复数脚本 V1.9 修正log10、log bug 新增unpolar

3535

修正log10、log bug
只经过初步测试…指数只能整数…- -

方法

---

self + other
self - other
self * other
self / other  
self ** other
算术运算符。分别表示和（加）、差（减）、积（乘）、商（除）、幂（乘方）。
self == other
判断相等。
abs
绝对值。
polar
极式。
unploar
a = Complex(1,2).polar
p Complex(a[0],a[1]).unpolar # => Complex(1,2)

Math：
csc
sec
cot
sincostan的倒数。
qu
二次方程
fact
阶乘。
cbrt
立方根。
to_rad
度数转弧度。
to_deg
弧度转度数。
nCr
…这东西中文叫？
sqrt
exp
log
log10
sin
cos
tan
sinh
cosh
tanh
asin
acos
atan
asinh
acosh
atanh
扩展复数运算。

Object：
Complex(re,im)
建立一个复数。

Numeric：
to_c

1. class Complex
   
2.   attr(:re)
   
3.   attr(:im)
   
4.   def initialize(re, im)
   
5.     @re = re
   
6.     @im = im
   
7.   end
   
8.   def +(other)
   
9.     if other.class == Complex
   
10.       return Complex(@re+other.re, @im+other.im)
    
11.     else
    
12.       return Complex(@re+other, @im)
    
13.     end
    
14.   end
    
15.   def -(other)
    
16.     if other.class == Complex
    
17.       return Complex(@re-other.re, @im-other.im)
    
18.     else
    
19.       return Complex(@re-other, @im)
    
20.     end
    
21.   end
    
22.   def *(other)
    
23.     if other.class == Complex
    
24.       return Complex(@re*other.re-@im*other.im, @im*other.re+@re*other.im)
    
25.     else
    
26.       return Complex(@re*other, @im*other)
    
27.     end
    
28.   end
    
29.   def /(other)
    
30.     if other.class == Complex
    
31.       a = (@re*other.re+@im*other.im)/(other.re**2+other.im**2)
    
32.       b = (@im*other.re-@re*other.im)/(other.re**2+other.im**2)
    
33.       return Complex(a, b)
    
34.     else
    
35.       return Complex(@re/other, @im/other)
    
36.     end
    
37.   end
    
38.   def **(other)
    
39.     times = other
    
40.     if @im == 0
    
41.       return @re**other
    
42.     else
    
43.       if times >= 2
    
44.         result = self*self
    
45.         times -= 2
    
46.         result**times
    
47.       end
    
48.       return result
    
49.     end
    
50.   end
    
51.   def ==(other)
    
52.     a = @re == other.re
    
53.     b = @im == other.im
    
54.     if a == true and b == true
    
55.       return ture
    
56.     else
    
57.       return false
    
58.     end
    
59.   end
    
60.   def abs
    
61.     return Math.sqrt(@re**2+@im**2)
    
62.   end
    
63.   def polar
    
64.     z = Math.sqrt(@re**2 + @im ** 2)
    
65.     theta = Math.atan(Float(@im)/Float(@re))
    
66.     return z, theta
    
67.   end
    
68.   def unpolar
    
69.     r = @re
    
70.     theta = @im
    
71.     return Complex(r*Math.cos(theta), r*Math.sin(theta))
    
72.   end
    
73.   def coerce(numeric)
    
74.     if numeric.class != Complex
    
75.       return numeric.to_c, self
    
76.     end
    
77.   end
    
78.   def +@
    
79.     return self
    
80.   end
    
81.   def -@
    
82.     return Complex(-@re,-@im)
    
83.   end
    
84. end
    
85. class Object
    
86.   def Complex(re,lm)
    
87.     return Complex.new(re,lm)
    
88.   end
    
89. end
    
90. class Numeric
    
91.   def to_c
    
92.     return Complex(self, 0)
    
93.   end
    
94. end
    
95. #==============================================================================
    
96. # ■ Math
    
97. #------------------------------------------------------------------------------
    
98. # 　支持浮点运算的模块。
    
99. #==============================================================================
    
100. 
     
101. module Math
     
102.   #--------------------------------------------------------------------------
     
103.   # ● 恒量
     
104.   #--------------------------------------------------------------------------
     
105.   I = Complex(0,1)
     
106.   #--------------------------------------------------------------------------
     
107.   # ● Csc
     
108.   #--------------------------------------------------------------------------
     
109.   def self.csc(x)
     
110.     return 1/self.sin(x)
     
111.   end
     
112.   #--------------------------------------------------------------------------
     
113.   # ● Sec
     
114.   #--------------------------------------------------------------------------
     
115.   def self.sec(x)
     
116.     return 1/self.cos(x)
     
117.   end
     
118.   #--------------------------------------------------------------------------
     
119.   # ● Cot
     
120.   #--------------------------------------------------------------------------
     
121.   def self.cot(x)
     
122.     return 1/self.tan(x)
     
123.   end
     
