行列式类

有丘直方

[pre lang="ruby"]#----------------------------------------------------------------
# ### Determinant
#----------------------------------------------------------------
#     行列式类。用于计算、处理、表达行列式的类。
#----------------------------------------------------------------
class Determinant <
#----------------------------------------------------------------
# ## 超类
#----------------------------------------------------------------
#     Object
#----------------------------------------------------------------
Object
#----------------------------------------------------------------
# ## 包含的模块
#----------------------------------------------------------------
#     Comparable
#----------------------------------------------------------------
include(Comparable)
#----------------------------------------------------------------
# ## 类方法
#----------------------------------------------------------------
    class << self
#----------------------------------------------------------------
# # Determinant[row1, row2, …]
#----------------------------------------------------------------
#     基本同Determinant.new。不同之处在于此方法的参数是多个长度相等的数组，
# 而Determinant.new的参数是嵌套数组。
#----------------------------------------------------------------
    def [](*rows)
        return new(rows)
    end
#----------------------------------------------------------------
# # Determinant.new(rows)
#----------------------------------------------------------------
#     生成一个与rows内容相同的行列式。
#     rows是一个嵌套数组，且rows内的数组的长度应与rows的长度相等，否则会引
# 发TypeError。
#----------------------------------------------------------------
        def new(rows)
            super(rows)
        end
    end
#----------------------------------------------------------------
# ## 方法
#----------------------------------------------------------------
#----------------------------------------------------------------
# # size
#----------------------------------------------------------------
#     返回行列式的阶数。
#----------------------------------------------------------------
    def size
        return rows.size
    end
#----------------------------------------------------------------
# # order
#----------------------------------------------------------------
#     同size。
#----------------------------------------------------------------
    def order
        return size
    end
#----------------------------------------------------------------
# # cofactor(x, y)
#----------------------------------------------------------------
#     返回在x、y位置的余子式。
#----------------------------------------------------------------
    def cofactor(x, y)
        ary = rows.clone
        ary.delete_at(x)
        for i in 0...(order - 1)
            ary = i >= x ? rows.clone : rows[i + 1].clone
            ary.delete_at(y)
        end
        return Determinant.new(ary)
    end
#----------------------------------------------------------------
# # cof(x, y)
#----------------------------------------------------------------
#     同cofactor。
#----------------------------------------------------------------
    def cof(x, y)
        return cofactor(x, y)
    end
#----------------------------------------------------------------
# # algebraic_cofactor(x, y)
#----------------------------------------------------------------
#     返回在x、y位置的代数余子式。
#----------------------------------------------------------------
    def algebraic_cofactor(x, y)
        return (-1) ** (x + y) * cofactor(x, y).value
    end
#----------------------------------------------------------------
# # alc(x, y)
#----------------------------------------------------------------
#     同algebraic_cofactor。
#----------------------------------------------------------------
    def alc(x, y)
        return algebraic_cofactor(x, y)
    end
#----------------------------------------------------------------
# # at(x, y)
#----------------------------------------------------------------
#     返回在x、y位置的元素。
#----------------------------------------------------------------
    def at(x, y)
        return rows[x][y]
    end
#----------------------------------------------------------------
# # self[x, y]
#----------------------------------------------------------------
#     同at。
#----------------------------------------------------------------
    def [](x, y)
        return at(x, y)
    end
#----------------------------------------------------------------
# # self[x, y] = val
#----------------------------------------------------------------
#     为在x、y位置的元素赋值代入val。
#     返回val。
#----------------------------------------------------------------
    def []=(x, y, val)
        return rows[x][y] = val
    end
#----------------------------------------------------------------
# # rows = val
#----------------------------------------------------------------
#     为rows赋值代入val。
#     返回val。
#----------------------------------------------------------------
    def rows=(val)
        raise(TypeError) if !val.is_a?(Array)
        for i in val
            raise(TypeError) if !i.is_a?(Array) or i.size != val.size
        end
        return @rows = val
    end
#----------------------------------------------------------------
# # row(x)
#----------------------------------------------------------------
#     返回与第x行内容相同的数组。
#     请参考column。
#----------------------------------------------------------------
    def row(x)
        return rows[x]
    end
#----------------------------------------------------------------
# # column(y)
#----------------------------------------------------------------
#     返回与第y列内容相同的数组。
#     请参考row。
#----------------------------------------------------------------
    def column(y)
        ary = []
        for i in rows
            ary += i[y].to_a
        end
        return ary
    end
#----------------------------------------------------------------
# # change_row(x, ary)
#----------------------------------------------------------------
#     把第x行的内容代替为数组ary的内容。返回self。
#     ary的元素的数量必须与行列式的阶数相等，否则会引发TypeError。
#     请参考change_column。
#----------------------------------------------------------------
    def change_row(x, ary)
        rows[x] = ary
        return self
    end
#----------------------------------------------------------------
# # change_column(y, ary)
#----------------------------------------------------------------
#     把第y列的内容代替为数组ary的内容。返回self。
#     ary的元素的数量必须与行列式的阶数相等，否则会引发TypeError。
#     请参考change_row。
#----------------------------------------------------------------
    def change_column(y, ary)
        for i in 0...size
            rows[y] = ary
        end
        return self
    end
#----------------------------------------------------------------
# # transpose
#----------------------------------------------------------------
#     转置变换。指把行列式逆时针旋转1/4圈。返回self。
#     行列式的性质1：行列式转置后，其值不变（请参考value）。
#----------------------------------------------------------------
    def transpose
        det = self
        for i in 0...size
            change_column(i, det.row(i))
        end
        return self
    end
#----------------------------------------------------------------
# # exchange_row(x, x_ed)
#----------------------------------------------------------------
#     换法变换。指把第x行与第x_ed行的位置互换。返回self。
#     行列式的性质2：互换行列式的两行（列），行列式变号（请参考value）。
#     请参考exchange_column。
#----------------------------------------------------------------
    def exchange_row(x, x_ed)
        a = row(x)
        b = row(x_ed)
        change_row(x, b)
        change_row(x_ed, a)
        return self
    end
