/
float.go
171 lines (144 loc) · 4.04 KB
/
float.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
// Copyright 2019 Alexey Krivonogov. All rights reserved.
// Use of this source code is governed by a MIT license
// that can be found in the LICENSE file.
package vm
import (
"fmt"
"math"
"strconv"
)
// AddºFloatInt adds float and int
func AddºFloatInt(left float64, right int64) float64 {
return left + float64(right)
}
// AddºIntFloat adds int and float
func AddºIntFloat(left int64, right float64) float64 {
return float64(left) + right
}
// AssignAddºFloatFloat adds one float to another
func AssignAddºFloatFloat(ptr *float64, value float64) (float64, error) {
*ptr += value
return *ptr, nil
}
// AssignDivºFloatFloat does float /= float
func AssignDivºFloatFloat(ptr *float64, value float64) (float64, error) {
if value == 0 {
return 0, fmt.Errorf(ErrorText(ErrDivZero))
}
*ptr /= value
return *ptr, nil
}
// AssignMulºFloatFloat equals float *= float
func AssignMulºFloatFloat(ptr *float64, value float64) (float64, error) {
*ptr *= value
return *ptr, nil
}
// AssignSubºFloatFloat equals float *= float
func AssignSubºFloatFloat(ptr *float64, value float64) (float64, error) {
*ptr -= value
return *ptr, nil
}
// boolºFloat converts integer value to boolean 0->false, not 0 -> true
func boolºFloat(val float64) int64 {
if val != 0.0 {
return 1
}
return 0
}
// CeilºFloat returns the least integer value greater than or equal to val.
func CeilºFloat(val float64) int64 {
return int64(math.Ceil(val))
}
// DivºFloatInt divides one float by int
func DivºFloatInt(left float64, right int64) (float64, error) {
if right == 0 {
return 0, fmt.Errorf(ErrorText(ErrDivZero))
}
return left / float64(right), nil
}
// DivºIntFloat divides one int by float
func DivºIntFloat(left int64, right float64) (float64, error) {
if right == 0 {
return 0, fmt.Errorf(ErrorText(ErrDivZero))
}
return float64(left) / right, nil
}
// EqualºFloatInt returns true if left == right
func EqualºFloatInt(left float64, right int64) int64 {
if left == float64(right) {
return 1
}
return 0
}
// ExpStrºFloat adds string and float in string expression
func ExpStrºFloat(left string, right float64) string {
return left + strºFloat(right)
}
// FloorºFloat returns the greatest integer value less than or equal to val.
func FloorºFloat(val float64) int64 {
return int64(math.Floor(val))
}
// GreaterºFloatInt returns true if left > right
func GreaterºFloatInt(left float64, right int64) int64 {
if left > float64(right) {
return 1
}
return 0
}
// intºFloat converts float value to int
func intºFloat(val float64) int64 {
return int64(val)
}
// LessºFloatInt returns true if left < right
func LessºFloatInt(left float64, right int64) int64 {
if left < float64(right) {
return 1
}
return 0
}
// MaxºFloatFloat returns the maximum of two float numbers
func MaxºFloatFloat(left, right float64) float64 {
if left < right {
return right
}
return left
}
// MinºFloatFloat returns the minimum of two float numbers
func MinºFloatFloat(left, right float64) float64 {
if left > right {
return right
}
return left
}
// MulºFloatInt multiplies float and int
func MulºFloatInt(left float64, right int64) float64 {
return left * float64(right)
}
// MulºIntFloat multiplies int and float
func MulºIntFloat(left int64, right float64) float64 {
return float64(left) * right
}
// RoundºFloat returns the nearest integer, rounding half away from zero.
func RoundºFloat(val float64) int64 {
return int64(math.Round(val))
}
// RoundºFloatInt returns a number with the specified number of decimal places.
func RoundºFloatInt(val float64, digits int64) float64 {
dec := float64(1)
for ; digits > 0; digits-- {
dec *= 10
}
return math.Round(val*dec) / dec
}
// strºFloat converts float value to string
func strºFloat(val float64) string {
return strconv.FormatFloat(val, 'f', -1, 64)
}
// SubºFloatInt subtracts float and int
func SubºFloatInt(left float64, right int64) float64 {
return left - float64(right)
}
// SubºIntFloat subtracts int and float
func SubºIntFloat(left int64, right float64) float64 {
return float64(left) - right
}