neoneo-go/pkg/util/fixed8.go
dauTT 095653af23 Implement rpc server method: sendrawtransaction (#174)
* Added new config attributes: 'SecondsPerBlock','LowPriorityThreshold'

* Added new files:

* Added new method: CompareTo

* Fixed empty Slice case

* Added new methods: LessThan, GreaterThan, Equal, CompareTo

* Added new method: InputIntersection

* Added MaxTransactionSize, GroupOutputByAssetID

* Added ned method: ScriptHash

* Added new method: IsDoubleSpend

* Refactor blockchainer, Added Feer interface, Verify and GetMemPool method

* 1) Added MemPool
2) Added new methods to satisfy the blockchainer interface: IsLowPriority, Verify, GetMemPool

* Added new methods: RelayTxn, RelayDirectly

* Fixed tests

* Implemented RPC server method sendrawtransaction

* Refactor getrawtransaction, sendrawtransaction in separate methods

* Moved 'secondsPerBlock' to config file

* Implemented Kim suggestions:
1) Fixed data race issues
2) refactor Verify method
3) Get rid of unused InputIntersection  method due to refactoring Verify method
4) Fixed bug in https://github.com/CityOfZion/neo-go/pull/174#discussion_r264108135
5) minor simplications of the code

* Fixed minor issues related to

1) space
2) getter methods do not need pointer on the receiver
3) error message
4) refactoring  CompareTo method in uint256.go

* Fixed small issues

* Use sync.RWMutex instead of sync.Mutex

* Refined (R)Lock/(R)Unlock

* return error instead of bool in Verify methods
2019-03-20 12:30:05 +00:00

153 lines
3.4 KiB
Go

package util
import (
"encoding/json"
"errors"
"strconv"
"strings"
)
const (
precision = 8
decimals = 100000000
)
var errInvalidString = errors.New("Fixed8 must satisfy following regex \\d+(\\.\\d{1,8})?")
// Fixed8 represents a fixed-point number with precision 10^-8.
type Fixed8 int64
// String implements the Stringer interface.
func (f Fixed8) String() string {
buf := new(strings.Builder)
val := int64(f)
if val < 0 {
buf.WriteRune('-')
val = -val
}
str := strconv.FormatInt(val/decimals, 10)
buf.WriteString(str)
val %= decimals
if val > 0 {
buf.WriteRune('.')
str = strconv.FormatInt(val, 10)
for i := len(str); i < 8; i++ {
buf.WriteRune('0')
}
buf.WriteString(str)
}
return buf.String()
}
// Value returns the original value representing the Fixed8.
func (f Fixed8) Value() int64 {
return int64(f) / decimals
}
// NewFixed8 returns a new Fixed8 type multiplied by decimals.
func NewFixed8(val int64) Fixed8 {
return Fixed8(decimals * val)
}
// NewFixed8FromFloat returns a new Fixed8 type multiplied by decimals.
func NewFixed8FromFloat(val float64) Fixed8 {
return Fixed8(int64(decimals * val))
}
// Fixed8DecodeString parses s which must be a fixed point number
// with precision up to 10^-8
func Fixed8DecodeString(s string) (Fixed8, error) {
parts := strings.SplitN(s, ".", 2)
ip, err := strconv.ParseInt(parts[0], 10, 64)
if err != nil {
return 0, errInvalidString
} else if len(parts) == 1 {
return Fixed8(ip * decimals), nil
}
fp, err := strconv.ParseInt(parts[1], 10, 64)
if err != nil || fp >= decimals {
return 0, errInvalidString
}
for i := len(parts[1]); i < precision; i++ {
fp *= 10
}
if ip < 0 {
return Fixed8(ip*decimals - fp), nil
}
return Fixed8(ip*decimals + fp), nil
}
// UnmarshalJSON implements the json unmarshaller interface.
func (f *Fixed8) UnmarshalJSON(data []byte) error {
var s string
if err := json.Unmarshal(data, &s); err == nil {
p, err := Fixed8DecodeString(s)
if err != nil {
return err
}
*f = p
return nil
}
var fl float64
if err := json.Unmarshal(data, &fl); err != nil {
return err
}
*f = Fixed8(decimals * fl)
return nil
}
// Size returns the size in number of bytes of Fixed8.
func (f *Fixed8) Size() int {
return 8
}
// MarshalJSON implements the json marshaller interface.
func (f Fixed8) MarshalJSON() ([]byte, error) {
return []byte(`"` + f.String() + `"`), nil
}
// Satoshi defines the value of a 'Satoshi'.
func Satoshi() Fixed8 {
return NewFixed8(1)
}
// Div implements Fixd8 division operator.
func (f Fixed8) Div(i int64) Fixed8 {
return NewFixed8(f.Value() / i)
}
// Add implements Fixd8 addition operator.
func (f Fixed8) Add(g Fixed8) Fixed8 {
return NewFixed8(f.Value() + g.Value())
}
// Sub implements Fixd8 subtraction operator.
func (f Fixed8) Sub(g Fixed8) Fixed8 {
return NewFixed8(f.Value() - g.Value())
}
// LessThan implements Fixd8 < operator.
func (f Fixed8) LessThan(g Fixed8) bool {
return f.Value() < g.Value()
}
// GreaterThan implements Fixd8 < operator.
func (f Fixed8) GreaterThan(g Fixed8) bool {
return f.Value() > g.Value()
}
// Equal implements Fixd8 == operator.
func (f Fixed8) Equal(g Fixed8) bool {
return f.Value() == g.Value()
}
// CompareTo returns the difference between the f and g.
// difference < 0 implies f < g.
// difference = 0 implies f = g.
// difference > 0 implies f > g.
func (f Fixed8) CompareTo(g Fixed8) int {
return int(f.Value() - g.Value())
}