#----------------------------------------------------------------
# # exchange_column(y, y_ed)
#----------------------------------------------------------------
#     换法变换。指把第y列与第y_ed列的位置互换。返回self。
#     请参考exchange_row。
#----------------------------------------------------------------
    def exchange_column(y, y_ed)
        a = column(y)
        b = column(x_ed)
        change_column(y, b)
        change_column(y_ed, a)
        return self
    end
#----------------------------------------------------------------
# # multiply_row(x, num)
#----------------------------------------------------------------
#     倍法变换。指把第x行的每一个元素都乘num。返回self。
#     行列式的性质3：行列式的某一行（列）的所有元素都乘k，等同于用k乘这个行
# 列式（请参考value）。
#     请参考multiply_column。
#----------------------------------------------------------------
    def multiply_row(x, num)
        for i in 0...size
            self[x, i] *= num
        end
        return self
    end
#----------------------------------------------------------------
# # multiply_column(y, num)
#----------------------------------------------------------------
#     倍法变换。指把第y列的每一个元素都乘num。返回self。
#     请参考multiply_row。
#----------------------------------------------------------------
    def multiply_column(y, num)
        for i in 0...size
            self[i, y] *= num
        end
        return self
    end
#----------------------------------------------------------------
# # transform_row(x, x_ed, num)
#----------------------------------------------------------------
#     消法变换。指把第x行的每一个元素都加上第x_ed行的对应元素乘num的积。返
# 回self。
#     行列式的性质5：把行列式的某一行（列）的元素都乘k后加到另一行（列）的对
# 应元素上去，行列式的值不变（请参考value）。
#     （行列式的性质4：如果行列式的某一行（列）的元素都是多项式，就可以把该
# 行列式拆成多个行列式的和（请参考value）。）
#     请参考transform_column。
#----------------------------------------------------------------
    def transform_row(x, x_ed, num)
        raise(TypeError) if x == x_ed or x >= size or x_ed >= size
        for i in 0...size
            self[x, i] += row(x_ed) * num
        end
        return self
    end
#----------------------------------------------------------------
# # transform_column(y, y_ed, num)
#----------------------------------------------------------------
#     消法变换。指把第x行的每一个元素都加上第x_ed行的对应元素乘num的积。返
# 回self。
#     请参考transform_row。
#----------------------------------------------------------------
    def transform_column(y, y_ed, num)
        raise(TypeError) if y == y_ed or y >= size or y_ed >= size
        for i in 0...size
            self[i, y] += y(y_ed) * num
        end
        return self
    end
#----------------------------------------------------------------
# # value(expand_calculate = false)
#----------------------------------------------------------------
#     返回行列式的值。当expand_calculate为true时计算时间较长但没有任何误
# 差，为false时计算时间较短但在阶数较大时会有细微误差。
#     若行列式中没有浮点数则返回整数，否则返回浮点数。
#----------------------------------------------------------------
    def value(expand_calculate = false)
        f = false
        for i in 0...size
            for j in 0...size
                if at(i, j).is_a?(Float)
                    f = true
                break
            end
            break if f == true
        end
        if expand_calculate
            if order == 1
                return at(0, 0)
            else
                val = 0
                for i in 0...order
                    val += at(0, i) * algebraic_cofactor(0, i)
                end
            end
        else
            det = self.dup
            for i in 0...size
                j = 0
                i.times do
                    if at(j, j) == 0
                        return 0.0 if f
                        return 0
                    end
                    det.transform_row(i, j, -(at(i, j) / at(j, j).to_f))
                    j += 1
                end
            end
            val = 1
            for i in 0...size
                val *= det[i, i]
            end
        end
        return val.to_i unless f
        return val
    end
#----------------------------------------------------------------
# # inspect
#----------------------------------------------------------------
#     返回表达行列式的字符串。
#----------------------------------------------------------------
    def inspect
        str = ""
        for i in rows
            str += i.inspect + "\n"
        end
        return str
    end
#----------------------------------------------------------------
# # to_s
#----------------------------------------------------------------
#     同inspect。
#----------------------------------------------------------------
    def to_s
        return inspect
    end
#----------------------------------------------------------------
# # to_a
#----------------------------------------------------------------
#     同rows。
#----------------------------------------------------------------
    def to_a
        return rows
    end
#----------------------------------------------------------------
# # to_f
#----------------------------------------------------------------
#     同value.to_f。
#----------------------------------------------------------------
    def to_f
        return value.to_f
    end
#----------------------------------------------------------------
# # to_i
#----------------------------------------------------------------
#     同value.to_i。
#----------------------------------------------------------------
    def to_i
        return value.to_i
    end
#----------------------------------------------------------------
# # self <=> other
#----------------------------------------------------------------
#     对self和other进行比较。若self.value较大时返回正数，若相等时返回0，
# 若较小时返回负数。
#----------------------------------------------------------------
    def <=>(other)
        if other.is_a?(Determinant)
            return value <=> other.value
        else
            return value <=> other
        end
    end
#----------------------------------------------------------------
# # eql?(other)
#----------------------------------------------------------------
#     若rows与other的rows用eql?比较为true则返回true，否则返回false。
#----------------------------------------------------------------
    def eql?(other)
        if other.is_a?(Determinant)
            return rows.eql?(other.rows)
        else
            return false
        end
    end
#----------------------------------------------------------------
# ## 属性
#----------------------------------------------------------------
#----------------------------------------------------------------
# # rows
#----------------------------------------------------------------
#     返回与行列式的内容一样的嵌套数组。
#     请参考Determinant.new
#----------------------------------------------------------------
    attr_accessor(:rows)
