this repo has no description
core/adt: simplify duplicate NumKind and NumberKind consts
kind.go defined both NumKind and NumberKind as IntKind | FloatKind.
Previously, NumKind was widely used, and NumberKind was not.
But NumberKind is:
(a) the better name;
(b) is used in cue/types.go, where many of the other consts from
adt/kind.go are also repeated.
(c) matches with Number, as used in the CUE language spec.
Rename NumKind to NumberKind and remove duplicate definition.
Signed-off-by: Matthew Sackman <matthew@cue.works>
Change-Id: Iefc35d5326879de9c4c5c3e87b50c530e0be99ef
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1197440
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: CUEcueckoo <cueckoo@cuelang.org>
Unity-Result: CUE porcuepine <cue.porcuepine@gmail.com>
+144
-146
+6
-6
cue/types.go
+6
-6
cue/types.go
···
79
79
// Kind.String to indicate NumberKind.
80
80
81
81
// NumberKind represents any kind of number.
82
-
NumberKind Kind = IntKind | FloatKind
82
+
NumberKind Kind = adt.NumberKind
83
83
84
84
// TopKind represents the top value.
85
85
TopKind Kind = adt.TopKind
···
332
332
// 200 and exp == -2. Calling MantExp with a nil argument is an efficient way to
333
333
// get the exponent of the receiver.
334
334
func (v Value) MantExp(mant *big.Int) (exp int, err error) {
335
-
n, err := v.getNum(adt.NumKind)
335
+
n, err := v.getNum(adt.NumberKind)
336
336
if err != nil {
337
337
return 0, err
338
338
}
···
351
351
// Decimal is for internal use only. The Decimal type that is returned is
352
352
// subject to change.
353
353
func (v hiddenValue) Decimal() (d *internal.Decimal, err error) {
354
-
n, err := v.getNum(adt.NumKind)
354
+
n, err := v.getNum(adt.NumberKind)
355
355
if err != nil {
356
356
return nil, err
357
357
}
···
372
372
// AppendFloat appends to buf the string form of the floating-point number x.
373
373
// It returns an error if v is not a number.
374
374
func (v Value) AppendFloat(buf []byte, fmt byte, prec int) ([]byte, error) {
375
-
n, err := v.getNum(adt.NumKind)
375
+
n, err := v.getNum(adt.NumberKind)
376
376
if err != nil {
377
377
return nil, err
378
378
}
···
510
510
// by a float64 (|x| > math.MaxFloat64), the result is (+Inf, ErrAbove) or
511
511
// (-Inf, ErrBelow), depending on the sign of x.
512
512
func (v Value) Float64() (float64, error) {
513
-
n, err := v.getNum(adt.NumKind)
513
+
n, err := v.getNum(adt.NumberKind)
514
514
if err != nil {
515
515
return 0, err
516
516
}
···
929
929
return internaljson.Marshal(nil)
930
930
case adt.BoolKind:
931
931
return internaljson.Marshal(x.(*adt.Bool).B)
932
-
case adt.IntKind, adt.FloatKind, adt.NumKind:
932
+
case adt.IntKind, adt.FloatKind, adt.NumberKind:
933
933
b, err := x.(*adt.Num).X.MarshalText()
934
934
b = bytes.TrimLeft(b, "+")
935
935
return b, err
+6
-6
internal/core/adt/binop.go
+6
-6
internal/core/adt/binop.go
···
64
64
case leftKind == BytesKind:
65
65
return cmpTonode(c, op, bytes.Compare(c.bytesValue(left, op), c.bytesValue(right, op)))
66
66
67
-
case leftKind&NumKind != 0 && rightKind&NumKind != 0:
67
+
case leftKind&NumberKind != 0 && rightKind&NumberKind != 0:
68
68
// n := c.newNum()
69
69
return cmpTonode(c, op, c.Num(left, op).X.Cmp(&c.Num(right, op).X))
70
70
···
102
102
case leftKind == BytesKind:
103
103
return cmpTonode(c, op, bytes.Compare(c.bytesValue(left, op), c.bytesValue(right, op)))
104
104
105
-
case leftKind&NumKind != 0 && rightKind&NumKind != 0:
105
+
case leftKind&NumberKind != 0 && rightKind&NumberKind != 0:
106
106
// n := c.newNum()
107
107
return cmpTonode(c, op, c.Num(left, op).X.Cmp(&c.Num(right, op).X))
108
108
···
131
131
case leftKind == BytesKind && rightKind == BytesKind:
132
132
return cmpTonode(c, op, bytes.Compare(c.bytesValue(left, op), c.bytesValue(right, op)))
133
133
134
-
case leftKind&NumKind != 0 && rightKind&NumKind != 0:
134
+
case leftKind&NumberKind != 0 && rightKind&NumberKind != 0:
135
135
// n := c.newNum(left, right)
136
136
return cmpTonode(c, op, c.Num(left, op).X.Cmp(&c.Num(right, op).X))
137
137
}
···
158
158
159
159
case AddOp:
160
160
switch {
161
-
case leftKind&NumKind != 0 && rightKind&NumKind != 0:
161
+
case leftKind&NumberKind != 0 && rightKind&NumberKind != 0:
162
162
return c.Add(c.Num(left, op), c.Num(right, op))
163
163
164
164
case leftKind == StringKind && rightKind == StringKind:
···
224
224
case MultiplyOp:
225
225
switch {
226
226
// float
227
-
case leftKind&NumKind != 0 && rightKind&NumKind != 0:
227
+
case leftKind&NumberKind != 0 && rightKind&NumberKind != 0:
228
228
return c.Mul(c.Num(left, op), c.Num(right, op))
229
229
230
230
case leftKind == StringKind && rightKind == IntKind:
···
280
280
}
281
281
282
282
case FloatQuotientOp:
283
-
if leftKind&NumKind != 0 && rightKind&NumKind != 0 {
283
+
if leftKind&NumberKind != 0 && rightKind&NumberKind != 0 {
284
284
return c.Quo(c.Num(left, op), c.Num(right, op))
285
285
}
286
286
+1
-1
internal/core/adt/constraints.go
+1
-1
internal/core/adt/constraints.go
+3
-3
internal/core/adt/context.go
+3
-3
internal/core/adt/context.go
···
1149
1149
return v
1150
1150
}
1151
1151
1152
-
var zero = &Num{K: NumKind}
1152
+
var zero = &Num{K: NumberKind}
1153
1153
1154
1154
func (c *OpContext) Num(v Value, as interface{}) *Num {
1155
1155
v = Unwrap(v)
···
1158
1158
}
1159
1159
x, ok := v.(*Num)
1160
1160
if !ok {
1161
-
c.typeErrorAs(v, NumKind, as)
1161
+
c.typeErrorAs(v, NumberKind, as)
1162
1162
return zero
1163
1163
}
1164
1164
return x
···
1236
1236
1237
1237
// ToString returns the string value of a scalar value.
1238
1238
func (c *OpContext) ToString(v Value) string {
1239
-
return c.toStringValue(v, StringKind|NumKind|BytesKind|BoolKind, nil)
1239
+
return c.toStringValue(v, StringKind|NumberKind|BytesKind|BoolKind, nil)
1240
1240
1241
1241
}
1242
1242
+6
-6
internal/core/adt/expr.go
+6
-6
internal/core/adt/expr.go
···
466
466
}
467
467
468
468
switch k := v.Kind(); k {
469
-
case IntKind, FloatKind, NumKind, StringKind, BytesKind:
469
+
case IntKind, FloatKind, NumberKind, StringKind, BytesKind:
470
470
case NullKind:
471
471
if x.Op != NotEqualOp {
472
472
err := ctx.NewPosf(pos(x.Expr),
···
474
474
return &Bottom{Err: err}
475
475
}
476
476
default:
477
-
mask := IntKind | FloatKind | NumKind | StringKind | BytesKind
477
+
mask := IntKind | FloatKind | NumberKind | StringKind | BytesKind
478
478
if x.Op == NotEqualOp {
479
479
mask |= NullKind
480
480
}
···
592
592
func (x *BoundValue) Kind() Kind {
593
593
k := x.Value.Kind()
594
594
switch k {
595
-
case IntKind, FloatKind, NumKind:
596
-
return NumKind
595
+
case IntKind, FloatKind, NumberKind:
596
+
return NumberKind
597
597
598
598
case NullKind:
599
599
if x.Op == NotEqualOp {
···
1242
1242
f.Src = x.Src
1243
1243
return &f
1244
1244
}
1245
-
expectedKind = NumKind
1245
+
expectedKind = NumberKind
1246
1246
1247
1247
case AddOp:
1248
1248
if v, ok := v.(*Num); ok {
1249
1249
// TODO: wrap in thunk to save position of '+'?
1250
1250
return v
1251
1251
}
1252
-
expectedKind = NumKind
1252
+
expectedKind = NumberKind
1253
1253
1254
1254
case NotOp:
1255
1255
if v, ok := v.(*Bool); ok {
+1
-1
internal/core/adt/feature.go
+1
-1
internal/core/adt/feature.go
+1
-3
internal/core/adt/kind.go
+1
-3
internal/core/adt/kind.go
···
71
71
72
72
_numberKind
73
73
74
-
NumberKind = IntKind | FloatKind
75
-
76
74
BottomKind Kind = 0
77
75
78
-
NumKind = IntKind | FloatKind
76
+
NumberKind = IntKind | FloatKind
79
77
TopKind Kind = (allKinds - 1) // all kinds, but not references
80
78
ScalarKinds = NullKind | BoolKind |
81
79
IntKind | FloatKind | StringKind | BytesKind
+4
-4
internal/core/adt/simplify.go
+4
-4
internal/core/adt/simplify.go
···
133
133
case diff == 1:
134
134
if k&FloatKind == 0 {
135
135
if x.Op == GreaterEqualOp && y.Op == LessThanOp {
136
-
return ctx.newNum(&lo, k&NumKind, x, y)
136
+
return ctx.newNum(&lo, k&NumberKind, x, y)
137
137
}
138
138
if x.Op == GreaterThanOp && y.Op == LessEqualOp {
139
-
return ctx.newNum(&hi, k&NumKind, x, y)
139
+
return ctx.newNum(&hi, k&NumberKind, x, y)
140
140
}
141
141
}
142
142
143
143
case diff == 2:
144
144
if k&FloatKind == 0 && x.Op == GreaterThanOp && y.Op == LessThanOp {
145
145
_, _ = internal.BaseContext.Add(&d, d.SetInt64(1), &lo)
146
-
return ctx.newNum(&d, k&NumKind, x, y)
146
+
return ctx.newNum(&d, k&NumberKind, x, y)
147
147
148
148
}
149
149
150
150
case diff == 0 && err == nil:
151
151
if x.Op == GreaterEqualOp && y.Op == LessEqualOp {
152
-
return ctx.newNum(&lo, k&NumKind, x, y)
152
+
return ctx.newNum(&lo, k&NumberKind, x, y)
153
153
}
154
154
fallthrough
155
155
+3
-3
internal/core/compile/predeclared.go
+3
-3
internal/core/compile/predeclared.go
···
38
38
case "float", "__float":
39
39
return &adt.BasicType{Src: n, K: adt.FloatKind}
40
40
case "number", "__number":
41
-
return &adt.BasicType{Src: n, K: adt.NumKind}
41
+
return &adt.BasicType{Src: n, K: adt.NumberKind}
42
42
43
43
case "len", "__len":
44
44
return lenBuiltin
···
136
136
}
137
137
138
138
func mkFloatRange(a, b string) adt.Expr {
139
-
from := newBound(adt.GreaterEqualOp, adt.NumKind, parseFloat(a))
140
-
to := newBound(adt.LessEqualOp, adt.NumKind, parseFloat(b))
139
+
from := newBound(adt.GreaterEqualOp, adt.NumberKind, parseFloat(a))
140
+
to := newBound(adt.LessEqualOp, adt.NumberKind, parseFloat(b))
141
141
src := ast.NewBinExpr(token.AND, from.Src, to.Src)
142
142
return &adt.Conjunction{Src: src, Values: []adt.Value{from, to}}
143
143
}
+1
-1
internal/pkg/context.go
+1
-1
internal/pkg/context.go
+1
-1
pkg/gen.go
+1
-1
pkg/gen.go
+8
-8
pkg/list/pkg.go
+8
-8
pkg/list/pkg.go
···
160
160
Params: []pkg.Param{
161
161
{Kind: adt.ListKind},
162
162
},
163
-
Result: adt.NumKind,
163
+
Result: adt.NumberKind,
164
164
Func: func(c *pkg.CallCtxt) {
165
165
xs := c.DecimalList(0)
166
166
if c.Do() {
···
172
172
Params: []pkg.Param{
173
173
{Kind: adt.ListKind},
174
174
},
175
-
Result: adt.NumKind,
175
+
Result: adt.NumberKind,
176
176
Func: func(c *pkg.CallCtxt) {
177
177
xs := c.DecimalList(0)
178
178
if c.Do() {
···
184
184
Params: []pkg.Param{
185
185
{Kind: adt.ListKind},
186
186
},
187
-
Result: adt.NumKind,
187
+
Result: adt.NumberKind,
188
188
Func: func(c *pkg.CallCtxt) {
189
189
xs := c.DecimalList(0)
190
190
if c.Do() {
···
196
196
Params: []pkg.Param{
197
197
{Kind: adt.ListKind},
198
198
},
199
-
Result: adt.NumKind,
199
+
Result: adt.NumberKind,
200
200
Func: func(c *pkg.CallCtxt) {
201
201
xs := c.DecimalList(0)
202
202
if c.Do() {
···
206
206
}, {
207
207
Name: "Range",
208
208
Params: []pkg.Param{
209
-
{Kind: adt.NumKind},
210
-
{Kind: adt.NumKind},
211
-
{Kind: adt.NumKind},
209
+
{Kind: adt.NumberKind},
210
+
{Kind: adt.NumberKind},
211
+
{Kind: adt.NumberKind},
212
212
},
213
213
Result: adt.ListKind,
214
214
Func: func(c *pkg.CallCtxt) {
···
222
222
Params: []pkg.Param{
223
223
{Kind: adt.ListKind},
224
224
},
225
-
Result: adt.NumKind,
225
+
Result: adt.NumberKind,
226
226
Func: func(c *pkg.CallCtxt) {
227
227
xs := c.DecimalList(0)
228
228
if c.Do() {
+101
-101
pkg/math/pkg.go
+101
-101
pkg/math/pkg.go
···
69
69
}, {
70
70
Name: "Floor",
71
71
Params: []pkg.Param{
72
-
{Kind: adt.NumKind},
72
+
{Kind: adt.NumberKind},
73
73
},
74
74
Result: adt.IntKind,
75
75
Func: func(c *pkg.CallCtxt) {
···
81
81
}, {
82
82
Name: "Ceil",
83
83
Params: []pkg.Param{
84
-
{Kind: adt.NumKind},
84
+
{Kind: adt.NumberKind},
85
85
},
86
86
Result: adt.IntKind,
87
87
Func: func(c *pkg.CallCtxt) {
···
93
93
}, {
94
94
Name: "Trunc",
95
95
Params: []pkg.Param{
96
-
{Kind: adt.NumKind},
96
+
{Kind: adt.NumberKind},
97
97
},
98
98
Result: adt.IntKind,
99
99
Func: func(c *pkg.CallCtxt) {
···
105
105
}, {
106
106
Name: "Round",
107
107
Params: []pkg.Param{
108
-
{Kind: adt.NumKind},
108
+
{Kind: adt.NumberKind},
109
109
},
110
110
Result: adt.IntKind,
111
111
Func: func(c *pkg.CallCtxt) {
···
117
117
}, {
118
118
Name: "RoundToEven",
119
119
Params: []pkg.Param{
120
-
{Kind: adt.NumKind},
120
+
{Kind: adt.NumberKind},
121
121
},
122
122
Result: adt.IntKind,
123
123
Func: func(c *pkg.CallCtxt) {
···
129
129
}, {
130
130
Name: "MultipleOf",
131
131
Params: []pkg.Param{
132
-
{Kind: adt.NumKind},
133
-
{Kind: adt.NumKind},
132
+
{Kind: adt.NumberKind},
133
+
{Kind: adt.NumberKind},
134
134
},
135
135
Result: adt.BoolKind,
136
136
Func: func(c *pkg.CallCtxt) {
···
142
142
}, {
143
143
Name: "Abs",
144
144
Params: []pkg.Param{
145
-
{Kind: adt.NumKind},
145
+
{Kind: adt.NumberKind},
146
146
},
147
-
Result: adt.NumKind,
147
+
Result: adt.NumberKind,
148
148
Func: func(c *pkg.CallCtxt) {
149
149
x := c.Decimal(0)
150
150
if c.Do() {
···
154
154
}, {
155
155
Name: "Acosh",
156
156
Params: []pkg.Param{
157
-
{Kind: adt.NumKind},
157
+
{Kind: adt.NumberKind},
158
158
},
159
-
Result: adt.NumKind,
159
+
Result: adt.NumberKind,
160
160
Func: func(c *pkg.CallCtxt) {
161
161
x := c.Float64(0)
162
162
if c.Do() {
···
166
166
}, {
167
167
Name: "Asin",
168
168
Params: []pkg.Param{
169
-
{Kind: adt.NumKind},
169
+
{Kind: adt.NumberKind},
170
170
},
171
-
Result: adt.NumKind,
171
+
Result: adt.NumberKind,
172
172
Func: func(c *pkg.CallCtxt) {
173
173
x := c.Float64(0)
174
174
if c.Do() {
···
178
178
}, {
179
179
Name: "Acos",
180
180
Params: []pkg.Param{
181
-
{Kind: adt.NumKind},
181
+
{Kind: adt.NumberKind},
182
182
},
183
-
Result: adt.NumKind,
183
+
Result: adt.NumberKind,
184
184
Func: func(c *pkg.CallCtxt) {
185
185
x := c.Float64(0)
186
186
if c.Do() {
···
190
190
}, {
191
191
Name: "Asinh",
192
192
Params: []pkg.Param{
193
-
{Kind: adt.NumKind},
193
+
{Kind: adt.NumberKind},
194
194
},
195
-
Result: adt.NumKind,
195
+
Result: adt.NumberKind,
196
196
Func: func(c *pkg.CallCtxt) {
197
197
x := c.Float64(0)
198
198
if c.Do() {
···
202
202
}, {
203
203
Name: "Atan",
204
204
Params: []pkg.Param{
205
-
{Kind: adt.NumKind},
205
+
{Kind: adt.NumberKind},
206
206
},
207
-
Result: adt.NumKind,
207
+
Result: adt.NumberKind,
208
208
Func: func(c *pkg.CallCtxt) {
209
209
x := c.Float64(0)
210
210
if c.Do() {
···
214
214
}, {
215
215
Name: "Atan2",
216
216
Params: []pkg.Param{
217
-
{Kind: adt.NumKind},
218
-
{Kind: adt.NumKind},
217
+
{Kind: adt.NumberKind},
218
+
{Kind: adt.NumberKind},
219
219
},
220
-
Result: adt.NumKind,
220
+
Result: adt.NumberKind,
221
221
Func: func(c *pkg.CallCtxt) {
222
222
y, x := c.Float64(0), c.Float64(1)
223
223
if c.Do() {
···
227
227
}, {
228
228
Name: "Atanh",
229
229
Params: []pkg.Param{
230
-
{Kind: adt.NumKind},
230
+
{Kind: adt.NumberKind},
231
231
},
232
-
Result: adt.NumKind,
232
+
Result: adt.NumberKind,
233
233
Func: func(c *pkg.CallCtxt) {
234
234
x := c.Float64(0)
235
235
if c.Do() {
···
239
239
}, {
240
240
Name: "Cbrt",
241
241
Params: []pkg.Param{
242
-
{Kind: adt.NumKind},
242
+
{Kind: adt.NumberKind},
243
243
},
244
-
Result: adt.NumKind,
244
+
Result: adt.NumberKind,
245
245
Func: func(c *pkg.CallCtxt) {
246
246
x := c.Decimal(0)
247
247
if c.Do() {
···
284
284
}, {
285
285
Name: "Copysign",
286
286
Params: []pkg.Param{
287
-
{Kind: adt.NumKind},
288
-
{Kind: adt.NumKind},
287
+
{Kind: adt.NumberKind},
288
+
{Kind: adt.NumberKind},
289
289
},
290
-
Result: adt.NumKind,
290
+
Result: adt.NumberKind,
291
291
Func: func(c *pkg.CallCtxt) {
292
292
x, y := c.Decimal(0), c.Decimal(1)
293
293
if c.Do() {
···
297
297
}, {
298
298
Name: "Dim",
299
299
Params: []pkg.Param{
300
-
{Kind: adt.NumKind},
301
-
{Kind: adt.NumKind},
300
+
{Kind: adt.NumberKind},
301
+
{Kind: adt.NumberKind},
302
302
},
303
-
Result: adt.NumKind,
303
+
Result: adt.NumberKind,
304
304
Func: func(c *pkg.CallCtxt) {
305
305
x, y := c.Decimal(0), c.Decimal(1)
306
306
if c.Do() {
···
310
310
}, {
311
311
Name: "Erf",
312
312
Params: []pkg.Param{
313
-
{Kind: adt.NumKind},
313
+
{Kind: adt.NumberKind},
314
314
},
315
-
Result: adt.NumKind,
315
+
Result: adt.NumberKind,
316
316
Func: func(c *pkg.CallCtxt) {
317
317
x := c.Float64(0)
318
318
if c.Do() {
···
322
322
}, {
323
323
Name: "Erfc",
324
324
Params: []pkg.Param{
325
-
{Kind: adt.NumKind},
325
+
{Kind: adt.NumberKind},
326
326
},
327
-
Result: adt.NumKind,
327
+
Result: adt.NumberKind,
328
328
Func: func(c *pkg.CallCtxt) {
329
329
x := c.Float64(0)
330
330
if c.Do() {
···
334
334
}, {
335
335
Name: "Erfinv",
336
336
Params: []pkg.Param{
337
-
{Kind: adt.NumKind},
337
+
{Kind: adt.NumberKind},
338
338
},
339
-
Result: adt.NumKind,
339
+
Result: adt.NumberKind,
340
340
Func: func(c *pkg.CallCtxt) {
341
341
x := c.Float64(0)
342
342
if c.Do() {
···
346
346
}, {
347
347
Name: "Erfcinv",
348
348
Params: []pkg.Param{
349
-
{Kind: adt.NumKind},
349
+
{Kind: adt.NumberKind},
350
350
},
351
-
Result: adt.NumKind,
351
+
Result: adt.NumberKind,
352
352
Func: func(c *pkg.CallCtxt) {
353
353
x := c.Float64(0)
354
354
if c.Do() {
···
358
358
}, {
359
359
Name: "Exp",
360
360
Params: []pkg.Param{
361
-
{Kind: adt.NumKind},
361
+
{Kind: adt.NumberKind},
362
362
},
363
-
Result: adt.NumKind,
363
+
Result: adt.NumberKind,
364
364
Func: func(c *pkg.CallCtxt) {
365
365
x := c.Decimal(0)
366
366
if c.Do() {
···
370
370
}, {
371
371
Name: "Exp2",
372
372
Params: []pkg.Param{
373
-
{Kind: adt.NumKind},
373
+
{Kind: adt.NumberKind},
374
374
},
375
-
Result: adt.NumKind,
375
+
Result: adt.NumberKind,
376
376
Func: func(c *pkg.CallCtxt) {
377
377
x := c.Decimal(0)
378
378
if c.Do() {
···
382
382
}, {
383
383
Name: "Expm1",
384
384
Params: []pkg.Param{
385
-
{Kind: adt.NumKind},
385
+
{Kind: adt.NumberKind},
386
386
},
387
-
Result: adt.NumKind,
387
+
Result: adt.NumberKind,
388
388
Func: func(c *pkg.CallCtxt) {
389
389
x := c.Float64(0)
390
390
if c.Do() {
···
394
394
}, {
395
395
Name: "Gamma",
396
396
Params: []pkg.Param{
397
-
{Kind: adt.NumKind},
397
+
{Kind: adt.NumberKind},
398
398
},
399
-
Result: adt.NumKind,
399
+
Result: adt.NumberKind,
400
400
Func: func(c *pkg.CallCtxt) {
401
401
x := c.Float64(0)
402
402
if c.Do() {
···
406
406
}, {
407
407
Name: "Hypot",
408
408
Params: []pkg.Param{
409
-
{Kind: adt.NumKind},
410
-
{Kind: adt.NumKind},
409
+
{Kind: adt.NumberKind},
410
+
{Kind: adt.NumberKind},
411
411
},
412
-
Result: adt.NumKind,
412
+
Result: adt.NumberKind,
413
413
Func: func(c *pkg.CallCtxt) {
414
414
p, q := c.Float64(0), c.Float64(1)
415
415
if c.Do() {
···
419
419
}, {
420
420
Name: "J0",
421
421
Params: []pkg.Param{
422
-
{Kind: adt.NumKind},
422
+
{Kind: adt.NumberKind},
423
423
},
424
-
Result: adt.NumKind,
424
+
Result: adt.NumberKind,
425
425
Func: func(c *pkg.CallCtxt) {
426
426
x := c.Float64(0)
427
427
if c.Do() {
···
431
431
}, {
432
432
Name: "Y0",
433
433
Params: []pkg.Param{
434
-
{Kind: adt.NumKind},
434
+
{Kind: adt.NumberKind},
435
435
},
436
-
Result: adt.NumKind,
436
+
Result: adt.NumberKind,
437
437
Func: func(c *pkg.CallCtxt) {
438
438
x := c.Float64(0)
439
439
if c.Do() {
···
443
443
}, {
444
444
Name: "J1",
445
445
Params: []pkg.Param{
446
-
{Kind: adt.NumKind},
446
+
{Kind: adt.NumberKind},
447
447
},
448
-
Result: adt.NumKind,
448
+
Result: adt.NumberKind,
449
449
Func: func(c *pkg.CallCtxt) {
450
450
x := c.Float64(0)
451
451
if c.Do() {
···
455
455
}, {
456
456
Name: "Y1",
457
457
Params: []pkg.Param{
458
-
{Kind: adt.NumKind},
458
+
{Kind: adt.NumberKind},
459
459
},
460
-
Result: adt.NumKind,
460
+
Result: adt.NumberKind,
461
461
Func: func(c *pkg.CallCtxt) {
462
462
x := c.Float64(0)
463
463
if c.Do() {
···
468
468
Name: "Jn",
469
469
Params: []pkg.Param{
470
470
{Kind: adt.IntKind},
471
-
{Kind: adt.NumKind},
471
+
{Kind: adt.NumberKind},
472
472
},
473
-
Result: adt.NumKind,
473
+
Result: adt.NumberKind,
474
474
Func: func(c *pkg.CallCtxt) {
475
475
n, x := c.Int(0), c.Float64(1)
476
476
if c.Do() {
···
481
481
Name: "Yn",
482
482
Params: []pkg.Param{
483
483
{Kind: adt.IntKind},
484
-
{Kind: adt.NumKind},
484
+
{Kind: adt.NumberKind},
485
485
},
486
-
Result: adt.NumKind,
486
+
Result: adt.NumberKind,
487
487
Func: func(c *pkg.CallCtxt) {
488
488
n, x := c.Int(0), c.Float64(1)
489
489
if c.Do() {
···
493
493
}, {
494
494
Name: "Ldexp",
495
495
Params: []pkg.Param{
496
-
{Kind: adt.NumKind},
496
+
{Kind: adt.NumberKind},
497
497
{Kind: adt.IntKind},
498
498
},
499
-
Result: adt.NumKind,
499
+
Result: adt.NumberKind,
500
500
Func: func(c *pkg.CallCtxt) {
501
501
frac, exp := c.Float64(0), c.Int(1)
502
502
if c.Do() {
···
506
506
}, {
507
507
Name: "Log",
508
508
Params: []pkg.Param{
509
-
{Kind: adt.NumKind},
509
+
{Kind: adt.NumberKind},
510
510
},
511
-
Result: adt.NumKind,
511
+
Result: adt.NumberKind,
512
512
Func: func(c *pkg.CallCtxt) {
513
513
x := c.Decimal(0)
514
514
if c.Do() {
···
518
518
}, {
519
519
Name: "Log10",
520
520
Params: []pkg.Param{
521
-
{Kind: adt.NumKind},
521
+
{Kind: adt.NumberKind},
522
522
},
523
-
Result: adt.NumKind,
523
+
Result: adt.NumberKind,
524
524
Func: func(c *pkg.CallCtxt) {
525
525
x := c.Decimal(0)
526
526
if c.Do() {
···
530
530
}, {
531
531
Name: "Log2",
532
532
Params: []pkg.Param{
533
-
{Kind: adt.NumKind},
533
+
{Kind: adt.NumberKind},
534
534
},
535
-
Result: adt.NumKind,
535
+
Result: adt.NumberKind,
536
536
Func: func(c *pkg.CallCtxt) {
537
537
x := c.Decimal(0)
538
538
if c.Do() {
···
542
542
}, {
543
543
Name: "Log1p",
544
544
Params: []pkg.Param{
545
-
{Kind: adt.NumKind},
545
+
{Kind: adt.NumberKind},
546
546
},
547
-
Result: adt.NumKind,
547
+
Result: adt.NumberKind,
548
548
Func: func(c *pkg.CallCtxt) {
549
549
x := c.Float64(0)
550
550
if c.Do() {
···
554
554
}, {
555
555
Name: "Logb",
556
556
Params: []pkg.Param{
557
-
{Kind: adt.NumKind},
557
+
{Kind: adt.NumberKind},
558
558
},
559
-
Result: adt.NumKind,
559
+
Result: adt.NumberKind,
560
560
Func: func(c *pkg.CallCtxt) {
561
561
x := c.Float64(0)
562
562
if c.Do() {
···
566
566
}, {
567
567
Name: "Ilogb",
568
568
Params: []pkg.Param{
569
-
{Kind: adt.NumKind},
569
+
{Kind: adt.NumberKind},
570
570
},
571
571
Result: adt.IntKind,
572
572
Func: func(c *pkg.CallCtxt) {
···
578
578
}, {
579
579
Name: "Mod",
580
580
Params: []pkg.Param{
581
-
{Kind: adt.NumKind},
582
-
{Kind: adt.NumKind},
581
+
{Kind: adt.NumberKind},
582
+
{Kind: adt.NumberKind},
583
583
},
584
-
Result: adt.NumKind,
584
+
Result: adt.NumberKind,
585
585
Func: func(c *pkg.CallCtxt) {
586
586
x, y := c.Float64(0), c.Float64(1)
587
587
if c.Do() {
···
591
591
}, {
592
592
Name: "Pow",
593
593
Params: []pkg.Param{
594
-
{Kind: adt.NumKind},
595
-
{Kind: adt.NumKind},
594
+
{Kind: adt.NumberKind},
595
+
{Kind: adt.NumberKind},
596
596
},
597
-
Result: adt.NumKind,
597
+
Result: adt.NumberKind,
598
598
Func: func(c *pkg.CallCtxt) {
599
599
x, y := c.Decimal(0), c.Decimal(1)
600
600
if c.Do() {
···
606
606
Params: []pkg.Param{
607
607
{Kind: adt.IntKind},
608
608
},
609
-
Result: adt.NumKind,
609
+
Result: adt.NumberKind,
610
610
Func: func(c *pkg.CallCtxt) {
611
611
n := c.Int32(0)
612
612
if c.Do() {
···
616
616
}, {
617
617
Name: "Remainder",
618
618
Params: []pkg.Param{
619
-
{Kind: adt.NumKind},
620
-
{Kind: adt.NumKind},
619
+
{Kind: adt.NumberKind},
620
+
{Kind: adt.NumberKind},
621
621
},
622
-
Result: adt.NumKind,
622
+
Result: adt.NumberKind,
623
623
Func: func(c *pkg.CallCtxt) {
624
624
x, y := c.Float64(0), c.Float64(1)
625
625
if c.Do() {
···
629
629
}, {
630
630
Name: "Signbit",
631
631
Params: []pkg.Param{
632
-
{Kind: adt.NumKind},
632
+
{Kind: adt.NumberKind},
633
633
},
634
634
Result: adt.BoolKind,
635
635
Func: func(c *pkg.CallCtxt) {
···
641
641
}, {
642
642
Name: "Cos",
643
643
Params: []pkg.Param{
644
-
{Kind: adt.NumKind},
644
+
{Kind: adt.NumberKind},
645
645
},
646
-
Result: adt.NumKind,
646
+
Result: adt.NumberKind,
647
647
Func: func(c *pkg.CallCtxt) {
648
648
x := c.Float64(0)
649
649
if c.Do() {
···
653
653
}, {
654
654
Name: "Sin",
655
655
Params: []pkg.Param{
656
-
{Kind: adt.NumKind},
656
+
{Kind: adt.NumberKind},
657
657
},
658
-
Result: adt.NumKind,
658
+
Result: adt.NumberKind,
659
659
Func: func(c *pkg.CallCtxt) {
660
660
x := c.Float64(0)
661
661
if c.Do() {
···
665
665
}, {
666
666
Name: "Sinh",
667
667
Params: []pkg.Param{
668
-
{Kind: adt.NumKind},
668
+
{Kind: adt.NumberKind},
669
669
},
670
-
Result: adt.NumKind,
670
+
Result: adt.NumberKind,
671
671
Func: func(c *pkg.CallCtxt) {
672
672
x := c.Float64(0)
673
673
if c.Do() {
···
677
677
}, {
678
678
Name: "Cosh",
679
679
Params: []pkg.Param{
680
-
{Kind: adt.NumKind},
680
+
{Kind: adt.NumberKind},
681
681
},
682
-
Result: adt.NumKind,
682
+
Result: adt.NumberKind,
683
683
Func: func(c *pkg.CallCtxt) {
684
684
x := c.Float64(0)
685
685
if c.Do() {
···
689
689
}, {
690
690
Name: "Sqrt",
691
691
Params: []pkg.Param{
692
-
{Kind: adt.NumKind},
692
+
{Kind: adt.NumberKind},
693
693
},
694
-
Result: adt.NumKind,
694
+
Result: adt.NumberKind,
695
695
Func: func(c *pkg.CallCtxt) {
696
696
x := c.Float64(0)
697
697
if c.Do() {
···
701
701
}, {
702
702
Name: "Tan",
703
703
Params: []pkg.Param{
704
-
{Kind: adt.NumKind},
704
+
{Kind: adt.NumberKind},
705
705
},
706
-
Result: adt.NumKind,
706
+
Result: adt.NumberKind,
707
707
Func: func(c *pkg.CallCtxt) {
708
708
x := c.Float64(0)
709
709
if c.Do() {
···
713
713
}, {
714
714
Name: "Tanh",
715
715
Params: []pkg.Param{
716
-
{Kind: adt.NumKind},
716
+
{Kind: adt.NumberKind},
717
717
},
718
-
Result: adt.NumKind,
718
+
Result: adt.NumberKind,
719
719
Func: func(c *pkg.CallCtxt) {
720
720
x := c.Float64(0)
721
721
if c.Do() {
+2
-2
pkg/strconv/pkg.go
+2
-2
pkg/strconv/pkg.go
···
69
69
{Kind: adt.StringKind},
70
70
{Kind: adt.IntKind},
71
71
},
72
-
Result: adt.NumKind,
72
+
Result: adt.NumberKind,
73
73
Func: func(c *pkg.CallCtxt) {
74
74
s, bitSize := c.String(0), c.Int(1)
75
75
if c.Do() {
···
122
122
}, {
123
123
Name: "FormatFloat",
124
124
Params: []pkg.Param{
125
-
{Kind: adt.NumKind},
125
+
{Kind: adt.NumberKind},
126
126
{Kind: adt.IntKind},
127
127
{Kind: adt.IntKind},
128
128
{Kind: adt.IntKind},