src/math/big/ratconv.go

   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 rat-to-string conversion functions.
   6
   7 package big
   8
   9 import (
  10         "errors"
  11         "fmt"
  12         "io"
  13         "strconv"
  14         "strings"
  15 )
  16
  17 func ratTok(ch rune) bool {
  18         return strings.ContainsRune("+-/0123456789.eE", ch)
  19 }
  20
  21 // Scan is a support routine for fmt.Scanner. It accepts the formats
  22 // 'e', 'E', 'f', 'F', 'g', 'G', and 'v'. All formats are equivalent.
  23 func (z *Rat) Scan(s fmt.ScanState, ch rune) error {
  24         tok, err := s.Token(true, ratTok)
  25         if err != nil {
  26                 return err
  27         }
  28         if !strings.ContainsRune("efgEFGv", ch) {
  29                 return errors.New("Rat.Scan: invalid verb")
  30         }
  31         if _, ok := z.SetString(string(tok)); !ok {
  32                 return errors.New("Rat.Scan: invalid syntax")
  33         }
  34         return nil
  35 }
  36
  37 // SetString sets z to the value of s and returns z and a boolean indicating
  38 // success. s can be given as a fraction "a/b" or as a floating-point number
  39 // optionally followed by an exponent. If the operation failed, the value of
  40 // z is undefined but the returned value is nil.
  41 func (z *Rat) SetString(s string) (*Rat, bool) {
  42         if len(s) == 0 {
  43                 return nil, false
  44         }
  45         // len(s) > 0
  46
  47         // parse fraction a/b, if any
  48         if sep := strings.Index(s, "/"); sep >= 0 {
  49                 if _, ok := z.a.SetString(s[:sep], 0); !ok {
  50                         return nil, false
  51                 }
  52                 s = s[sep+1:]
  53                 var err error
  54                 if z.b.abs, _, _, err = z.b.abs.scan(strings.NewReader(s), 0, false); err != nil {
  55                         return nil, false
  56                 }
  57                 if len(z.b.abs) == 0 {
  58                         return nil, false
  59                 }
  60                 return z.norm(), true
  61         }
  62
  63         // parse floating-point number
  64         r := strings.NewReader(s)
  65
  66         // sign
  67         neg, err := scanSign(r)
  68         if err != nil {
  69                 return nil, false
  70         }
  71
  72         // mantissa
  73         var ecorr int
  74         z.a.abs, _, ecorr, err = z.a.abs.scan(r, 10, true)
  75         if err != nil {
  76                 return nil, false
  77         }
  78
  79         // exponent
  80         var exp int64
  81         exp, _, err = scanExponent(r, false)
  82         if err != nil {
  83                 return nil, false
  84         }
  85
  86         // there should be no unread characters left
  87         if _, err = r.ReadByte(); err != io.EOF {
  88                 return nil, false
  89         }
  90
  91         // correct exponent
  92         if ecorr < 0 {
  93                 exp += int64(ecorr)
  94         }
  95
  96         // compute exponent power
  97         expabs := exp
  98         if expabs < 0 {
  99                 expabs = -expabs
 100         }
 101         powTen := nat(nil).expNN(natTen, nat(nil).setWord(Word(expabs)), nil)
 102
 103         // complete fraction
 104         if exp < 0 {
 105                 z.b.abs = powTen
 106                 z.norm()
 107         } else {
 108                 z.a.abs = z.a.abs.mul(z.a.abs, powTen)
 109                 z.b.abs = z.b.abs[:0]
 110         }
 111
 112         z.a.neg = neg && len(z.a.abs) > 0 // 0 has no sign
 113
 114         return z, true
 115 }
 116
 117 // scanExponent scans the longest possible prefix of r representing a decimal
 118 // ('e', 'E') or binary ('p') exponent, if any. It returns the exponent, the
 119 // exponent base (10 or 2), or a read or syntax error, if any.
 120 //
 121 //      exponent = ( "E" | "e" | "p" ) [ sign ] digits .
 122 //      sign     = "+" | "-" .
 123 //      digits   = digit { digit } .
 124 //      digit    = "0" ... "9" .
 125 //
 126 // A binary exponent is only permitted if binExpOk is set.
 127 func scanExponent(r io.ByteScanner, binExpOk bool) (exp int64, base int, err error) {
 128         base = 10
 129
 130         var ch byte
 131         if ch, err = r.ReadByte(); err != nil {
 132                 if err == io.EOF {
 133                         err = nil // no exponent; same as e0
 134                 }
 135                 return
 136         }
 137
 138         switch ch {
 139         case 'e', 'E':
 140                 // ok
 141         case 'p':
 142                 if binExpOk {
 143                         base = 2
 144                         break // ok
 145                 }
 146                 fallthrough // binary exponent not permitted
 147         default:
 148                 r.UnreadByte()
 149                 return // no exponent; same as e0
 150         }
 151
 152         var neg bool
 153         if neg, err = scanSign(r); err != nil {
 154                 return
 155         }
 156
 157         var digits []byte
 158         if neg {
 159                 digits = append(digits, '-')
 160         }
 161
 162         // no need to use nat.scan for exponent digits
 163         // since we only care about int64 values - the
 164         // from-scratch scan is easy enough and faster
 165         for i := 0; ; i++ {
 166                 if ch, err = r.ReadByte(); err != nil {
 167                         if err != io.EOF || i == 0 {
 168                                 return
 169                         }
 170                         err = nil
 171                         break // i > 0
 172                 }
 173                 if ch < '0' || '9' < ch {
 174                         if i == 0 {
 175                                 r.UnreadByte()
 176                                 err = fmt.Errorf("invalid exponent (missing digits)")
 177                                 return
 178                         }
 179                         break // i > 0
 180                 }
 181                 digits = append(digits, byte(ch))
 182         }
 183         // i > 0 => we have at least one digit
 184
 185         exp, err = strconv.ParseInt(string(digits), 10, 64)
 186         return
 187 }
 188
 189 // String returns a string representation of x in the form "a/b" (even if b == 1).
 190 func (x *Rat) String() string {
 191         var buf []byte
 192         buf = x.a.Append(buf, 10)
 193         buf = append(buf, '/')
 194         if len(x.b.abs) != 0 {
 195                 buf = x.b.Append(buf, 10)
 196         } else {
 197                 buf = append(buf, '1')
 198         }
 199         return string(buf)
 200 }
 201
 202 // RatString returns a string representation of x in the form "a/b" if b != 1,
 203 // and in the form "a" if b == 1.
 204 func (x *Rat) RatString() string {
 205         if x.IsInt() {
 206                 return x.a.String()
 207         }
 208         return x.String()
 209 }
 210
 211 // FloatString returns a string representation of x in decimal form with prec
 212 // digits of precision after the decimal point. The last digit is rounded to
 213 // nearest, with halves rounded away from zero.
 214 func (x *Rat) FloatString(prec int) string {
 215         var buf []byte
 216
 217         if x.IsInt() {
 218                 buf = x.a.Append(buf, 10)
 219                 if prec > 0 {
 220                         buf = append(buf, '.')
 221                         for i := prec; i > 0; i-- {
 222                                 buf = append(buf, '0')
 223                         }
 224                 }
 225                 return string(buf)
 226         }
 227         // x.b.abs != 0
 228
 229         q, r := nat(nil).div(nat(nil), x.a.abs, x.b.abs)
 230
 231         p := natOne
 232         if prec > 0 {
 233                 p = nat(nil).expNN(natTen, nat(nil).setUint64(uint64(prec)), nil)
 234         }
 235
 236         r = r.mul(r, p)
 237         r, r2 := r.div(nat(nil), r, x.b.abs)
 238
 239         // see if we need to round up
 240         r2 = r2.add(r2, r2)
 241         if x.b.abs.cmp(r2) <= 0 {
 242                 r = r.add(r, natOne)
 243                 if r.cmp(p) >= 0 {
 244                         q = nat(nil).add(q, natOne)
 245                         r = nat(nil).sub(r, p)
 246                 }
 247         }
 248
 249         if x.a.neg {
 250                 buf = append(buf, '-')
 251         }
 252         buf = append(buf, q.utoa(10)...) // itoa ignores sign if q == 0
 253
 254         if prec > 0 {
 255                 buf = append(buf, '.')
 256                 rs := r.utoa(10)
 257                 for i := prec - len(rs); i > 0; i-- {
 258                         buf = append(buf, '0')
 259                 }
 260                 buf = append(buf, rs...)
 261         }
 262
 263         return string(buf)
 264 }