#----------------------------------------------------------------
# ## 私有方法
#----------------------------------------------------------------
#----------------------------------------------------------------
# # initialiaze(rows)
#----------------------------------------------------------------
#     行列式对象被建立之后初始化的方法，该方法的参数会全部传递给Determinant
# .new。这里定义了rows属性的初始值。
#----------------------------------------------------------------
    def initialize(rows)
        raise(TypeError) unless rows.is_a?(Array)
        for i in rows
            raise(TypeError) if !i.is_a?(Array) or i.size != rows.size
        end
        @rows = rows
    end
#----------------------------------------------------------------
# # initialiaze_copy(det)
#----------------------------------------------------------------
#     行列式对象被复制之后初始化的方法。
#     行列式的克隆中，它的rows和rows内部的数组都是原行列式对象的rows和rows
# 内部的数组的克隆。其余信息的克隆都和一般的对象相同，即Object类内的定义。
#----------------------------------------------------------------
    def initialize_copy(det)
        det.rows = rows.dup
        for i in 0...size
            det.rows = rows.dup
        end
    end
end[/pre]大更，增加了注释和大量方法，value方法更加高明了。谢谢。

正太君

该类最关键最重要的方法竟然有BUG...

有丘直方

1. def cofactor(x, y)
   
2.         p ary = row.clone,3
   
3.         ary.delete_at(x)
   
4.         p row,4
   
5.         for i in 0...(order - 1)
   
6.             ary[i].delete_at(y)
   
7.         p ary,5
   
8.         end
   
9.         p row,6
   
10.         return Determinant.new(ary)
    
11.     end

复制代码

我发现出现bug的关键在于这里第四行和第九行的输出结果不一样。真是让人匪夷所思！

RyanBern

我想借助计算机计算一个24阶行列式的值，于是用了楼主的代码：
[pre lang="Ruby"]N = 24
a = Array.new(N){Array.new(N)}
for i in 0...N
  for j in 0...N
    a[j] = 1.0 / (i + j + 1)
  end
end

det = Determinant.new(a)
p det.value[/pre]
结果算了半天也没算出来，这是怎么回事啊？

---

以上都是在卖萌（包括刚才的点评）。我来给楼主算一笔账：
楼主使用行列式展开计算行列式的值，假设f(n)为行列式阶数为n时所需的运算量（仅仅考虑乘法），按照行列展开的定义，我们有如下递推式
f(n)=n*(1+f(n-1))

如果忽略其中的1，那么我们有f(n)>nf(n-1)，根据递推式，f(n)>n!。

当 n = 24 时，24!约为6.2E+23，假设计算机一秒能算1E+10次乘法（百亿次），则算出这个行列式至少要200万年。

所以楼主所说“用笔算算1年也算不出来”其实这个远远不够呢。

但是求行列式是数值运算中非常基础的运算，如果所有软件中的算法都是这个效率，那么科研人员也不用做别的了。

刚才打开了 MATLAB，计算det(A)，瞬间给出了结果。它的算法肯定不是楼主给出的算法。

请自行 google 计算行列式的正确姿势。

---

代码中间某个 if 少了 end，望改正。

然后我随便拿了两个矩阵看了看，结果均不一致。
[pre lang="Ruby"]N = 5
arr = Array.new(5){Array.new(5)}
=begin
(0...N).each do |i|
  (0...N).each do |j|
    arr[j] = 1.0 / (i + j + 1)
  end
end
=end
arr[0] = [17, 24, 1, 8 ,15]
arr[1] = [23, 5, 7, 14,16]
arr[2] = [4, 6, 13,20, 22]
arr[3] = [10, 12, 19, 21, 3]
arr[4] = [11, 18, 25, 2, 9]

det = Determinant.new(arr)
p det.value(true)
p det.value(false)
[/pre]
[pre lang="SHELL"]ruby det.rb
1049811
-951950[/pre]
用 MATLAB 计算得此行列式值为 5.0700e+06

另外请测试一下另外的一个行列式（我代码中=begin~=end里注释的部分），这个行列式比较难算，建议先把这个先弄出来。

有丘直方

RyanBern 发表于 2016-8-26 21:34
我想借助计算机计算一个24阶行列式的值，于是用了楼主的代码：
N = 24
a = Array.new(N){Array.new(N)}

为了做这个，我花了一天时间把行列式研究了个透。我还找讲量子的理论物理书，看一下矩阵的性质。其实矩阵跟行列式几乎不着关系……
那天下午，我作为一个普通的七年级学生，做了很多额外的行列式的题目——本来初中阶段就不应该学这个。
补了一天的姿势之后，我终于总结出了把行列式变成三角形的一般方法（从1开始数而非从0，为了适合一般的数学意义；r表示行矢量，c表示列矢量，a表示元素，n表示阶数）：
先用第1行减第2行的对应元素乘第2行第1个元素除以第1行第1个元素的商的积。即：r(2) -= r(1) * (a(2,1) / a(1,1))。根据行列式性质5，行列式的值不变。
再r(3) -= r(1) * (a(3,1) / a(1,1))。再r(4) -= r(1) * (a(4,1) / a(1,1))。以此类推，到r(n) -= r(1) * (a(n,1) / a(1,1))。
然后r(3) -= r(2) * (a(3,2) / a(2,2))。再r(4) -= r(2) * (a(4,2) / a(2,2))。以此类推。这个式子现在很常用，我们用函数d(a,b)来表示。
像上面这样以此类推，我们得到d(n,n-1)是最后一个式子。我们总结一下：
d(2,1);d(3,1);d(4,1);...;d(n,1)
d(3,2);d(4,2);d(5,2);...;d(n,2)
d(4,3);d(5,3);......
......
d(n-1,n-2);d(n,n-2)
d(n,n-1)
好，现在从0开始数，再用上ruby语言，再进一步总结：
for i in 0...n
  for j in 0...i
    d(i,j)
  end
