Source file
src/tawesoft.co.uk/go/operator/float32.go
Documentation:
src/tawesoft.co.uk/go/operator/float32.go
1 package operator
2
3
4
5 import "math"
6
7
8
9 type float32Unary struct {
10 Identity func(float32) float32
11 Abs func(float32) float32
12 Negation func(float32) float32
13 Zero func(float32) bool
14 NonZero func(float32) bool
15 Positive func(float32) bool
16 Negative func(float32) bool
17 }
18
19 type float32UnaryChecked struct {
20 Abs func(float32) (float32, error)
21 Negation func(float32) (float32, error)
22 }
23
24 type float32Binary struct {
25 Add func(float32, float32) float32
26 Sub func(float32, float32) float32
27 Mul func(float32, float32) float32
28 Div func(float32, float32) float32
29 Mod func(float32, float32) float32
30
31 Eq func(float32, float32) bool
32 Neq func(float32, float32) bool
33 Lt func(float32, float32) bool
34 Lte func(float32, float32) bool
35 Gt func(float32, float32) bool
36 Gte func(float32, float32) bool
37
38
39 }
40
41 type float32BinaryChecked struct {
42 Add func(float32, float32) (float32, error)
43 Sub func(float32, float32) (float32, error)
44 Mul func(float32, float32) (float32, error)
45 Div func(float32, float32) (float32, error)
46
47 }
48
49 type float32Nary struct {
50 Add func(... float32) float32
51 Sub func(... float32) float32
52 Mul func(... float32) float32
53 }
54
55 type float32NaryChecked struct {
56 Add func(... float32) (float32, error)
57 Sub func(... float32) (float32, error)
58 Mul func(... float32) (float32, error)
59 }
60
61
62 var Float32 = struct {
63 Unary float32Unary
64 Binary float32Binary
65 Nary float32Nary
66 Reduce func(operatorIdentity float32, operator func(float32, float32) float32, elements ... float32) float32
67 }{
68 Unary: float32Unary{
69 Identity: func(a float32) float32 { return a },
70 Abs: float32UnaryAbs,
71 Negation: func(a float32) float32 { return -a },
72 Zero: func(a float32) bool { return a == 0 },
73 NonZero: func(a float32) bool { return a != 0 },
74 Positive: float32UnaryPositive,
75 Negative: float32UnaryNegative,
76 },
77
78 Binary: float32Binary{
79 Add: func(a float32, b float32) float32 { return a + b },
80 Sub: func(a float32, b float32) float32 { return a - b },
81 Mul: func(a float32, b float32) float32 { return a * b },
82 Div: func(a float32, b float32) float32 { return a / b },
83
84 Eq: func(a float32, b float32) bool { return a == b },
85 Neq: func(a float32, b float32) bool { return a != b },
86 Lt: func(a float32, b float32) bool { return a < b },
87 Lte: func(a float32, b float32) bool { return a <= b },
88 Gt: func(a float32, b float32) bool { return a > b },
89 Gte: func(a float32, b float32) bool { return a >= b },
90
91
92 },
93
94 Nary: float32Nary{
95 Add: float32NaryAdd,
96 Mul: float32NaryMul,
97 },
98
99 Reduce: float32Reduce,
100 }
101
102
103
104 var Float32Checked = struct {
105 Unary float32UnaryChecked
106 Binary float32BinaryChecked
107 Nary float32NaryChecked
108 Reduce func(operatorIdentity float32, operator func(float32, float32) (float32, error), elements ... float32) (float32, error)
109 }{
110 Unary: float32UnaryChecked{
111 Abs: float32UnaryCheckedAbs,
112 Negation: float32UnaryCheckedNegation,
113 },
114
115 Binary: float32BinaryChecked{
116 Add: float32BinaryCheckedAdd,
117 Sub: float32BinaryCheckedSub,
118 Mul: float32BinaryCheckedMul,
119 Div: float32BinaryCheckedDiv,
120 },
121
122 Nary: float32NaryChecked{
123 Add: float32NaryCheckedAdd,
124 Mul: float32NaryCheckedMul,
125 },
126
127 Reduce: float32CheckedReduce,
128 }
129
130 func float32UnaryPositive(a float32) bool {
131 return math.Signbit(float64(a)) == false
132 }
133
134 func float32UnaryNegative(a float32) bool {
135 return math.Signbit(float64(a)) == true
136 }
137
138 func float32UnaryAbs(a float32) float32 {
139 return float32(math.Abs(float64(a)))
140 }
141
142
143 func float32UnaryCheckedAbs(a float32) (v float32, err error) {
144 if math.IsNaN(float64(a)) { return v, ErrorNaN }
145 return float32(math.Abs(float64(a))), nil
146 }
147
148 func float32UnaryCheckedNegation(a float32) (v float32, err error) {
149 if math.IsNaN(float64(a)) { return v, ErrorNaN }
150 return -a, nil
151 }
152
153 func float32BinaryCheckedAdd(a float32, b float32) (v float32, err error) {
154 if (b > 0) && (a > (maxFloat32 - b)) { return v, ErrorOverflow }
155 if (b < 0) && (a < (minFloat32 - b)) { return v, ErrorOverflow }
156 return a + b, nil
157 }
158
159 func float32BinaryCheckedSub(a float32, b float32) (v float32, err error) {
160 if (b < 0) && (a > (maxFloat32 + b)) { return v, ErrorOverflow }
161 if (b > 0) && (a < (minFloat32 + b)) { return v, ErrorOverflow }
162 return a - b, nil
163 }
164
165 func float32BinaryCheckedMul(a float32, b float32) (v float32, err error) {
166 if (a > (maxFloat32 / b)) { return v, ErrorOverflow }
167 if (a < (minFloat32 / b)) { return v, ErrorOverflow }
168
169 return a * b, nil
170 }
171
172 func float32BinaryCheckedDiv(a float32, b float32) (v float32, err error) {
173 if math.IsNaN(float64(a)) { return v, ErrorNaN }
174 if (b == 0) { return v, ErrorUndefined }
175
176 return a / b, nil
177 }
178
179
180
181 func float32NaryAdd(xs ... float32) (result float32) {
182 for i := 0; i < len(xs); i++ {
183 result += xs[i]
184 }
185 return result
186 }
187
188 func float32NaryCheckedAdd(xs ... float32) (result float32, err error) {
189 for i := 0; i < len(xs); i++ {
190 result, err = float32BinaryCheckedAdd(result, xs[i])
191 if err != nil { return result, err }
192 }
193 return result, nil
194 }
195
196 func float32NaryMul(xs ... float32) (result float32) {
197 result = 1
198 for i := 0; i < len(xs); i++ {
199 result *= xs[i]
200 }
201 return result
202 }
203
204 func float32NaryCheckedMul(xs ... float32) (result float32, err error) {
205 result = 1
206 for i := 0; i < len(xs); i++ {
207 result, err = float32BinaryCheckedMul(result, xs[i])
208 if err != nil { return result, err }
209 }
210 return result, nil
211 }
212
213 func float32Reduce(operatorIdentity float32, operator func(float32, float32) float32, elements ... float32) (result float32) {
214 result = operatorIdentity
215 for i := 0; i < len(elements); i++ {
216 result = operator(result, elements[i])
217 }
218 return result
219 }
220
221 func float32CheckedReduce(operatorIdentity float32, operator func(float32, float32) (float32, error), elements ... float32) (result float32, err error) {
222 result = operatorIdentity
223 for i := 0; i < len(elements); i++ {
224 result, err = operator(result, elements[i])
225 if err != nil { return result, err }
226 }
227 return result, err
228 }
229
230
View as plain text