1 // Copyright 2015 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 // This file implements string-to-Float conversion functions. 6 7 package big 8 9 import ( 10 "fmt" 11 "io" 12 "strings" 13 ) 14 15 var floatZero Float 16 17 // SetString sets z to the value of s and returns z and a boolean indicating 18 // success. s must be a floating-point number of the same format as accepted 19 // by Parse, with base argument 0. The entire string (not just a prefix) must 20 // be valid for success. If the operation failed, the value of z is undefined 21 // but the returned value is nil. 22 func (z *Float) SetString(s string) (*Float, bool) { 23 if f, _, err := z.Parse(s, 0); err == nil { 24 return f, true 25 } 26 return nil, false 27 } 28 29 // scan is like Parse but reads the longest possible prefix representing a valid 30 // floating point number from an io.ByteScanner rather than a string. It serves 31 // as the implementation of Parse. It does not recognize ±Inf and does not expect 32 // EOF at the end. 33 func (z *Float) scan(r io.ByteScanner, base int) (f *Float, b int, err error) { 34 prec := z.prec 35 if prec == 0 { 36 prec = 64 37 } 38 39 // A reasonable value in case of an error. 40 z.form = zero 41 42 // sign 43 z.neg, err = scanSign(r) 44 if err != nil { 45 return 46 } 47 48 // mantissa 49 var fcount int // fractional digit count; valid if <= 0 50 z.mant, b, fcount, err = z.mant.scan(r, base, true) 51 if err != nil { 52 return 53 } 54 55 // exponent 56 var exp int64 57 var ebase int 58 exp, ebase, err = scanExponent(r, true, base == 0) 59 if err != nil { 60 return 61 } 62 63 // special-case 0 64 if len(z.mant) == 0 { 65 z.prec = prec 66 z.acc = Exact 67 z.form = zero 68 f = z 69 return 70 } 71 // len(z.mant) > 0 72 73 // The mantissa may have a radix point (fcount <= 0) and there 74 // may be a nonzero exponent exp. The radix point amounts to a 75 // division by b**(-fcount). An exponent means multiplication by 76 // ebase**exp. Finally, mantissa normalization (shift left) requires 77 // a correcting multiplication by 2**(-shiftcount). Multiplications 78 // are commutative, so we can apply them in any order as long as there 79 // is no loss of precision. We only have powers of 2 and 10, and 80 // we split powers of 10 into the product of the same powers of 81 // 2 and 5. This reduces the size of the multiplication factor 82 // needed for base-10 exponents. 83 84 // normalize mantissa and determine initial exponent contributions 85 exp2 := int64(len(z.mant))*_W - fnorm(z.mant) 86 exp5 := int64(0) 87 88 // determine binary or decimal exponent contribution of radix point 89 if fcount < 0 { 90 // The mantissa has a radix point ddd.dddd; and 91 // -fcount is the number of digits to the right 92 // of '.'. Adjust relevant exponent accordingly. 93 d := int64(fcount) 94 switch b { 95 case 10: 96 exp5 = d 97 fallthrough // 10**e == 5**e * 2**e 98 case 2: 99 exp2 += d 100 case 8: 101 exp2 += d * 3 // octal digits are 3 bits each 102 case 16: 103 exp2 += d * 4 // hexadecimal digits are 4 bits each 104 default: 105 panic("unexpected mantissa base") 106 } 107 // fcount consumed - not needed anymore 108 } 109 110 // take actual exponent into account 111 switch ebase { 112 case 10: 113 exp5 += exp 114 fallthrough // see fallthrough above 115 case 2: 116 exp2 += exp 117 default: 118 panic("unexpected exponent base") 119 } 120 // exp consumed - not needed anymore 121 122 // apply 2**exp2 123 if MinExp <= exp2 && exp2 <= MaxExp { 124 z.prec = prec 125 z.form = finite 126 z.exp = int32(exp2) 127 f = z 128 } else { 129 err = fmt.Errorf("exponent overflow") 130 return 131 } 132 133 if exp5 == 0 { 134 // no decimal exponent contribution 135 z.round(0) 136 return 137 } 138 // exp5 != 0 139 140 // apply 5**exp5 141 p := new(Float).SetPrec(z.Prec() + 64) // use more bits for p -- TODO(gri) what is the right number? 142 if exp5 < 0 { 143 z.Quo(z, p.pow5(uint64(-exp5))) 144 } else { 145 z.Mul(z, p.pow5(uint64(exp5))) 146 } 147 148 return 149 } 150 151 // These powers of 5 fit into a uint64. 152 // 153 // for p, q := uint64(0), uint64(1); p < q; p, q = q, q*5 { 154 // fmt.Println(q) 155 // } 156 // 157 var pow5tab = [...]uint64{ 158 1, 159 5, 160 25, 161 125, 162 625, 163 3125, 164 15625, 165 78125, 166 390625, 167 1953125, 168 9765625, 169 48828125, 170 244140625, 171 1220703125, 172 6103515625, 173 30517578125, 174 152587890625, 175 762939453125, 176 3814697265625, 177 19073486328125, 178 95367431640625, 179 476837158203125, 180 2384185791015625, 181 11920928955078125, 182 59604644775390625, 183 298023223876953125, 184 1490116119384765625, 185 7450580596923828125, 186 } 187 188 // pow5 sets z to 5**n and returns z. 189 // n must not be negative. 190 func (z *Float) pow5(n uint64) *Float { 191 const m = uint64(len(pow5tab) - 1) 192 if n <= m { 193 return z.SetUint64(pow5tab[n]) 194 } 195 // n > m 196 197 z.SetUint64(pow5tab[m]) 198 n -= m 199 200 // use more bits for f than for z 201 // TODO(gri) what is the right number? 202 f := new(Float).SetPrec(z.Prec() + 64).SetUint64(5) 203 204 for n > 0 { 205 if n&1 != 0 { 206 z.Mul(z, f) 207 } 208 f.Mul(f, f) 209 n >>= 1 210 } 211 212 return z 213 } 214 215 // Parse parses s which must contain a text representation of a floating- 216 // point number with a mantissa in the given conversion base (the exponent 217 // is always a decimal number), or a string representing an infinite value. 218 // 219 // For base 0, an underscore character ``_'' may appear between a base 220 // prefix and an adjacent digit, and between successive digits; such 221 // underscores do not change the value of the number, or the returned 222 // digit count. Incorrect placement of underscores is reported as an 223 // error if there are no other errors. If base != 0, underscores are 224 // not recognized and thus terminate scanning like any other character 225 // that is not a valid radix point or digit. 226 // 227 // It sets z to the (possibly rounded) value of the corresponding floating- 228 // point value, and returns z, the actual base b, and an error err, if any. 229 // The entire string (not just a prefix) must be consumed for success. 230 // If z's precision is 0, it is changed to 64 before rounding takes effect. 231 // The number must be of the form: 232 // 233 // number = [ sign ] ( float | "inf" | "Inf" ) . 234 // sign = "+" | "-" . 235 // float = ( mantissa | prefix pmantissa ) [ exponent ] . 236 // prefix = "0" [ "b" | "B" | "o" | "O" | "x" | "X" ] . 237 // mantissa = digits "." [ digits ] | digits | "." digits . 238 // pmantissa = [ "_" ] digits "." [ digits ] | [ "_" ] digits | "." digits . 239 // exponent = ( "e" | "E" | "p" | "P" ) [ sign ] digits . 240 // digits = digit { [ "_" ] digit } . 241 // digit = "0" ... "9" | "a" ... "z" | "A" ... "Z" . 242 // 243 // The base argument must be 0, 2, 8, 10, or 16. Providing an invalid base 244 // argument will lead to a run-time panic. 245 // 246 // For base 0, the number prefix determines the actual base: A prefix of 247 // ``0b'' or ``0B'' selects base 2, ``0o'' or ``0O'' selects base 8, and 248 // ``0x'' or ``0X'' selects base 16. Otherwise, the actual base is 10 and 249 // no prefix is accepted. The octal prefix "0" is not supported (a leading 250 // "0" is simply considered a "0"). 251 // 252 // A "p" or "P" exponent indicates a base 2 (rather then base 10) exponent; 253 // for instance, "0x1.fffffffffffffp1023" (using base 0) represents the 254 // maximum float64 value. For hexadecimal mantissae, the exponent character 255 // must be one of 'p' or 'P', if present (an "e" or "E" exponent indicator 256 // cannot be distinguished from a mantissa digit). 257 // 258 // The returned *Float f is nil and the value of z is valid but not 259 // defined if an error is reported. 260 // 261 func (z *Float) Parse(s string, base int) (f *Float, b int, err error) { 262 // scan doesn't handle ±Inf 263 if len(s) == 3 && (s == "Inf" || s == "inf") { 264 f = z.SetInf(false) 265 return 266 } 267 if len(s) == 4 && (s[0] == '+' || s[0] == '-') && (s[1:] == "Inf" || s[1:] == "inf") { 268 f = z.SetInf(s[0] == '-') 269 return 270 } 271 272 r := strings.NewReader(s) 273 if f, b, err = z.scan(r, base); err != nil { 274 return 275 } 276 277 // entire string must have been consumed 278 if ch, err2 := r.ReadByte(); err2 == nil { 279 err = fmt.Errorf("expected end of string, found %q", ch) 280 } else if err2 != io.EOF { 281 err = err2 282 } 283 284 return 285 } 286 287 // ParseFloat is like f.Parse(s, base) with f set to the given precision 288 // and rounding mode. 289 func ParseFloat(s string, base int, prec uint, mode RoundingMode) (f *Float, b int, err error) { 290 return new(Float).SetPrec(prec).SetMode(mode).Parse(s, base) 291 } 292 293 var _ fmt.Scanner = &floatZero // *Float must implement fmt.Scanner 294 295 // Scan is a support routine for fmt.Scanner; it sets z to the value of 296 // the scanned number. It accepts formats whose verbs are supported by 297 // fmt.Scan for floating point values, which are: 298 // 'b' (binary), 'e', 'E', 'f', 'F', 'g' and 'G'. 299 // Scan doesn't handle ±Inf. 300 func (z *Float) Scan(s fmt.ScanState, ch rune) error { 301 s.SkipSpace() 302 _, _, err := z.scan(byteReader{s}, 0) 303 return err 304 } 305