end
看上去简单的很是吧？
但是这么简单的东西榨干了我那么多时间！后来，我用一个行列式
| 1 2 3 |
| 9 8 7 |
| 6 6 5 |
测试了一下，得到了正确结果。正确结果是6678还是6687来着，反正我的代码算对了。
后来你说，我的代码有问题，我就把代码复制回来，又试了一次这个6678行列式，结果得到了-20……我严重怀疑我的iPad被黑客袭击了。这真是奇妙的很啊。
现在我陷入了瓶颈，不知道怎么修复了……
下面是我在你提出bug时未完更新。发现有一处非常奇怪的ArgErr，说我多了一个参数。

1. #----------------------------------------------------------------
   
2. # ### Determinant
   
3. #----------------------------------------------------------------
   
4. #     行列式类。用于计算、处理、表达行列式的类。
   
5. #----------------------------------------------------------------
   
6. class Determinant <
   
7. #----------------------------------------------------------------
   
8. # ## 超类
   
9. #----------------------------------------------------------------
   
10. #     Object
    
11. #----------------------------------------------------------------
    
12. Object
    
13. #----------------------------------------------------------------
    
14. # ## 包含的模块
    
15. #----------------------------------------------------------------
    
16. #     Comparable
    
17. #----------------------------------------------------------------
    
18. include(Comparable)
    
19. #----------------------------------------------------------------
    
20. # ## 类方法
    
21. #----------------------------------------------------------------
    
22.     class << self
    
23. #----------------------------------------------------------------
    
24. # # Determinant[row1, row2, ...]
    
25. #----------------------------------------------------------------
    
26. #     基本同Determinant.new。不同之处在于此方法的参数是多个长度相等的数组，
    
27. # 而Determinant.new的参数是嵌套数组。
    
28. #----------------------------------------------------------------
    
29.         def [](*rows)
    
30.             return(new(rows))
    
31.         end
    
32. #----------------------------------------------------------------
    
33. # # Determinant.new(rows)
    
34. #----------------------------------------------------------------
    
35. #     生成一个与rows内容相同的行列式。
    
36. #     rows是一个嵌套数组，且rows内的数组的长度应与rows的长度相等，否则会引
    
37. # 发TypeError。
    
38. #----------------------------------------------------------------
    
39.         def new(rows)
    
40.             super(rows)
    
41.         end
    
42. #----------------------------------------------------------------
    
43. # # Determinant.rows(rows, copy = true)
    
44. #----------------------------------------------------------------
    
45. #     基本同Determinant.new。copy为true时使用rows.dup，否则直接使用
    
46. # rows。
    
47. #     请参考Determinant.columns。
    
48. #----------------------------------------------------------------
    
49.         def rows(rows, copy = true)
    
50.             return(new(rows.dup)) if copy
    
51.             return(new(rows))
    
52.         end
    
53. #----------------------------------------------------------------
    
54. # # Determinant.columns(columns, copy = true)
    
55. #----------------------------------------------------------------
    
56. #     生成一个与columns内容相同的行列式。相当于Determinant.rows
    
57. # (columns, copy).transpose!。copy为true时使用columns.dup，否则直接使
    
58. # 用columns。
    
59. #     请参考Determinant.rows。
    
60. #----------------------------------------------------------------
    
61.         def columns(columns, copy = true)
    
62.             return(rows(columns, copy).transpose!)
    
63.         end
    
64. #----------------------------------------------------------------
    
65. # # Determinant.diagonal(value1, value2, ...)
    
66. #   Determinant.diagonal(values)
    
67. #----------------------------------------------------------------
    
68. #     生成一个对角线内容分别是value1、value2等或数组values的元素的行列式。
    
69. # 其他元素都为0。
    
70. #----------------------------------------------------------------
    
71.         def diagonal(*values)
    
72.             ary = (values.size == 1 and values[0].is_a?(Array)) ? values[0] : values
    
73.             j = 0
    
74.             det = zero(size)
    
75.             for i in ary
    
76.                 det[j, j] = i
    
77.                 j += 1
    
78.             end
    
79.             return(det)
    
80.         end
    
81. #----------------------------------------------------------------
    
82. # # Determinant.scalar(size, value)
    
83. #----------------------------------------------------------------
    
84. #     生成一个对角线元素全部为value的size阶行列式。其他元素都为0。
    
85. #----------------------------------------------------------------
    
86.         def scalar(size, value)
    
87.             det = zero(size)
    
88.             for i in 0...size
    
89.                 det[i, i] = value
    
90.             end
    
91.             return(det)
    
92.         end
    
93. #----------------------------------------------------------------
    
94. # # Determinant.identity(size)
    
95. #----------------------------------------------------------------
    
96. #     生成一个对角线元素全为1的size阶行列式。其他元素都为0。
    
97. #----------------------------------------------------------------
    
98.         def identity(size)
    
99.             return(scalac(size, 1))
    
100.         end
     
101. #----------------------------------------------------------------
     
102. # # Determinant.unit(size)
     
103. #----------------------------------------------------------------
     
104. #     同Determinant.identity。
     
105. #----------------------------------------------------------------
     
106.         def unit(size)
     
107.             return(identity(size))
     
108.         end
     
109. #----------------------------------------------------------------
     
110. # # Determinant.I(size)
     
111. #----------------------------------------------------------------
     
112. #     同Determinant.identity。
     
113. #----------------------------------------------------------------
     
114.         def I(size)
     
115.             return(identity(size))
     
116.         end
     
117. #----------------------------------------------------------------
     
118. # # Determinant.zero(size)
     
119. #----------------------------------------------------------------
     
120. #     生成一个元素全为0的size阶行列式。
     
121. #----------------------------------------------------------------
     
122.         def zero(size)
     
123.             det = new(Array.new(size) { Array.new(size) })
     
124.             for i in 0...size
     
125.                 det[i, i] = 0
     
126.             end
     
127.             return(det)
     
128.         end
     
