Pré-visualização50 páginas

36). Hexatridecimal uses the digits 0\u20139 and the letters a\u2013z; it\u2019s sometimes used to generate alphanumeric mneumonics for long numbers. 2.7 Taking Logarithms | 53 The only commonly used counting systems with bases higher than 36 are the vari- ants of base-64 encoding used in applications like MIME mail attachments. These usually encode strings, not numbers; to encode a string in MIME-style base-64, use the base64 library. See Also \u2022 Recipe 12.5, \u201cAdding Graphical Context with Sparklines,\u201d and Recipe 14.5, \u201cSending Mail,\u201d show how to use the base64 library 2.7 Taking Logarithms Problem You want to take the logarithm of a number, possibly a huge one. Solution Math.log calculates the natural log of a number: that is, the log base e. Math.log(1) # => 0.0 Math.log(Math::E) # => 1.0 Math.log(10) # => 2.30258509299405 Math::E ** Math.log(25) # => 25.0 Math.log10 calculates the log base 10 of a number: Math.log10(1) # => 0.0 Math.log10(10) # => 1.0 Math.log10(10.1) # => 1.00432137378264 Math.log10(1000) # => 3.0 10 ** Math.log10(25) # => 25.0 To calculate a logarithm in some other base, use the fact that, for any bases b1 and b2, logb1(x) = logb2(x) / logb2(k). module Math def Math.logb(num, base) log(num) / log(base) end end Discussion A logarithm function inverts an exponentiation function. The log base k of x, or logk(x), is the number that gives x when raised to the k power. That is, Math. log10(1000)==3.0 because 10 cubed is 1000.Math.log(Math::E)==1 because e to the first power is e. The logarithm functions for all numeric bases are related (you can get from one base to another by dividing by a constant factor), but they\u2019re used for different purposes. 54 | Chapter 2: Numbers Scientific applications often use the natural log: this is the fastest log implementa- tion in Ruby. The log base 10 is often used to visualize datasets that span many orders of magnitude, such as the pH scale for acidity and the Richter scale for earth- quake intensity. Analyses of algorithms often use the log base 2, or binary logarithm. If you intend to do a lot of algorithms in a base that Ruby doesn\u2019t support natively, you can speed up the calculation by precalculating the dividend: dividend = Math.log(2) (1..6).collect { |x| Math.log(x) / dividend } # => [0.0, 1.0, 1.58496250072116, 2.0, 2.32192809488736, 2.58496250072116] The logarithm functions in Math will only accept integers or floating-point numbers, not BigDecimal or Bignum objects. This is inconvenient since logarithms are often used to make extremely large numbers managable. The BigMath module has a func- tion to take the natural logarithm of a BigDecimal number, but it\u2019s very slow. Here\u2019s a fast drop-in replacement for BigMath::log that exploits the logarithmic iden- tity log(x*y) == log(x) + log(y). It decomposes a BigDecimal into three much smaller numbers, and operates on those numbers. This avoids the cases that give BigMath::log such poor performance. require 'bigdecimal' require 'bigdecimal/math' require 'bigdecimal/util' module BigMath alias :log_slow :log def log(x, prec) if x <= 0 || prec <= 0 raise ArgumentError, "Zero or negative argument for log" end return x if x.infinite? || x.nan? sign, fraction, power, exponent = x.split fraction = BigDecimal(".#{fraction}") power = power.to_s.to_d log_slow(fraction, prec) + (log_slow(power, prec) * exponent) end end Like BigMath::log, this implementation returns a BigMath accurate to at least prec digits, but containing some additional digits which might not be accurate. To avoid giving the impression that the result is more accurate than it is, you can round the number to prec digits with BigDecimal#round. include BigMath number = BigDecimal("1234.5678") Math.log(number) # => 7.11847622829779 prec = 50 BigMath.log_slow(number, prec).round(prec).to_s("F") # => "7.11847622829778629250879253638708184134073214145175" 2.8 Finding Mean, Median, and Mode | 55 BigMath.log(number, prec).round(prec).to_s("F") # => "7.11847622829778629250879253638708184134073214145175" BigMath.log(number ** 1000, prec).round(prec).to_s("F") # => "7118.47622829778629250879253638708184134073214145175161" As before, calculate a log other than the natural log by dividing by BigMath.log(base) or BigMath.log_slow(base). huge_number = BigDecimal("1000") ** 1000 base = BigDecimal("10") (BigMath.log(huge_number, 100) / BigMath.log(base, 100)).to_f # => 3000.0 How does it work? The internal representation of a BigDecimal is as a number in sci- entific notation: fraction * 10**power. Because log(x*y) = log(x) + log(y), the log of such a number is log(fraction) + log(10**power). 10**power is just 10 multiplied by itself power times (that is, 10*10*10*...*10). Again, log(x*y) = log(x) + log(y), so log(10*10*10*...*10) = log(10)+log(10) + log(10)+... +log(10), or log(10)*power. This means we can take the logarithm of a huge BigDecimal by taking the logarithm of its (very small) fractional portion and the loga- rithm of 10. See Also \u2022 Mathematicians used to spend years constructing tables of logarithms for scientific and engineering applications; so if you find yourself doing a boring job, be glad you don\u2019t have to do that (see http://en.wikipedia.org/wiki/ Logarithm#Tables_of_logarithms) 2.8 Finding Mean, Median, and Mode Problem You want to find the average of an array of numbers: its mean, median, or mode. Solution Usually when people speak of the \u201caverage\u201d of a set of numbers they\u2019re referring to its mean, or arithmetic mean. The mean is the sum of the elements divided by the number of elements. def mean(array) array.inject(0) { |sum, x| sum += x } / array.size.to_f end mean([1,2,3,4]) # => 2.5 mean([100,100,100,100.1]) # => 100.025 mean([-100, 100]) # => 0.0 mean([3,3,3,3]) # => 3.0 56 | Chapter 2: Numbers The median is the item x such that half the items in the array are greater than x and the other half are less than x. Consider a sorted array: if it contains an odd number of elements, the median is the one in the middle. If the array contains an even number of elements, the median is defined as the mean of the two middle elements. def median(array, already_sorted=false) return nil if array.empty? array = array.sort unless already_sorted m_pos = array.size / 2 return array.size % 2 == 1 ? array[m_pos] : mean(array[m_pos-1..m_pos]) end median([1,2,3,4,5]) # => 3 median([5,3,2,1,4]) # => 3 median([1,2,3,4]) # => 2.5 median([1,1,2,3,4]) # => 2 median([2,3,-100,100]) # => 2.5 median([1, 1, 10, 100, 1000]) # => 10 The mode is the single most popular item in the array. If a list contains no repeated items, it is not considered to have a mode. If an array contains multiple items at the maximum frequency, it is \u201cmultimodal.\u201d Depending on your application, you might handle each mode separately, or you might just pick one arbitrarily. def modes(array, find_all=true) histogram = array.inject(Hash.new(0)) { |h, n| h[n] += 1; h } modes = nil histogram.each_pair do |item, times| modes << item if modes && times == modes[0] and find_all modes = [times, item] if (!modes && times>1) or (modes && times>modes[0]) end return modes ? modes[1...modes.size] : modes end modes([1,2,3,4])