stream_float.go raw

   1  package jsoniter
   2  
   3  import (
   4  	"fmt"
   5  	"math"
   6  	"strconv"
   7  )
   8  
   9  var pow10 []uint64
  10  
  11  func init() {
  12  	pow10 = []uint64{1, 10, 100, 1000, 10000, 100000, 1000000}
  13  }
  14  
  15  // WriteFloat32 write float32 to stream
  16  func (stream *Stream) WriteFloat32(val float32) {
  17  	if math.IsInf(float64(val), 0) || math.IsNaN(float64(val)) {
  18  		stream.Error = fmt.Errorf("unsupported value: %f", val)
  19  		return
  20  	}
  21  	abs := math.Abs(float64(val))
  22  	fmt := byte('f')
  23  	// Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right.
  24  	if abs != 0 {
  25  		if float32(abs) < 1e-6 || float32(abs) >= 1e21 {
  26  			fmt = 'e'
  27  		}
  28  	}
  29  	stream.buf = strconv.AppendFloat(stream.buf, float64(val), fmt, -1, 32)
  30  	if fmt == 'e' {
  31  		// clean up e-09 to e-9
  32  		n := len(stream.buf)
  33  		if n >= 4 && stream.buf[n-4] == 'e' && stream.buf[n-3] == '-' && stream.buf[n-2] == '0' {
  34  			stream.buf[n-2] = stream.buf[n-1]
  35  			stream.buf = stream.buf[:n-1]
  36  		}
  37  	}
  38  }
  39  
  40  // WriteFloat32Lossy write float32 to stream with ONLY 6 digits precision although much much faster
  41  func (stream *Stream) WriteFloat32Lossy(val float32) {
  42  	if math.IsInf(float64(val), 0) || math.IsNaN(float64(val)) {
  43  		stream.Error = fmt.Errorf("unsupported value: %f", val)
  44  		return
  45  	}
  46  	if val < 0 {
  47  		stream.writeByte('-')
  48  		val = -val
  49  	}
  50  	if val > 0x4ffffff {
  51  		stream.WriteFloat32(val)
  52  		return
  53  	}
  54  	precision := 6
  55  	exp := uint64(1000000) // 6
  56  	lval := uint64(float64(val)*float64(exp) + 0.5)
  57  	stream.WriteUint64(lval / exp)
  58  	fval := lval % exp
  59  	if fval == 0 {
  60  		return
  61  	}
  62  	stream.writeByte('.')
  63  	for p := precision - 1; p > 0 && fval < pow10[p]; p-- {
  64  		stream.writeByte('0')
  65  	}
  66  	stream.WriteUint64(fval)
  67  	for stream.buf[len(stream.buf)-1] == '0' {
  68  		stream.buf = stream.buf[:len(stream.buf)-1]
  69  	}
  70  }
  71  
  72  // WriteFloat64 write float64 to stream
  73  func (stream *Stream) WriteFloat64(val float64) {
  74  	if math.IsInf(val, 0) || math.IsNaN(val) {
  75  		stream.Error = fmt.Errorf("unsupported value: %f", val)
  76  		return
  77  	}
  78  	abs := math.Abs(val)
  79  	fmt := byte('f')
  80  	// Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right.
  81  	if abs != 0 {
  82  		if abs < 1e-6 || abs >= 1e21 {
  83  			fmt = 'e'
  84  		}
  85  	}
  86  	stream.buf = strconv.AppendFloat(stream.buf, float64(val), fmt, -1, 64)
  87  	if fmt == 'e' {
  88  		// clean up e-09 to e-9
  89  		n := len(stream.buf)
  90  		if n >= 4 && stream.buf[n-4] == 'e' && stream.buf[n-3] == '-' && stream.buf[n-2] == '0' {
  91  			stream.buf[n-2] = stream.buf[n-1]
  92  			stream.buf = stream.buf[:n-1]
  93  		}
  94  	}
  95  }
  96  
  97  // WriteFloat64Lossy write float64 to stream with ONLY 6 digits precision although much much faster
  98  func (stream *Stream) WriteFloat64Lossy(val float64) {
  99  	if math.IsInf(val, 0) || math.IsNaN(val) {
 100  		stream.Error = fmt.Errorf("unsupported value: %f", val)
 101  		return
 102  	}
 103  	if val < 0 {
 104  		stream.writeByte('-')
 105  		val = -val
 106  	}
 107  	if val > 0x4ffffff {
 108  		stream.WriteFloat64(val)
 109  		return
 110  	}
 111  	precision := 6
 112  	exp := uint64(1000000) // 6
 113  	lval := uint64(val*float64(exp) + 0.5)
 114  	stream.WriteUint64(lval / exp)
 115  	fval := lval % exp
 116  	if fval == 0 {
 117  		return
 118  	}
 119  	stream.writeByte('.')
 120  	for p := precision - 1; p > 0 && fval < pow10[p]; p-- {
 121  		stream.writeByte('0')
 122  	}
 123  	stream.WriteUint64(fval)
 124  	for stream.buf[len(stream.buf)-1] == '0' {
 125  		stream.buf = stream.buf[:len(stream.buf)-1]
 126  	}
 127  }
 128