129.     end
     
130. #----------------------------------------------------------------
     
131. # ## 方法
     
132. #----------------------------------------------------------------
     
133. #----------------------------------------------------------------
     
134. # # size
     
135. #----------------------------------------------------------------
     
136. #     返回行列式的阶数。相当于rows.size。
     
137. #----------------------------------------------------------------
     
138.     def size
     
139.         return(rows.size)
     
140.     end
     
141. #----------------------------------------------------------------
     
142. # # order
     
143. #----------------------------------------------------------------
     
144. #     同size。
     
145. #----------------------------------------------------------------
     
146.     def order
     
147.         return(size)
     
148.     end
     
149. #----------------------------------------------------------------
     
150. # # cofactor(x, y)
     
151. #----------------------------------------------------------------
     
152. #     返回在x、y位置的余子式。
     
153. #----------------------------------------------------------------
     
154.     def cofactor(x, y)
     
155.         raise(TypeError) if x >= size or y >= size
     
156.         ary = rows.dup
     
157.         ary.delete_at(x)
     
158.         for i in 0...(order - 1)
     
159.             ary[i] = i >= x ? rows[i].clone : rows[i + 1].clone
     
160.             ary[i].delete_at(y)
     
161.         end
     
162.         return(Determinant.new(ary))
     
163.     end
     
164. #----------------------------------------------------------------
     
165. # # cof(x, y)
     
166. #----------------------------------------------------------------
     
167. #     同cofactor。
     
168. #----------------------------------------------------------------
     
169.     def cof(x, y)
     
170.         return(cofactor(x, y))
     
171.     end
     
172. #----------------------------------------------------------------
     
173. # # algebraic_cofactor(x, y)
     
174. #----------------------------------------------------------------
     
175. #     返回在x、y位置的代数余子式。
     
176. #----------------------------------------------------------------
     
177.     def algebraic_cofactor(x, y)
     
178.         raise(TypeError) if x >= size or y >= size
     
179.         return((-1) ** (x + y) * cofactor(x, y).value)
     
180.     end
     
181. #----------------------------------------------------------------
     
182. # # alc(x, y)
     
183. #----------------------------------------------------------------
     
184. #     同algebraic_cofactor。
     
185. #----------------------------------------------------------------
     
186.     def alc(x, y)
     
187.         return(algebraic_cofactor(x, y))
     
188.     end
     
189. #----------------------------------------------------------------
     
190. # # at(x, y)
     
191. #----------------------------------------------------------------
     
192. #     返回在x、y位置的元素。
     
193. #----------------------------------------------------------------
     
194.     def at(x, y)
     
195.         return(nil) if x >= size or y >= size
     
196.         return(rows[x][y])
     
197.     end
     
198. #----------------------------------------------------------------
     
199. # # self[x, y]
     
200. #----------------------------------------------------------------
     
201. #     同at。
     
202. #----------------------------------------------------------------
     
203.     def [](x, y)
     
204.         return(nil) if x >= size or y >= size
     
205.         return(at(x, y))
     
206.     end
     
207. #----------------------------------------------------------------
     
208. # # self[x, y] = val
     
209. #----------------------------------------------------------------
     
210. #     为在x、y位置的元素赋值代入val。
     
211. #     返回val。
     
212. #----------------------------------------------------------------
     
213.     def []=(x, y, val)
     
214.         raise(TypeError) if x >= size or y >= size
     
215.         return(rows[x][y] = val)
     
216.     end
     
217. #----------------------------------------------------------------
     
218. # # rows = val
     
219. #----------------------------------------------------------------
     
220. #     为rows赋值代入val。
     
221. #     返回val。
     
222. #----------------------------------------------------------------
     
223.     def rows=(val)
     
224.         raise(TypeError) if !val.is_a?(Array)
     
225.         for i in val
     
226.             raise(TypeError) if !i.is_a?(Array) or i.size != val.size
     
227.         end
     
228.         return(@rows = val)
     
229.     end
     
230. #----------------------------------------------------------------
     
231. # # row(x)
     
232. #----------------------------------------------------------------
     
233. #     返回与第x行内容相同的数组。
     
234. #     请参考column。
     
235. #----------------------------------------------------------------
     
236.     def row(x)
     
237.         raise(TypeError) if x >= size
     
238.         return(rows[x])
     
239.     end
     
240. #----------------------------------------------------------------
     
241. # # column(y)
     
242. #----------------------------------------------------------------
     
243. #     返回与第y列内容相同的数组。
     
244. #     请参考row。
     
245. #----------------------------------------------------------------
     
246.     def column(y)
     
247.         raise(TypeError) if y >= size
     
248.         ary = []
     
249.         for i in rows
     
250.             ary += i[y].to_a
     
251.         end
     
252.         return(ary)
     
253.     end
     
254. #----------------------------------------------------------------
     
255. # # change_row(x, ary)
     
256. #----------------------------------------------------------------
     
257. #     返回把第x行的内容代替为数组ary的内容后的行列式。
     
258. #     ary的元素的数量必须与行列式的阶数相等，否则会引发TypeError。
     
259. #     请参考change_column。
     
260. #----------------------------------------------------------------
     
261.     def change_row(x, ary)
     
262.         raise(TypeError) if ary.size != size or x >= size
     
263.         det = dup
     
264.         det.rows[x] = ary
     
265.         return(det)
     
266.     end
     
267. #----------------------------------------------------------------
     
268. # # change_row!(x, ary)
     
269. #----------------------------------------------------------------
     
270. #     基本同change_row，不同之处在于change_row!有破坏性。
     
271. #     请参考change_column!。
     
272. #----------------------------------------------------------------
     
273.     def change_row!(x, ary)
     
274.         raise(TypeError) if ary.size != size or x >= size
     
275.         rows[x] = ary
     
276.         return(self)
     
277.     end
     
278. #----------------------------------------------------------------
     
