Feature #4667 ยป 0002-whitespace-fixes-for-the-mathn-library.patch

View differences:

lib/mathn.rb
73 73

74 74
`class Rational`
75 75
`  remove_method :**`
76

77
`  ##`
78
`  # exponentiate by +other+`
76 79
`  def ** (other)`
77 80
`    if other.kind_of?(Rational)`
78 81
`      other2 = other`
79 82
`      if self < 0`
80
`	return Complex(self, 0.0) ** other`
83
`        return Complex(self, 0.0) ** other`
81 84
`      elsif other == 0`
82
`	return Rational(1,1)`
85
`        return Rational(1,1)`
83 86
`      elsif self == 0`
84
`	return Rational(0,1)`
87
`        return Rational(0,1)`
85 88
`      elsif self == 1`
86
`	return Rational(1,1)`
89
`        return Rational(1,1)`
87 90
`      end`
88 91

89 92
`      npd = numerator.prime_division`
90 93
`      dpd = denominator.prime_division`
91 94
`      if other < 0`
92
`	other = -other`
93
`	npd, dpd = dpd, npd`
95
`        other = -other`
96
`        npd, dpd = dpd, npd`
94 97
`      end`
95 98

96 99
`      for elm in npd`
97
`	elm[1] = elm[1] * other`
98
`	if !elm[1].kind_of?(Integer) and elm[1].denominator != 1`
99
`         return Float(self) ** other2`
100
`	end`
101
`	elm[1] = elm[1].to_i`
100
`        elm[1] = elm[1] * other`
101
`        if !elm[1].kind_of?(Integer) and elm[1].denominator != 1`
102
`          return Float(self) ** other2`
103
`        end`
104
`        elm[1] = elm[1].to_i`
102 105
`      end`
103 106

104 107
`      for elm in dpd`
105
`	elm[1] = elm[1] * other`
106
`	if !elm[1].kind_of?(Integer) and elm[1].denominator != 1`
107
`         return Float(self) ** other2`
108
`	end`
109
`	elm[1] = elm[1].to_i`
108
`        elm[1] = elm[1] * other`
109
`        if !elm[1].kind_of?(Integer) and elm[1].denominator != 1`
110
`          return Float(self) ** other2`
111
`        end`
112
`        elm[1] = elm[1].to_i`
110 113
`      end`
111 114

112 115
`      num = Integer.from_prime_division(npd)`
......
116 119

117 120
`    elsif other.kind_of?(Integer)`
118 121
`      if other > 0`
119
`	num = numerator ** other`
120
`	den = denominator ** other`
122
`        num = numerator ** other`
123
`        den = denominator ** other`
121 124
`      elsif other < 0`
122
`	num = denominator ** -other`
123
`	den = numerator ** -other`
125
`        num = denominator ** -other`
126
`        den = numerator ** -other`
124 127
`      elsif other == 0`
125
`	num = 1`
126
`	den = 1`
128
`        num = 1`
129
`        den = 1`
127 130
`      end`
128 131
`      Rational(num, den)`
129 132
`    elsif other.kind_of?(Float)`
......
144 147
`    if a.kind_of?(Complex)`
145 148
`      abs = sqrt(a.real*a.real + a.imag*a.imag)`
146 149
`#      if not abs.kind_of?(Rational)`
147
`#	return a**Rational(1,2)`
150
`#        return a**Rational(1,2)`
148 151
`#      end`
149 152
`      x = sqrt((a.real + abs)/Rational(2))`
150 153
`      y = sqrt((-a.real + abs)/Rational(2))`
151 154
`#      if !(x.kind_of?(Rational) and y.kind_of?(Rational))`
152
`#	return a**Rational(1,2)`
155
`#        return a**Rational(1,2)`
153 156
`#      end`
154 157
`      if a.imag >= 0`
155
`	Complex(x, y)`
158
`        Complex(x, y)`
156 159
`      else`
157
`	Complex(x, -y)`
160
`        Complex(x, -y)`
158 161
`      end`
159 162
`    elsif a.respond_to?(:nan?) and a.nan?`
160 163
`      a`
......
176 179
`      byte_a = [src & 0xffffffff]`
177 180
`      # ruby's bug`
178 181
`      while (src >= max) and (src >>= 32)`
179
`	byte_a.unshift src & 0xffffffff`
182
`        byte_a.unshift src & 0xffffffff`
180 183
`      end`
181 184

182 185
`      answer = 0`
183 186
`      main = 0`
184 187
`      side = 0`
185 188
`      for elm in byte_a`
186
`	main = (main << 32) + elm`
187
`	side <<= 16`
188
`	if answer != 0`
189
`	  if main * 4  < side * side`
190
`	    applo = main.div(side)`
191
`	  else`
192
`	    applo = ((sqrt!(side * side + 4 * main) - side)/2.0).to_i + 1`
193
`	  end`
194
`	else`
195
`	  applo = sqrt!(main).to_i + 1`
196
`	end`
197

198
`	while (x = (side + applo) * applo) > main`
199
`	  applo -= 1`
200
`	end`
201
`	main -= x`
202
`	answer = (answer << 16) + applo`
203
`	side += applo * 2`
189
`        main = (main << 32) + elm`
190
`        side <<= 16`
191
`        if answer != 0`
192
`          if main * 4  < side * side`
193
`            applo = main.div(side)`
194
`          else`
195
`            applo = ((sqrt!(side * side + 4 * main) - side)/2.0).to_i + 1`
196
`          end`
197
`        else`
198
`          applo = sqrt!(main).to_i + 1`
199
`        end`
200

201
`        while (x = (side + applo) * applo) > main`
202
`          applo -= 1`
203
`        end`
204
`        main -= x`
205
`        answer = (answer << 16) + applo`
206
`        side += applo * 2`
204 207
`      end`
205 208
`      if main == 0`
206
`	answer`
209
`        answer`
207 210
`      else`
208
`	sqrt!(a)`
211
`        sqrt!(a)`
209 212
`      end`
210 213
`    end`
211 214
`  end`
212
`- `