124.   #--------------------------------------------------------------------------
     
125.   # ● 二次方程一
     
126.   #--------------------------------------------------------------------------
     
127.   def self.qu(a, b, c)
     
128.     y1 = (-1*b + self.sqrt(b*b - 4*a*c)) / 2*a
     
129.     y2 = (-1*b - self.sqrt(b*b - 4*a*c)) / 2*a
     
130.     if y1 == y2
     
131.       return y1
     
132.     else
     
133.       return y1,y2
     
134.     end
     
135.   end
     
136.   #--------------------------------------------------------------------------
     
137.   # ● 阶乘
     
138.   #--------------------------------------------------------------------------
     
139.   def self.fact(numb)
     
140.     if numb == 0
     
141.       return 1
     
142.     end
     
143.     if numb.is_a?(Integer)
     
144.       for i in 1...numb
     
145.         numb *=  i
     
146.       end
     
147.       return numb
     
148.     else
     
149.       result = self.sqrt(2*PI*numb) * (numb/E)**numb * (1+1/12*numb+1/288*numb**2-139/51840*numb**3-571/2488320*numb**4)
     
150.       return result
     
151.     end
     
152.   end
     
153.   #--------------------------------------------------------------------------
     
154.   # ● 立方根
     
155.   #--------------------------------------------------------------------------
     
156.   def self.cbrt(x)
     
157.     return self.exp(self.log(x)/3)
     
158.   end
     
159.   #--------------------------------------------------------------------------
     
160.   # ● 度数转弧度
     
161.   #--------------------------------------------------------------------------
     
162.   def self.to_rad(x)
     
163.     r = x*(PI/180)
     
164.     return r
     
165.   end
     
166.   #--------------------------------------------------------------------------
     
167.   # ● 弧度转度数
     
168.   #--------------------------------------------------------------------------
     
169.   def self.to_deg(x)
     
170.     d = x*(180/PI)
     
171.     return d
     
172.   end
     
173.   #--------------------------------------------------------------------------
     
174.   # ● nCr
     
175.   #--------------------------------------------------------------------------
     
176.   def self.nCr(n, r)
     
177.     return (self.fact(n))/(self.fact(r)*self.fact(n-r))
     
178.   end
     
179. end
     
180. #==============================================================================
     
181. # ■ Math
     
182. #------------------------------------------------------------------------------
     
183. # 　扩展复数运算。
     
184. #==============================================================================
     
185. class << Math
     
186.   alias old_sqrt sqrt
     
187.   alias old_exp exp
     
188.   alias old_log log
     
189.   alias old_log10 log10
     
190.   alias old_sin sin
     
191.   alias old_cos cos
     
192.   alias old_tan tan
     
193.   alias old_sinh sinh
     
194.   alias old_cosh cosh
     
195.   alias old_tanh tanh
     
196.   alias old_asin asin
     
197.   alias old_acos acos
     
198.   alias old_atan atan
     
199.   alias old_asinh asinh
     
200.   alias old_acosh acosh
     
201.   alias old_atanh atanh
     
202.   #--------------------------------------------------------------------------
     
203.   # ● 平方根
     
204.   #--------------------------------------------------------------------------
     
205.   def sqrt(z)
     
206.     if z.class == Complex
     
207.       r = z.abs
     
208.       x = z.re
     
209.       return Complex(old_sqrt((r + x) / 2), old_sqrt((r - x) / 2))
     
210.     else
     
211.       if z < 0
     
212.         return Complex.new(0, old_sqrt(z.abs))
     
213.       else
     
214.         old_sqrt(z)
     
215.       end
     
216.     end
     
217.   end
     
218.   #--------------------------------------------------------------------------
     
219.   # ● 指数函数
     
220.   #--------------------------------------------------------------------------
     
221.   def exp(z)
     
222.     if z.class == Complex
     
223.       return Complex(old_exp(z.re) * old_cos(z.im), old_exp(z.re) * old_sin(z.im))
     
224.     else
     
225.       old_exp(z)
     
226.     end
     
227.   end
     
228.   #--------------------------------------------------------------------------
     
229.   # ● 自然对数
     
230.   #--------------------------------------------------------------------------
     
231.   def log(z)
     
232.     if z.class == Complex
     
233.       return Complex(old_log(z.abs), z.polar[1])
     
234.     else
     
235.       if z < 0
     
236.         return Complex(log(z.abs), Math::PI)
     
237.       else
     
238.         old_log(z)
     
239.       end
     
240.     end
     
241.   end
     
242.   #--------------------------------------------------------------------------
     
243.   # ● 常用对数
     
244.   #--------------------------------------------------------------------------
     
245.   def log10(z)
     
246.     if z.class == Complex
     
247.       u = Complex(old_log10(z.abs), z.polar[1]/old_log(10))
     
248.       return u
     
249.     else
     
250.       if z < 0
     
251.         return Complex(old_log10(z.abs), old_log10(Math::E)*Math::PI)
     
