Skip to content

Commit 984cba4

Browse files
juntuujuntuu
committed
Replace I and D with correct types
1 parent 7229958 commit 984cba4

File tree

2 files changed

+76
-69
lines changed

2 files changed

+76
-69
lines changed

‎jsrc/conversions.cpp

+75-68
Original file line numberDiff line numberDiff line change
@@ -72,7 +72,7 @@ template <typename From, typename To>
7272
[[nodiscard]] auto
7373
convert(J jt, array w, void *yv) -> bool {
7474
if constexpr (std::is_same_v<To, Z>) {
75-
return convert<From, To>(jt, w, yv, [](auto v) { return To{.re = static_cast<D>(v), .im = {}}; });
75+
return convert<From, To>(jt, w, yv, [](auto v) { return To{.re = static_cast<double>(v), .im = {}}; });
7676
} else if constexpr (!in_range<To, From>()) {
7777
return convert<From, To>(jt, w, yv, [](auto v) { return value_if(in_range<To>(v), v); });
7878
} else {
@@ -85,41 +85,41 @@ convert(J jt, array w, void *yv) -> bool {
8585

8686
template <>
8787
[[nodiscard]] auto
88-
convert<D, bool>(J jt, array w, void *yv, D fuzz) -> bool {
88+
convert<double, bool>(J jt, array w, void *yv, double fuzz) -> bool {
8989
auto const infinity = [](auto p) { return p < -2 || 2 < p; };
90-
return convert<D, bool>(
90+
return convert<double, bool>(
9191
jt, w, yv, [&](auto p) { return value_if(!infinity(p) && (p == 0.0 || fuzzy_equal(p, 1.0, fuzz)), p != 0.0); });
9292
}
9393

9494
template <>
9595
[[nodiscard]] auto
96-
convert<D, I>(J jt, array w, void *yv, D fuzz) -> bool {
97-
return convert<D, I>(jt, w, yv, [&](auto p) -> std::optional<I> {
96+
convert<double, int64_t>(J jt, array w, void *yv, double fuzz) -> bool {
97+
return convert<double, int64_t>(jt, w, yv, [&](auto p) -> std::optional<int64_t> {
9898
auto const q = jround(p);
9999
if (!(p == q || fuzzy_equal(p, q, fuzz))) {
100100
return std::nullopt; // must equal int, possibly out of range
101101
}
102102
// out-of-range values don't convert, handle separately
103-
if (p < static_cast<D>(IMIN)) {
103+
if (p < static_cast<double>(IMIN)) {
104104
return value_if(p >= IMIN * (1 + fuzz), IMIN);
105105
} // if tolerantly < IMIN, error; else take IMIN
106106
else if (p >= FLIMAX) {
107-
return value_if(p <= -static_cast<D>(IMIN) * (1 + fuzz), IMAX);
107+
return value_if(p <= -static_cast<double>(IMIN) * (1 + fuzz), IMAX);
108108
} // if tolerantly > IMAX, error; else take IMAX
109109
return q;
110110
});
111111
}
112112

113113
template <>
114114
[[nodiscard]] auto
115-
convert<Z, D>(J jt, array w, void *yv, D fuzz) -> bool {
115+
convert<Z, double>(J jt, array w, void *yv, double fuzz) -> bool {
116116
if (fuzz != 0.0) {
117-
return convert<Z, D>(jt, w, yv, [&](auto const &v) {
117+
return convert<Z, double>(jt, w, yv, [&](auto const &v) {
118118
auto const d = std::abs(v.im);
119119
return value_if(d != inf && d <= fuzz * std::abs(v.re), v.re);
120120
});
121121
}
122-
return convert<Z, D>(jt, w, yv, [](auto v) { return value_if(!v.im, v.re); });
122+
return convert<Z, double>(jt, w, yv, [](auto v) { return value_if(!v.im, v.re); });
123123
}
124124

125125
template <>
@@ -143,8 +143,8 @@ inplace_negate(T *u, int64_t n) {
143143

144144
template <>
145145
[[nodiscard]] auto
146-
convert<I, X>(J jt, array w, void *yv) -> bool {
147-
I u[XIDIG];
146+
convert<int64_t, X>(J jt, array w, void *yv) -> bool {
147+
int64_t u[XIDIG];
148148
auto const convert_one = [&](auto c) {
149149
auto const b = c == IMIN;
150150
auto d = b ? -(1 + c) : std::abs(c);
@@ -159,13 +159,13 @@ convert<I, X>(J jt, array w, void *yv) -> bool {
159159
if (0 > c) { inplace_negate(u, XIDIG); }
160160
return jtvec(jt, INT, length, u);
161161
};
162-
return convert<I, X>(jt, w, yv, convert_one) && !jt->jerr;
162+
return convert<int64_t, X>(jt, w, yv, convert_one) && !jt->jerr;
163163
}
164164

165165
static auto
166-
jtxd1(J jt, D p, I mode) -> X {
166+
jtxd1(J jt, double p, int64_t mode) -> X {
167167
PROLOG(0052);
168-
D e = jttfloor(jt, p);
168+
double e = jttfloor(jt, p);
169169
switch (mode) {
170170
case XMFLR: p = e; break;
171171
case XMCEIL: p = ceil(p); break;
@@ -186,7 +186,7 @@ jtxd1(J jt, D p, I mode) -> X {
186186
while (0 < d) {
187187
auto const q = floor(d / XBASE);
188188
auto const r = d - q * XBASE;
189-
u[m++] = static_cast<I>(r);
189+
u[m++] = static_cast<int64_t>(r);
190190
d = q;
191191
if (m == AN(t)) {
192192
RZ(t = jtext(jt, 0, t));
@@ -205,8 +205,8 @@ jtxd1(J jt, D p, I mode) -> X {
205205

206206
template <>
207207
[[nodiscard]] auto
208-
convert<D, X>(J jt, array w, void *yv, I mode) -> bool {
209-
return convert<D, X>(jt, w, yv, [=](auto v) { return jtxd1(jt, v, mode); }) && !jt->jerr;
208+
convert<double, X>(J jt, array w, void *yv, int64_t mode) -> bool {
209+
return convert<double, X>(jt, w, yv, [=](auto v) { return jtxd1(jt, v, mode); }) && !jt->jerr;
210210
}
211211

212212
template <>
@@ -228,21 +228,21 @@ value_from_X(X p) -> T {
228228

229229
template <>
230230
[[nodiscard]] auto
231-
convert<X, I>(J jt, array w, void *yv) -> bool {
231+
convert<X, int64_t>(J jt, array w, void *yv) -> bool {
232232
X p = jtxc(jt, IMAX);
233233
if (!p) return false;
234234
X q = jtxminus(jt, jtnegate(jt, p), jtxc(jt, 1L));
235235
if (!q) return false;
236-
return convert<X, I>(jt, w, yv, [&](auto c) -> std::optional<int64_t> {
236+
return convert<X, int64_t>(jt, w, yv, [&](auto c) -> std::optional<int64_t> {
237237
if (!(1 != jtxcompare(jt, q, c) && 1 != jtxcompare(jt, c, p))) return std::nullopt;
238238
return value_from_X<int64_t>(c);
239239
});
240240
}
241241

242242
template <>
243243
[[nodiscard]] auto
244-
convert<X, D>(J jt, array w, void *yv) -> bool {
245-
return convert<X, D>(jt, w, yv, [](auto p) {
244+
convert<X, double>(J jt, array w, void *yv) -> bool {
245+
return convert<X, double>(jt, w, yv, [](auto p) {
246246
auto const c = pointer_to_values<int64_t>(p)[AN(p) - 1];
247247
if (c == XPINF) { return inf; }
248248
if (c == XNINF) { return infm; }
@@ -258,12 +258,12 @@ convert<X, Q>(J jt, array w, void *yv) -> bool {
258258

259259
template <>
260260
[[nodiscard]] auto
261-
convert<D, Q>(J jt, array w, void *yv, I mode) -> bool {
261+
convert<double, Q>(J jt, array w, void *yv, int64_t mode) -> bool {
262262
if ((w) == nullptr) return false;
263263
auto const n = AN(w);
264264
auto *const wv = pointer_to_values<double>(w);
265265
auto *x = static_cast<Q *>(yv);
266-
D t = NAN;
266+
double t = NAN;
267267
auto *tv = 3 + reinterpret_cast<S *>(&t);
268268
Q q;
269269
for (int64_t i = 0; i < n; ++i) {
@@ -287,7 +287,7 @@ convert<D, Q>(J jt, array w, void *yv, I mode) -> bool {
287287
} else {
288288
bool const recip = 1 > t;
289289
if (recip) { t = 1.0 / t; }
290-
auto e = static_cast<I>(0xfff0 & *tv);
290+
auto e = static_cast<int64_t>(0xfff0 & *tv);
291291
e >>= 4;
292292
e -= 1023;
293293
if (recip) {
@@ -306,8 +306,8 @@ convert<D, Q>(J jt, array w, void *yv, I mode) -> bool {
306306

307307
template <>
308308
[[nodiscard]] auto
309-
convert<Q, D>(J jt, array w, void *yv) -> bool {
310-
auto const xb = static_cast<D>(XBASE);
309+
convert<Q, double>(J jt, array w, void *yv) -> bool {
310+
auto const xb = static_cast<double>(XBASE);
311311
auto const nn = 308 / XBASEN;
312312

313313
// TODO: figure out nice algorithm for this
@@ -322,7 +322,7 @@ convert<Q, D>(J jt, array w, void *yv) -> bool {
322322
};
323323

324324
X x2 = nullptr;
325-
return convert<Q, D>(jt, w, yv, [&](auto nd) -> std::optional<D> {
325+
return convert<Q, double>(jt, w, yv, [&](auto nd) -> std::optional<double> {
326326
auto *const p = nd.n;
327327
auto const pn = AN(p);
328328
auto const kk = 1 == pn ? pointer_to_values<int64_t>(p)[0] : 0;
@@ -359,9 +359,9 @@ convert<Q, X>(J jt, array w, void *yv) -> bool {
359359
// 0 if error, 1 if success. If the conversion loses precision, error is returned
360360
// Calls through bcvt are tagged with a flag in jt, indicating to set fuzz=0
361361
auto
362-
jtccvt(J jt, I tflagged, array w, array *y) -> bool {
362+
jtccvt(J jt, int64_t tflagged, array w, array *y) -> bool {
363363
FPREFIP;
364-
I const t = tflagged & NOUN;
364+
int64_t const t = tflagged & NOUN;
365365
if (w == nullptr) return false;
366366
auto const r = AR(w);
367367
auto *const s = AS(w);
@@ -376,7 +376,7 @@ jtccvt(J jt, I tflagged, array w, array *y) -> bool {
376376
jt->ranks = oqr;
377377
return true; // dense to sparse; convert type first (even if same dtype)
378378
case 3: // sparse to sparse
379-
I t1 = DTYPE(t);
379+
int64_t t1 = DTYPE(t);
380380
GASPARSE(*y, t, 1, r, s);
381381
P *yp = pointer_to_values<P>(*y);
382382
P *wp = pointer_to_values<P>(w);
@@ -406,14 +406,14 @@ jtccvt(J jt, I tflagged, array w, array *y) -> bool {
406406
if (!d) return false;
407407
auto *yv = pointer_to_values<void>(d); // allocate the same # atoms, even if we will convert fewer
408408
if ((tflagged & NOUNCVTVALIDCT) != 0) {
409-
I inputn = *reinterpret_cast<I *>(y); // fetch input, in case it is called for
410-
if (inputn > 0) { // if converting the leading values, just update the counts
411-
n = inputn; // set the counts for local use, and in the block to be converted
412-
} else { // if converting trailing values...
409+
int64_t inputn = *reinterpret_cast<int64_t *>(y); // fetch input, in case it is called for
410+
if (inputn > 0) { // if converting the leading values, just update the counts
411+
n = inputn; // set the counts for local use, and in the block to be converted
412+
} else { // if converting trailing values...
413413
AK(w) += (n + inputn) << bplg(wt);
414-
yv = reinterpret_cast<I *>(static_cast<C *>(yv) +
415-
((n + inputn) << bplg(t))); // advance input and output pointers to new area
416-
n = -inputn; // get positive # atoms to convert
414+
yv = reinterpret_cast<int64_t *>(
415+
static_cast<C *>(yv) + ((n + inputn) << bplg(t))); // advance input and output pointers to new area
416+
n = -inputn; // get positive # atoms to convert
417417
}
418418
AN(w) = n; // change atomct of w to # atoms to convert
419419
}
@@ -451,66 +451,73 @@ jtccvt(J jt, I tflagged, array w, array *y) -> bool {
451451
return convert<bool, X>(jt, w, pointer_to_values<int64_t>(d)) && convert<X, Q>(jt, d, yv);
452452
case CVCASE(FLX, B01X): return convert<bool, double>(jt, w, yv);
453453
case CVCASE(CMPXX, B01X): return convert<bool, Z>(jt, w, yv);
454-
case CVCASE(B01X, INTX): return convert<I, bool>(jt, w, yv);
455-
case CVCASE(XNUMX, INTX): return convert<I, X>(jt, w, yv);
454+
case CVCASE(B01X, INTX): return convert<int64_t, bool>(jt, w, yv);
455+
case CVCASE(XNUMX, INTX): return convert<int64_t, X>(jt, w, yv);
456456
case CVCASE(RATX, INTX):
457457
GATV(d, XNUM, n, r, s);
458-
return convert<I, X>(jt, w, pointer_to_values<int64_t>(d)) && convert<X, Q>(jt, d, yv);
458+
return convert<int64_t, X>(jt, w, pointer_to_values<int64_t>(d)) && convert<X, Q>(jt, d, yv);
459459
case CVCASE(FLX, INTX): return convert<int64_t, double>(jt, w, yv);
460460
case CVCASE(CMPXX, INTX): return convert<int64_t, Z>(jt, w, yv);
461-
case CVCASE(B01X, FLX): return convert<D, bool>(jt, w, yv, ((I)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ);
462-
case CVCASE(INTX, FLX): return convert<D, I>(jt, w, yv, ((I)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ);
461+
case CVCASE(B01X, FLX):
462+
return convert<double, bool>(jt, w, yv, ((int64_t)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ);
463+
case CVCASE(INTX, FLX):
464+
return convert<double, int64_t>(jt, w, yv, ((int64_t)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ);
463465
case CVCASE(XNUMX, FLX):
464-
return convert<D, X>(
466+
return convert<double, X>(
465467
jt, w, yv, (jt->xmode & REPSGN(SGNIFNOT(tflagged, XCVTXNUMORIDEX))) | (tflagged >> XCVTXNUMCVX));
466468
case CVCASE(RATX, FLX):
467-
return convert<D, Q>(
469+
return convert<double, Q>(
468470
jt, w, yv, (jt->xmode & REPSGN(SGNIFNOT(tflagged, XCVTXNUMORIDEX))) | (tflagged >> XCVTXNUMCVX));
469-
case CVCASE(CMPXX, FLX): return convert<D, Z>(jt, w, yv);
471+
case CVCASE(CMPXX, FLX): return convert<double, Z>(jt, w, yv);
470472
case CVCASE(B01X, CMPXX):
471473
GATV(d, FL, n, r, s);
472-
return convert<Z, D>(jt, w, pointer_to_values<int64_t>(d), ((I)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ) &&
473-
convert<D, bool>(jt, d, yv, ((I)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ);
474+
return convert<Z, double>(
475+
jt, w, pointer_to_values<int64_t>(d), ((int64_t)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ) &&
476+
convert<double, bool>(jt, d, yv, ((int64_t)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ);
474477
case CVCASE(INTX, CMPXX):
475478
GATV(d, FL, n, r, s);
476-
return convert<Z, D>(jt, w, pointer_to_values<int64_t>(d), ((I)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ) &&
477-
convert<D, I>(jt, d, yv, ((I)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ);
479+
return convert<Z, double>(
480+
jt, w, pointer_to_values<int64_t>(d), ((int64_t)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ) &&
481+
convert<double, int64_t>(jt, d, yv, ((int64_t)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ);
478482
case CVCASE(XNUMX, CMPXX):
479483
GATV(d, FL, n, r, s);
480-
return convert<Z, D>(jt, w, pointer_to_values<int64_t>(d), ((I)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ) &&
481-
convert<D, X>(
484+
return convert<Z, double>(
485+
jt, w, pointer_to_values<int64_t>(d), ((int64_t)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ) &&
486+
convert<double, X>(
482487
jt, d, yv, (jt->xmode & REPSGN(SGNIFNOT(tflagged, XCVTXNUMORIDEX))) | (tflagged >> XCVTXNUMCVX));
483488
case CVCASE(RATX, CMPXX):
484489
GATV(d, FL, n, r, s);
485-
return convert<Z, D>(jt, w, pointer_to_values<int64_t>(d), ((I)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ) &&
486-
convert<D, Q>(
490+
return convert<Z, double>(
491+
jt, w, pointer_to_values<int64_t>(d), ((int64_t)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ) &&
492+
convert<double, Q>(
487493
jt, d, yv, (jt->xmode & REPSGN(SGNIFNOT(tflagged, XCVTXNUMORIDEX))) | (tflagged >> XCVTXNUMCVX));
488-
case CVCASE(FLX, CMPXX): return convert<Z, D>(jt, w, yv, ((I)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ);
494+
case CVCASE(FLX, CMPXX):
495+
return convert<Z, double>(jt, w, yv, ((int64_t)jtinplace & JTNOFUZZ) != 0 ? 0.0 : FUZZ);
489496
case CVCASE(B01X, XNUMX): return convert<X, bool>(jt, w, yv);
490-
case CVCASE(INTX, XNUMX): return convert<X, I>(jt, w, yv);
497+
case CVCASE(INTX, XNUMX): return convert<X, int64_t>(jt, w, yv);
491498
case CVCASE(RATX, XNUMX): return convert<X, Q>(jt, w, yv);
492-
case CVCASE(FLX, XNUMX): return convert<X, D>(jt, w, yv);
499+
case CVCASE(FLX, XNUMX): return convert<X, double>(jt, w, yv);
493500
case CVCASE(CMPXX, XNUMX):
494501
GATV(d, FL, n, r, s);
495-
return convert<X, D>(jt, w, pointer_to_values<int64_t>(d)) && convert<D, Z>(jt, d, yv);
502+
return convert<X, double>(jt, w, pointer_to_values<int64_t>(d)) && convert<double, Z>(jt, d, yv);
496503
case CVCASE(B01X, RATX):
497504
GATV(d, XNUM, n, r, s);
498505
return convert<Q, X>(jt, w, pointer_to_values<int64_t>(d)) && convert<X, bool>(jt, d, yv);
499506
case CVCASE(INTX, RATX):
500507
GATV(d, XNUM, n, r, s);
501-
return convert<Q, X>(jt, w, pointer_to_values<int64_t>(d)) && convert<X, I>(jt, d, yv);
508+
return convert<Q, X>(jt, w, pointer_to_values<int64_t>(d)) && convert<X, int64_t>(jt, d, yv);
502509
case CVCASE(XNUMX, RATX): return convert<Q, X>(jt, w, yv);
503-
case CVCASE(FLX, RATX): return convert<Q, D>(jt, w, yv);
510+
case CVCASE(FLX, RATX): return convert<Q, double>(jt, w, yv);
504511
case CVCASE(CMPXX, RATX):
505512
GATV(d, FL, n, r, s);
506-
return convert<Q, D>(jt, w, pointer_to_values<int64_t>(d)) && convert<D, Z>(jt, d, yv);
513+
return convert<Q, double>(jt, w, pointer_to_values<int64_t>(d)) && convert<double, Z>(jt, d, yv);
507514
default: ASSERT(0, EVDOMAIN);
508515
}
509516
}
510517

511518
// clear rank before calling ccvt - needed for sparse arrays only but returns the block as the result
512519
auto
513-
jtcvt(J jt, I t, array w) -> array {
520+
jtcvt(J jt, int64_t t, array w) -> array {
514521
array y = nullptr;
515522
bool const b = jtccvt(jt, t, w, &y);
516523
ASSERT(b, EVDOMAIN);
@@ -526,7 +533,7 @@ jtbcvt(J jt, C mode, array w) -> array {
526533
FPREFIP;
527534
if (w == nullptr) { return nullptr; }
528535

529-
auto const as_integer = [](auto const &v) { return *(I *)&v; };
536+
auto const as_integer = [](auto const &v) { return *(int64_t *)&v; };
530537
auto const isflag = [&](auto const &z) { return as_integer(z.im) == NANFLAG; };
531538

532539
// there may be values (especially b types) that were nominally CMPX but might actually be integers. Those were
@@ -541,15 +548,15 @@ jtbcvt(J jt, C mode, array w) -> array {
541548
// auto flags = std::transform_reduce(wv, wv + AN(w), int64_t{}, std::plus{}, isflag);
542549
auto flags = std::accumulate(wv, wv + AN(w), int64_t{}, [&](auto sum, auto v) { return sum + isflag(v); });
543550
if (flags != 0) {
544-
I ipok = SGNIF(jtinplace, JTINPLACEWX) & AC(w); // both sign bits set (<0) if inplaceable
551+
int64_t ipok = SGNIF(jtinplace, JTINPLACEWX) & AC(w); // both sign bits set (<0) if inplaceable
545552
if (flags == AN(w)) {
546553
if (ipok >= 0) GATV(result, INT, AN(w), AR(w), AS(w));
547554
std::transform(
548555
wv, wv + AN(w), pointer_to_values<int64_t>(result), [&](auto const &z) { return as_integer(z.re); });
549556
} else {
550557
if (ipok >= 0) GATV(result, CMPX, AN(w), AR(w), AS(w));
551558
std::transform(wv, wv + AN(w), pointer_to_values<Z>(result), [&](auto const &z) -> Z {
552-
if (isflag(z)) { return {.re = (D)as_integer(z.re), .im = 0.0}; };
559+
if (isflag(z)) { return {.re = (double)as_integer(z.re), .im = 0.0}; };
553560
return z; // copy floats, and converts any integers back to float
554561
});
555562
}
@@ -561,7 +568,7 @@ jtbcvt(J jt, C mode, array w) -> array {
561568
// To avoid a needless copy, suppress conversion to B01 if type is B01, to INT if type is INT, etc
562569
// set the NOFUZZ flag in jt to insist on an exact match so we won't lose precision
563570
array y = nullptr;
564-
jtinplace = (J)((I)jt + JTNOFUZZ); // demand exact match
571+
jtinplace = (J)((int64_t)jt + JTNOFUZZ); // demand exact match
565572
result = ((mode & 14) == 0) && jtccvt(jtinplace, B01, w, &y) ? y
566573
: (y = w, AT(w) & INT || (((mode & 12) == 0) && jtccvt(jtinplace, INT, w, &y))) ? y
567574
: (y = w, AT(w) & FL || (((mode & 8) == 0) && jtccvt(jtinplace, FL, w, &y)))
@@ -582,7 +589,7 @@ jticvt(J jt, array w) -> array {
582589
}
583590

584591
auto
585-
jtpcvt(J jt, I t, array w) -> array {
592+
jtpcvt(J jt, int64_t t, array w) -> array {
586593
RANK2T oqr = jt->ranks;
587594
RESETRANK;
588595
array y = nullptr;
@@ -611,7 +618,7 @@ jtxco1(J jt, array w) -> array {
611618
auto
612619
jtxco2(J jt, array a, array w) -> array {
613620
ASSERT(AT(w) & DENSE, EVNONCE);
614-
I j = jti0(jt, a);
621+
int64_t j = jti0(jt, a);
615622
if (jt->jerr != 0) return nullptr;
616623
switch (j) {
617624
case -2: return jtaslash1(jt, CDIV, w);

‎jsrc/je.h

+1-1
Original file line numberDiff line numberDiff line change
@@ -551,7 +551,7 @@ extern A jtcreatecycliciterator(J, A, A);
551551
extern A jtcrelocalsyms(J, A, A, I, I, I);
552552
extern A jtcstr(J, C*);
553553
extern A jtcvt(J, I, A);
554-
extern bool jtccvt(J, I, A, A*);
554+
extern bool jtccvt(J, int64_t, A, A*);
555555
extern A jtcvz(J, I, A);
556556
extern A jtdaxis(J, I, A);
557557
extern A jtddtokens(J, A, I);

0 commit comments

Comments
 (0)