279. # # change_column(y, ary)
     
280. #----------------------------------------------------------------
     
281. #     返回把第y列的内容代替为数组ary的内容后的行列式。
     
282. #     ary的元素的数量必须与行列式的阶数相等，否则会引发TypeError。
     
283. #     请参考change_row。
     
284. #----------------------------------------------------------------
     
285.     def change_column(y, ary)
     
286.         raise(TypeError) if ary.size != size or y >= size
     
287.         det = dup
     
288.         for i in 0...size
     
289.             det[i, y] = ary[i]
     
290.         end
     
291.         return(det)
     
292.     end
     
293. #----------------------------------------------------------------
     
294. # # change_column!(y, ary)
     
295. #----------------------------------------------------------------
     
296. #     基本同change_column，不同之处在于change_column!有破坏性。
     
297. #     请参考change_row!。
     
298. #----------------------------------------------------------------
     
299.     def change_column!(y, ary)
     
300.         raise(TypeError) if ary.size != size or y >= size
     
301.         for i in 0...size
     
302.             self[i, y] = ary[i]
     
303.         end
     
304.         return(self)
     
305.     end
     
306. #----------------------------------------------------------------
     
307. # # collect { |item| ... }
     
308. #----------------------------------------------------------------
     
309. #     为行列式中的每个元素分别进行块的迭代操作，并以行列式的形式返回迭代操作
     
310. # 的结果。
     
311. #----------------------------------------------------------------
     
312.     def collect
     
313.         det = Determinant.zero(size)
     
314.         for i in 0...size
     
315.             for j in 0...size
     
316.                 det[i, j] = yield(at(i, j))
     
317.             end
     
318.         end
     
319.         return(det)
     
320.     end
     
321. #----------------------------------------------------------------
     
322. # # map
     
323. #----------------------------------------------------------------
     
324. #     同collect。
     
325. #----------------------------------------------------------------
     
326.     def map
     
327.         return(collect)
     
328.     end
     
329. #----------------------------------------------------------------
     
330. # # collect! { |item| ... }
     
331. #----------------------------------------------------------------
     
332. #     基本同collect，不同之处在于collect!有破坏性。
     
333. #----------------------------------------------------------------
     
334.     def collect!
     
335.         for i in 0...size
     
336.             for j in 0...size
     
337.                 self[i, j] = yield(at(i, j))
     
338.             end
     
339.         end
     
340.         return(self)
     
341.     end
     
342. #----------------------------------------------------------------
     
343. # # map!
     
344. #----------------------------------------------------------------
     
345. #     同collect!。
     
346. #----------------------------------------------------------------
     
347.     def map!
     
348.         return(collect!)
     
349.     end
     
350. #----------------------------------------------------------------
     
351. # # transpose
     
352. #----------------------------------------------------------------
     
353. #     转置变换。指把行列式逆时针旋转1/4圈。返回变换后的行列式。
     
354. #     行列式的性质1：行列式转置后，其值不变（请参考value）。
     
355. #----------------------------------------------------------------
     
356.     def transpose
     
357.         det = dup
     
358.         for i in 0...size
     
359.             det.change_column(i, row(i))
     
360.         end
     
361.         return(det)
     
362.     end
     
363. #----------------------------------------------------------------
     
364. # # transpose!
     
365. #----------------------------------------------------------------
     
366. #     基本同transpose，不同之处在于transpose!有破坏性。
     
367. #----------------------------------------------------------------
     
368.     def transpose!
     
369.         det = dup
     
370.         for i in 0...size
     
371.             change_column(i, det.row(i))
     
372.         end
     
373.         return(self)
     
374.     end
     
375. end
     
376. #----------------------------------------------------------------
     
377. # # exchange_row(x, x_ed)
     
378. #----------------------------------------------------------------
     
379. #     换法变换。指把第x行与第x_ed行的位置互换。返回变换后的行列式。
     
380. #     行列式的性质2：互换行列式的两行（列），行列式变号（请参考value）。
     
381. #     请参考exchange_column。
     
382. #----------------------------------------------------------------
     
383.     def exchange_row(x, x_ed)
     
384.         raise(TypeError) if x >= size or x_ed >= size
     
385.         det = dup
     
386.         a = row(x)
     
387.         b = row(x_ed)
     
388.         det.change_row!(x, b)
     
389.         det.change_row!(x_ed, a)
     
390.         return(det)
     
391.     end
     
392. #----------------------------------------------------------------
     
393. # # exchange_row!
     
394. #----------------------------------------------------------------
     
395. #     基本同exchange_row，不同之处在于exchange_row!有破坏性。
     
396. #     请参考exchange_column!。
     
397. #----------------------------------------------------------------
     
398.     def exchange_row!(x, x_ed)
     
399.         raise(TypeError) if x >= size or x_ed >= size
     
400.         a = row(x)
     
401.         b = row(x_ed)
     
402.         change_row!(x, b)
     
403.         change_row!(x_ed, a)
     
404.         return(self)
     
405.     end
     
406. #----------------------------------------------------------------
     
407. # # exchange_column(y, y_ed)
     
408. #----------------------------------------------------------------
     
409. #     换法变换。指把第y列与第y_ed列的位置互换。返回变换后的行列式。
     
410. #     请参考exchange_row。
     
411. #----------------------------------------------------------------
     
412.     def exchange_column(y, y_ed)
     
413.         raise(TypeError) if y >= size or y_ed >= size
     
414.         det = dup
     
415.         a = column(y)
     
416.         b = column(y_ed)
     
417.         det.change_column!(y, b)
     
418.         det.change_column!(y_ed, a)
     
419.         return(det)
     
420.     end
     
421. #----------------------------------------------------------------
     
422. # # exchange_column!
     
423. #----------------------------------------------------------------
     
424. #     基本同exchange_column，不同之处在于exchange_column!有破坏性。
     
425. #----------------------------------------------------------------
     