252.       else
     
253.         old_log10(z)
     
254.       end
     
255.     end
     
256.   end
     
257.   #--------------------------------------------------------------------------
     
258.   # ● sin
     
259.   #--------------------------------------------------------------------------
     
260.   def sin(z)
     
261.     if z.class == Complex
     
262.       return Complex(old_sin(z.re) * old_cosh(z.im), old_cos(z.re) * old_sinh(z.im))
     
263.     else
     
264.       old_sin(z)
     
265.     end
     
266.   end
     
267.   #--------------------------------------------------------------------------
     
268.   # ● cos
     
269.   #--------------------------------------------------------------------------
     
270.   def cos(z)
     
271.     if z.class == Complex
     
272.       return Complex(old_cos(z.re) * old_cosh(z.im), -old_sin(z.re) * old_sinh(z.im))
     
273.     else
     
274.       old_cos(z)
     
275.     end
     
276.   end
     
277.   #--------------------------------------------------------------------------
     
278.   # ● tan
     
279.   #--------------------------------------------------------------------------
     
280.   def tan(z)
     
281.     if z.class == Complex
     
282.       return sin(z)/cos(z)
     
283.     else
     
284.       old_tan(z)
     
285.     end
     
286.   end
     
287.   #--------------------------------------------------------------------------
     
288.   # ● sinh
     
289.   #--------------------------------------------------------------------------
     
290.   def sinh(z)
     
291.     if z.class == Complex
     
292.       return Complex(old_sinh(z.re) * old_cos(z.im), old_cosh(z.re) * old_sin(z.im))
     
293.     else
     
294.       old_sinh(z)
     
295.     end
     
296.   end
     
297.   #--------------------------------------------------------------------------
     
298.   # ● cosh
     
299.   #--------------------------------------------------------------------------
     
300.   def cosh(z)
     
301.     if z.class == Complex
     
302.       return Complex(old_cosh(z.re) * old_cos(z.im), old_sinh(z.re) * old_sin(z.im))
     
303.     else
     
304.       old_cosh(z)
     
305.     end
     
306.   end
     
307.   #--------------------------------------------------------------------------
     
308.   # ● tanh
     
309.   #--------------------------------------------------------------------------
     
310.   def tanh(z)
     
311.     if z.class == Complex
     
312.       return sinh(z) / cosh(z)
     
313.     else
     
314.       old_tanh(z)
     
315.     end
     
316.   end
     
317.   #--------------------------------------------------------------------------
     
318.   # ● asin
     
319.   #--------------------------------------------------------------------------
     
320.   def asin(z)
     
321.     if z.class == Complex
     
322.       return log(Math::I * z + sqrt(1.0 - z * z))/Math::I
     
323.     else
     
324.       old_asin(z)
     
325.     end
     
326.   end
     
327.   #--------------------------------------------------------------------------
     
328.   # ● acos
     
329.   #--------------------------------------------------------------------------
     
330.   def acos(z)
     
331.     if z.class == Complex
     
332.       return log(z + Math::I * sqrt(1.0 - z * z))/Math::I
     
333.     else
     
334.       old_acos(z)
     
335.     end
     
336.   end
     
337.   #--------------------------------------------------------------------------
     
338.   # ● atan
     
339.   #--------------------------------------------------------------------------
     
340.   def atan(z)
     
341.     if z.class == Complex
     
342.       return log((1.0 + z * Math::I)/(1.0 - z * Math::I))/Math::I*2
     
343.     else
     
344.       old_atan(z)
     
345.     end
     
346.   end
     
347.   #--------------------------------------------------------------------------
     
348.   # ● asinh
     
349.   #--------------------------------------------------------------------------
     
350.   def asinh(z)
     
351.     if z.class == Complex
     
352.       return log(z + sqrt(1.0 + z * z))
     
353.     else
     
354.       old_asinh(z)
     
355.     end
     
356.   end
     
357.   #--------------------------------------------------------------------------
     
358.   # ● acosh
     
359.   #--------------------------------------------------------------------------
     
360.   def acosh(z)
     
361.     if z.class == Complex
     
362.       return log(z + sqrt(z * z - 1.0))
     
363.     else
     
364.       old_acosh(z)
     
365.     end
     
366.   end
     
367.   #--------------------------------------------------------------------------
     
368.   # ● atanh
     
369.   #--------------------------------------------------------------------------
     
370.   def atanh(z)
     
371.     if z.class == Complex
     
372.       return log((1.0 + z) / (1.0 - z)) / 2.0
     
373.     else
     
374.       old_atanh(z)
     
375.     end
     
376.   end
     
377. end
     

复制代码

禾西

甚麽叫複數...英文是甚麽 Orz
（完全看不懂題目與腳本的人爬過）

禾西

哦哦，原來是complex num...我說中文怎麼叫複數 Orz。
麻煩在開頭提及所有新增的公共方法和私有方法

禾西

Orz 禾西錯了...提問區多謝有你們在幫忙...