426.     def exchange_column!(y, y_ed)
     
427.         raise(TypeError) if y >= size or y_ed >= size
     
428.         a = column(y)
     
429.         b = column(y_ed)
     
430.         change_column!(y, b)
     
431.         change_column!(y_ed, a)
     
432.         return(self)
     
433.     end
     
434. #----------------------------------------------------------------
     
435. # # multiply_row(x, num)
     
436. #----------------------------------------------------------------
     
437. #     倍法变换。指把第x行的每一个元素都乘num。返回变换后的行列式。
     
438. #     行列式的性质3：行列式的某一行（列）的所有元素都乘k，等同于用k乘这个行
     
439. # 列式（请参考value）。
     
440. #     请参考multiply_column。
     
441. #----------------------------------------------------------------
     
442.     def multiply_row(x, num)
     
443.         raise(TypeError) if x >= size
     
444.         det = dup
     
445.         for i in 0...size
     
446.             det[x, i] *= num
     
447.         end
     
448.         return(det)
     
449.     end
     
450. #----------------------------------------------------------------
     
451. # # multiply_row!
     
452. #----------------------------------------------------------------
     
453. #     基本同multiply_row，不同之处在于multiply_row!有破坏性。
     
454. #     请参考multilpy_column!。
     
455. #----------------------------------------------------------------
     
456.     def multiply_row!(x, num)
     
457.         raise(TypeError) if x >= size
     
458.         for i in 0...size
     
459.             self[x, i] *= num
     
460.         end
     
461.         return(self)
     
462.     end
     
463. #----------------------------------------------------------------
     
464. # # multiply_column(y, num)
     
465. #----------------------------------------------------------------
     
466. #     倍法变换。指把第y列的每一个元素都乘num。返回变换后的行列式。
     
467. #     请参考multiply_row。
     
468. #----------------------------------------------------------------
     
469.     def multiply_column(y, num)
     
470.         raise(TypeError) if y >= size
     
471.         det = dup
     
472.         for i in 0...size
     
473.             det[i, y] *= num
     
474.         end
     
475.         return(det)
     
476.     end
     
477. #----------------------------------------------------------------
     
478. # # multiply_column!
     
479. #----------------------------------------------------------------
     
480. #     基本同multiply_column，不同之处在于multiply_column!有破坏性。
     
481. #     请参考multiply_row!。
     
482. #----------------------------------------------------------------
     
483.     def multiply_column!(y, num)
     
484.         raise(TypeError) if y >= size
     
485.         for i in 0...size
     
486.             self[i, y] *= num
     
487.         end
     
488.         return(self)
     
489.     end
     
490. #----------------------------------------------------------------
     
491. # # transform_row(x, x_ed, num)
     
492. #----------------------------------------------------------------
     
493. #     消法变换。指把第x行的每一个元素都加上第x_ed行的对应元素乘num的积。返
     
494. # 回变换后的行列式。
     
495. #     行列式的性质5：把行列式的某一行（列）的元素都乘k后加到另一行（列）的对
     
496. # 应元素上去，行列式的值不变（请参考value）。
     
497. #     （行列式的性质4：如果行列式的某一行（列）的元素都是多项式，就可以把该
     
498. # 行列式拆成多个行列式的和（请参考value）。）
     
499. #     请参考transform_column。
     
500. #----------------------------------------------------------------
     
501.     def transform_row(x, x_ed, num)
     
502.         raise(TypeError) if x == x_ed or x >= size or x_ed >= size
     
503.         det = dup
     
504.         for i in 0...size
     
505.             det[x, i] += row(x_ed)[i] * num
     
506.         end
     
507.         return(det)
     
508.     end
     
509. #----------------------------------------------------------------
     
510. # # transform_row!
     
511. #----------------------------------------------------------------
     
512. #     基本同transform_row，不同之处在于transform_row!有破坏性。
     
513. #     请参考transform_column!。
     
514. #----------------------------------------------------------------
     
515.     def transform_row!(x, x_ed, num)
     
516.         raise(TypeError) if x == x_ed or x >= size or x_ed >= size
     
517.         for i in 0...size
     
518.             self[x, i] += row(x_ed)[i] * num
     
519.         end
     
520.         return(self)
     
521.     end
     
522. #----------------------------------------------------------------
     
523. # # transform_column(y, y_ed, num)
     
524. #----------------------------------------------------------------
     
525. #     消法变换。指把第y列的每一个元素都加上第y_ed列的对应元素乘num的积。返
     
526. # 回变换后的行列式。
     
527. #     请参考transform_row。
     
528. #----------------------------------------------------------------
     
529.     def transform_column(y, y_ed, num)
     
530.         raise(TypeError) if y == y_ed or y >= size or y_ed >= size
     
531.         det = dup
     
532.         for i in 0...size
     
533.             det[i, y] += y(y_ed)[i] * num
     
534.         end
     
535.         return(det)
     
536.     end
     
537. #----------------------------------------------------------------
     
538. # # transform_column!
     
539. #----------------------------------------------------------------
     
540. #     基本同transform_column，不同之处在于transform_column!有破坏性。
     
541. #     请参考transform_row!。
     
542. #----------------------------------------------------------------
     
543.     def transform_column!(y, y_ed, num)
     
544.         raise(TypeError) if y == y_ed or y >= size or y_ed >= size
     
545.         for i in 0...size
     
546.             self[i, y] += y(y_ed)[i] * num
     
547.         end
     
548.         return(self)
     
549.     end
     
550. #----------------------------------------------------------------
     
551. # # value(expand_calculate = false)
     
552. #----------------------------------------------------------------
     
553. #     返回行列式的值。当expand_calculate为true时计算时间较长但没有任何误
     
554. # 差，为false时计算时间较短但在阶数较大时会有细微误差。
     
555. #     若行列式中没有浮点数则返回整数，否则返回浮点数。
     
556. #----------------------------------------------------------------
     
557.     def value(expand_calculate = false)
     
558.         f = false
     
559.         for i in 0...size
     
560.             for j in 0...size
     
561.                 if at(i, j).is_a?(Float)
     
562.                     f = true
     
563.                     break
     
564.                 end
     
565.             end
     
566.             break if f == true
     
567.         end
     
568.         if expand_calculate
     
569.             if order == 1
     
570.                 return at(0, 0)
     
571.             else
     
572.                 val = 0
     
573.                 for i in 0...order
     
574.                     val += at(0, i) * algebraic_cofactor(0, i)
     
575.                 end
     
576.             end
     
577.         else
     
578.             det = dup
     
579.             for i in 0...size
     
580.                 j = 0
     
581.                 i.times do
     
582.                     if at(j, j) == 0
     
583.                         return 0.0 if f
     
584.                         return 0
     
585.                     end
     
586.                     det.transform_row!(i, j, -(at(i, j) / at(j, j).to_f))
     
587.                     j += 1
     
588.                 end
     
589.             end
     
590.             val = 1
     
591.             for i in 0...size
     
592.                 val *= det[i, i]
     
593.             end
     
594.         end
     
595.         return val.to_i unless f
     
596.         return val
     
597.     end
     
598. #----------------------------------------------------------------
     
599. # # inspect
     
600. #----------------------------------------------------------------
     
601. #     返回表达行列式的字符串。
     
602. #----------------------------------------------------------------
     
603.     def inspect
     
604.         l = []
     
605.         for i in 0...size
     
606.             l[i] = 0
     
607.             for j in 0...size
     
608.                 l[i] = at(j, i).size if at(j, i).size > l[i]
     
609.             end
     
610.         end
     
611.         str = ""
     
612.         for i in rows
     
613.             str += "| "
     
614.             k = 0
     
615.             for j in i
     
616.                 k += 1
     
617.                 str += j.inspect
     
618.                 str += ", " if k < size
     
619.                 str += " " * (l[k - 1] - j.inspect.size)
     
620.             end
     
621.             str += " |\n"
     
622.         end
     
623.         return str
     
624.     end
     
625. #----------------------------------------------------------------
     
626. # # to_s
     
627. #----------------------------------------------------------------
     
628. #     同inspect。
     
629. #----------------------------------------------------------------
     
630.     def to_s
     
631.         return inspect
     
632.     end
     
633. #----------------------------------------------------------------
     
634. # # to_a
     
635. #----------------------------------------------------------------
     
636. #     同rows。
     
637. #----------------------------------------------------------------
     
638.     def to_a
     
639.         return rows
     
640.     end
     
641. #----------------------------------------------------------------
     
642. # # to_f
     
643. #----------------------------------------------------------------
     
644. #     同value.to_f。
     
645. #----------------------------------------------------------------
     
646.     def to_f
     
647.         return value.to_f
     
648.     end
     
649. #----------------------------------------------------------------
     
650. # # to_i
     
651. #----------------------------------------------------------------
     
652. #     同value.to_i。
     
653. #----------------------------------------------------------------
     
654.     def to_i
     
655.         return value.to_i
     
656.     end
     
657. #----------------------------------------------------------------
     
658. # # self <=> other
     
659. #----------------------------------------------------------------
     
660. #     对self和other进行比较。若self.value较大时返回正数，若相等时返回0，
     
661. # 若较小时返回负数。
     
662. #----------------------------------------------------------------
     
663.     def <=>(other)
     
664.         if other.is_a?(Determinant)
     
665.             return value <=> other.value
     
666.         else
     
667.             return value <=> other
     
668.         end
     
669.     end
     
670. #----------------------------------------------------------------
     
671. # # eql?(other)
     
672. #----------------------------------------------------------------
     
673. #     若rows与other的rows用eql?比较为true则返回true，否则返回false。
     
674. #----------------------------------------------------------------
     
675.     def eql?(other)
     
676.         if other.is_a?(Determinant)
     
677.             return rows.eql?(other.rows)
     
678.         else
     
679.             return false
     
680.         end
     
681.     end
     
682. #----------------------------------------------------------------
     
683. # ## 属性
     
684. #----------------------------------------------------------------
     
685. #----------------------------------------------------------------
     
686. # # rows
     
687. #----------------------------------------------------------------
     
688. #     返回与行列式的内容一样的嵌套数组。
     
689. #     请参考Determinant.new
     
690. #----------------------------------------------------------------
     
691.     attr_accessor(:rows)
     
692. #----------------------------------------------------------------
     
693. # ## 私有方法
     
694. #----------------------------------------------------------------
     
695. #----------------------------------------------------------------
     
696. # # initialiaze(rows)
     
697. #----------------------------------------------------------------
     
698. #     行列式对象被建立之后初始化的方法，该方法的参数会全部传递给Determinant
     
699. # .new。这里定义了rows属性的初始值。
     
700. #----------------------------------------------------------------
     
701.     def initialize(rows)
     
702.         raise(TypeError) unless rows.is_a?(Array)
     
703.         for i in rows
     
704.             raise(TypeError) unless i.is_a?(Array) and i.size == rows.size
     
705.         end
     
706.         @rows = rows
     
707.     end
     
708. #----------------------------------------------------------------
     
709. # # initialiaze_copy(det)
     
710. #----------------------------------------------------------------
     
711. #     行列式对象被复制之后初始化的方法。
     
712. #     行列式的克隆中，它的rows和rows内部的数组都是原行列式对象的rows和rows
     
713. # 内部的数组的克隆。其余信息的克隆都和一般的对象相同，即Object类内的定义。
     
714. #----------------------------------------------------------------
     
715.     def initialize_copy(det)
     
716.         det.rows = rows.dup
     
717.         for i in 0...size
     
718.             det.rows[i] = rows[i].dup
     
719.         end
     
720.     end
     
721. end

复制代码