Skip to content

Adjusting the Stdlib to cope with our conceptual TC problem #253

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
sbscholz merged 3 commits into from
Feb 13, 2026
Merged

Adjusting the Stdlib to cope with our conceptual TC problem #253

Show file tree
Hide file tree
Changes from 2 commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
133bed2
Adjusted ArrayArith to cope with our conceptual TC problem....
sbscholz Feb 12, 2026
22330de
Adjusted ScalarArith and ComplexArrayArith as well
sbscholz Feb 13, 2026
b3f00cb
elided unnecessary parameter in logic ops
sbscholz Feb 13, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion include/builtin.mac
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -48,7 +48,7 @@ REAL_NUM(fun)
INT_NUM(fun) \
REAL_NUM(fun)

#define CHAR(fun) \
#define CHAR(fun) \
fun(char, /* no postfix */, c, ' ', ' ')

#define BOOL(fun) \
Expand Down
114 changes: 57 additions & 57 deletions include/templates.mac
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,101 +16,101 @@
*
******************************************************************************/

#define MAP_ARI_OPS(ext, a) \
MAP_BIN_##ext(+, _add_SxS_, a, a) \
MAP_BIN_##ext(-, _sub_SxS_, a, a) \
MAP_BIN_##ext(*, _mul_SxS_, a, a) \
MAP_BIN_##ext(/, _div_SxS_, a, a) \
MAP_BIN_##ext(min, _min_SxS_, a, a) \
MAP_BIN_##ext(max, _max_SxS_, a, a)
#define MAP_ARI_OPS(ext, a, _zval) \
MAP_BIN_##ext(+, _add_SxS_, a, a, _zval, _zval) \
MAP_BIN_##ext(-, _sub_SxS_, a, a, _zval, _zval) \
MAP_BIN_##ext(*, _mul_SxS_, a, a, _zval, _zval) \
MAP_BIN_##ext(/, _div_SxS_, a, a, _zval, _zval) \
MAP_BIN_##ext(min, _min_SxS_, a, a, _zval, _zval) \
MAP_BIN_##ext(max, _max_SxS_, a, a, _zval, _zval)

#define MAP_ABS_OP(ext, a) \
MAP_MON_##ext(abs, _abs_S_, a, a)
#define MAP_ABS_OP(ext, a, _zval) \
MAP_MON_##ext(abs, _abs_S_, a, a, _zval, _zval)

#define MAP_ABS_NOOP(ext, a) \
MAP_MON_##ext(abs, /* no postfix */, a, a)
#define MAP_ABS_NOOP(ext, a, _zval) \
MAP_MON_##ext(abs, /* no postfix */, a, a, _zval, _zval)

#define MAP_NEG_OP(ext, a) \
MAP_MON_##ext(-, _neg_S_, a, a)
#define MAP_NEG_OP(ext, a, _zval) \
MAP_MON_##ext(-, _neg_S_, a, a, _zval, _zval)

#define MAP_ANA_OPS(ext, a) \
MAP_UNA_##ext(++, _add_SxS_, a, a) \
MAP_UNA_##ext(--, _sub_SxS_, a, a)

#define MAP_INT_OPS(ext, a) \
MAP_BIN_##ext(mod, _aplmod_SxS_, a, a) \
MAP_BIN_##ext(%, _mod_SxS_, a, a) \
MAP_BIN_##ext(^, _bitxor_SxS_, a, a) \
MAP_BIN_##ext(|, _bitor_SxS_, a, a) \
MAP_BIN_##ext(&, _bitand_SxS_, a, a) \
MAP_BIN_##ext(<<, _shl_SxS_, a, a) \
MAP_BIN_##ext(>>, _shr_SxS_, a, a)
#define MAP_INT_OPS(ext, a, _zval) \
MAP_BIN_##ext(mod, _aplmod_SxS_, a, a, _zval, _zval) \
MAP_BIN_##ext(%, _mod_SxS_, a, a, _zval, _zval) \
MAP_BIN_##ext(^, _bitxor_SxS_, a, a, _zval, _zval) \
MAP_BIN_##ext(|, _bitor_SxS_, a, a, _zval, _zval) \
MAP_BIN_##ext(&, _bitand_SxS_, a, a, _zval, _zval) \
MAP_BIN_##ext(<<, _shl_SxS_, a, a, _zval, _zval) \
MAP_BIN_##ext(>>, _shr_SxS_, a, a, _zval, _zval)

/******************************************************************************
*
* Macros for generating MACRO calls for all relational operations.
*
******************************************************************************/

#define MAP_REL_OPS(ext, a) \
MAP_EQ_OPS(ext, a) \
MAP_COMP_OPS(ext, a)
#define MAP_REL_OPS(ext, a, _zval) \
MAP_EQ_OPS(ext, a, _zval) \
MAP_COMP_OPS(ext, a, _zval)

#define MAP_EQ_OPS(ext, a) \
MAP_BIN_##ext(==, _eq_SxS_, a, bool) \
MAP_BIN_##ext(!=, _neq_SxS_, a, bool)
#define MAP_EQ_OPS(ext, a, _zval) \
MAP_BIN_##ext(==, _eq_SxS_, a, bool, _zval, true) \
MAP_BIN_##ext(!=, _neq_SxS_, a, bool, _zval, true)

#define MAP_COMP_OPS(ext, a) \
MAP_BIN_##ext(<, _lt_SxS_, a, bool) \
MAP_BIN_##ext(<=, _le_SxS_, a, bool) \
MAP_BIN_##ext(>, _gt_SxS_, a, bool) \
MAP_BIN_##ext(>=, _ge_SxS_, a, bool)
#define MAP_COMP_OPS(ext, a, _zval) \
MAP_BIN_##ext(<, _lt_SxS_, a, bool, _zval, true) \
MAP_BIN_##ext(<=, _le_SxS_, a, bool, _zval, true) \
MAP_BIN_##ext(>, _gt_SxS_, a, bool, _zval, true) \
MAP_BIN_##ext(>=, _ge_SxS_, a, bool, _zval, true)

/******************************************************************************
*
* Macros for generating MACRO calls for all logic operations.
*
******************************************************************************/

#define MAP_LOG_OPS(ext) \
MAP_BIN_##ext(&, _and_SxS_, bool, bool) \
MAP_BIN_##ext(|, _or_SxS_, bool, bool) \
MAP_MON_##ext(!, _not_S_, bool, bool)
#define MAP_LOG_OPS(ext, _zval) \
MAP_BIN_##ext(&, _and_SxS_, bool, bool, _zval, true) \
MAP_BIN_##ext(|, _or_SxS_, bool, bool, _zval, true) \
MAP_MON_##ext(!, _not_S_, bool, bool, _zval, true)
Comment thread
sbscholz marked this conversation as resolved.
Outdated

/******************************************************************************
*
* Macros for generating MACRO calls for all conversion operations.
*
******************************************************************************/

#define MAP_BOOL_CONV_OP(ext, a) \
MAP_MON_##ext(tobool, _tobool_S_, a, bool)
#define MAP_BOOL_CONV_OP(ext, a, _zval) \
MAP_MON_##ext(tobool, _tobool_S_, a, bool, _zval, true)

#define MAP_MIN_NUM_CONV_OPS(ext, a) \
MAP_MON_##ext(toi, _toi_S_, a, int) \
MAP_MON_##ext(tol, _tol_S_, a, long) \
MAP_MON_##ext(toui, _toui_S_, a, uint) \
MAP_MON_##ext(toul, _toul_S_, a, ulong) \
MAP_MON_##ext(tof, _tof_S_, a, float) \
MAP_MON_##ext(tod, _tod_S_, a, double)
#define MAP_MIN_NUM_CONV_OPS(ext, a, _zval) \
MAP_MON_##ext(toi, _toi_S_, a, int, _zval, 0i) \
MAP_MON_##ext(tol, _tol_S_, a, long, _zval, 0l) \
MAP_MON_##ext(toui, _toui_S_, a, uint, _zval, 0ui) \
MAP_MON_##ext(toul, _toul_S_, a, ulong, _zval, 0ul) \
MAP_MON_##ext(tof, _tof_S_, a, float, _zval, 0f) \
MAP_MON_##ext(tod, _tod_S_, a, double, _zval, 0d)

#ifdef FULLTYPES

#define MAP_FULL_NUM_CONV_OPS(ext, a) \
MAP_MON_##ext(tob, _tob_S_, a, byte) \
MAP_MON_##ext(tosh, _tos_S_, a, short) \
MAP_MON_##ext(toll, _toll_S_, a, longlong) \
MAP_MON_##ext(toub, _toub_S_, a, ubyte) \
MAP_MON_##ext(tous, _tous_S_, a, ushort) \
MAP_MON_##ext(toull, _toull_S_, a, ulonglong)
#define MAP_FULL_NUM_CONV_OPS(ext, a, _zval) \
MAP_MON_##ext(tob, _tob_S_, a, byte, _zval, 0b) \
MAP_MON_##ext(tosh, _tos_S_, a, short, _zval, 0s) \
MAP_MON_##ext(toll, _toll_S_, a, longlong, _zval, 0ll) \
MAP_MON_##ext(toub, _toub_S_, a, ubyte, _zval, 0ub) \
MAP_MON_##ext(tous, _tous_S_, a, ushort, _zval, 0us) \
MAP_MON_##ext(toull, _toull_S_, a, ulonglong, _zval, 0ull)

#define MAP_NUM_CONV_OPS(ext, a) \
MAP_MIN_NUM_CONV_OPS(ext, a) \
MAP_FULL_NUM_CONV_OPS(ext, a)
#define MAP_NUM_CONV_OPS(ext, a, _zval) \
MAP_MIN_NUM_CONV_OPS(ext, a, _zval) \
MAP_FULL_NUM_CONV_OPS(ext, a, _zval)

#else /* FULLTYPES */

#define MAP_NUM_CONV_OPS(ext, a) \
MAP_MIN_NUM_CONV_OPS(ext, a)
#define MAP_NUM_CONV_OPS(ext, a, _zval) \
MAP_MIN_NUM_CONV_OPS(ext, a, _zval)

#endif /* FULLTYPES */
74 changes: 39 additions & 35 deletions src/structures/ArrayArith.xsac
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -37,25 +37,28 @@ export all;
*
******************************************************************************/

#define MAP_BIN_AxA(name, op, a, b) \
#define MAP_BIN_AxA(name, op, a, b, adef, bdef) \
inline \
b[d>0:shp] name(a[d>0:shp] A, a[d>0:shp] B) \
{ \
return { iv -> op(_sel_VxA_(iv, A), _sel_VxA_(iv, B)) | iv < shp }; \
return { iv -> op(_sel_VxA_(iv, A), _sel_VxA_(iv, B)) | iv < shp; \
iv -> bdef | iv < shp }; \
}

#define MAP_BIN_AxS(name, op, a, b) \
#define MAP_BIN_AxS(name, op, a, b, adef, bdef) \
inline \
b[d>0:shp] name(a[d>0:shp] A, a B) \
{ \
return { iv -> op(_sel_VxA_(iv, A), B) | iv < shp }; \
return { iv -> op(_sel_VxA_(iv, A), B) | iv < shp; \
iv -> bdef | iv < shp }; \
}

#define MAP_BIN_SxA(name, op, a, b) \
#define MAP_BIN_SxA(name, op, a, b, adef, bdef) \
inline \
b[d>0:shp] name(a A, a[d>0:shp] B) \
{ \
return { iv -> op(A, _sel_VxA_(iv, B)) | iv < shp }; \
return { iv -> op(A, _sel_VxA_(iv, B)) | iv < shp; \
iv -> bdef | iv < shp }; \
}

/******************************************************************************/
Expand Down Expand Up @@ -87,15 +90,16 @@ int[n] name(int A, int[n] B) \
*
******************************************************************************/

#define MAP_MON_AxA(name, op, a, b) \
#define MAP_MON_AxA(name, op, a, b, adef, bdef) \
inline \
b[d>0:shp] name(a[d>0:shp] A) \
{ \
return { iv -> op(_sel_VxA_(iv, A)) | iv < shp }; \
return { iv -> op(_sel_VxA_(iv, A)) | iv < shp; \
iv -> bdef | iv < shp }; \
}

#define MAP_MON_AxS(name, op, a, b)
#define MAP_MON_SxA(name, op, a, b)
#define MAP_MON_AxS(name, op, a, b, adef, bdef)
#define MAP_MON_SxA(name, op, a, b, adef, bdef)

/******************************************************************************
*
Expand All @@ -104,23 +108,23 @@ b[d>0:shp] name(a[d>0:shp] A) \
******************************************************************************/

#define ARI_OPS_A(typ, _postfix, _fmt, _zval, _oval) \
MAP_ARI_OPS(AxA, typ) \
MAP_ARI_OPS(AxS, typ) \
MAP_ARI_OPS(SxA, typ)
MAP_ARI_OPS(AxA, typ, _zval) \
MAP_ARI_OPS(AxS, typ, _zval) \
MAP_ARI_OPS(SxA, typ, _zval)

NUM(ARI_OPS_A)

/******************************************************************************/

#define ABS_OP_A(type, _postfix, _fmt, _zval, _oval) \
MAP_ABS_OP(AxA, type) \
MAP_ABS_OP(AxS, type) \
MAP_ABS_OP(SxA, type)
MAP_ABS_OP(AxA, type, _zval) \
MAP_ABS_OP(AxS, type, _zval) \
MAP_ABS_OP(SxA, type, _zval)

#define ABS_NOOP_A(type, _postfix, _fmt, _zval, _oval) \
MAP_ABS_NOOP(AxA, type) \
MAP_ABS_NOOP(AxS, type) \
MAP_ABS_NOOP(SxA, type)
MAP_ABS_NOOP(AxA, type, _zval) \
MAP_ABS_NOOP(AxS, type, _zval) \
MAP_ABS_NOOP(SxA, type, _zval)

SIGNED_NUM(ABS_OP_A)
// abs is noop on unsigned numbers
Expand All @@ -129,18 +133,18 @@ UNSIGNED_INT_NUM(ABS_NOOP_A)
/******************************************************************************/

#define NEG_OP_A(typ, _postfix, _fmt, _zval, _oval) \
MAP_NEG_OP(AxA, typ) \
MAP_NEG_OP(AxS, typ) \
MAP_NEG_OP(SxA, typ)
MAP_NEG_OP(AxA, typ, _zval) \
MAP_NEG_OP(AxS, typ, _zval) \
MAP_NEG_OP(SxA, typ, _zval)

SIGNED_NUM(NEG_OP_A)

/******************************************************************************/

#define INT_OPS_A(typ, _postfix, _fmt, _zval, _oval) \
MAP_INT_OPS(AxA, typ) \
MAP_INT_OPS(AxS, typ) \
MAP_INT_OPS(SxA, typ)
MAP_INT_OPS(AxA, typ, _zval) \
MAP_INT_OPS(AxS, typ, _zval) \
MAP_INT_OPS(SxA, typ, _zval)

INT_NUM(INT_OPS_A)

Expand All @@ -151,9 +155,9 @@ INT_NUM(INT_OPS_A)
******************************************************************************/

#define REL_OPS_A(typ, _postfix, _fmt, _zval, _oval) \
MAP_REL_OPS(AxA, typ) \
MAP_REL_OPS(AxS, typ) \
MAP_REL_OPS(SxA, typ)
MAP_REL_OPS(AxA, typ, _zval) \
MAP_REL_OPS(AxS, typ, _zval) \
MAP_REL_OPS(SxA, typ, _zval)

BUILT_IN(REL_OPS_A)

Expand All @@ -163,25 +167,25 @@ BUILT_IN(REL_OPS_A)
*
******************************************************************************/

MAP_LOG_OPS(AxA)
MAP_LOG_OPS(AxS)
MAP_LOG_OPS(SxA)
MAP_LOG_OPS(AxA, true)
MAP_LOG_OPS(AxS, true)
MAP_LOG_OPS(SxA, true)

/******************************************************************************
*
* ConvOPS on scalars (see templates.mac for details).
*
******************************************************************************/

#define BOOL_CONV_OP_A(typ, _postfix, _fmt, _zero, _one) \
MAP_BOOL_CONV_OP(AxA, typ)
#define BOOL_CONV_OP_A(typ, _postfix, _fmt, _zval, _oval) \
MAP_BOOL_CONV_OP(AxA, typ, _zval)

NUM(BOOL_CONV_OP_A)
BOOL(BOOL_CONV_OP_A)

/******************************************************************************/

#define NUM_CONV_OPS_A(typ, _postfix, _fmt, _zero, _one) \
MAP_NUM_CONV_OPS(AxA, typ)
#define NUM_CONV_OPS_A(typ, _postfix, _fmt, _zval, _oval) \
MAP_NUM_CONV_OPS(AxA, typ, _zval)

BUILT_IN(NUM_CONV_OPS_A)
12 changes: 8 additions & 4 deletions src/structures/ArrayTransform.xsac
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -58,28 +58,32 @@ BUILT_IN(TRANSPOSE)
inline \
typ[d:shp] where(bool[d:shp] p, typ[d:shp] A, typ[d:shp] B) \
{ \
return { iv -> _sel_VxA_(iv, p) ? _sel_VxA_(iv, A) : _sel_VxA_(iv, B) }; \
return { iv -> _sel_VxA_(iv, p) ? _sel_VxA_(iv, A) : _sel_VxA_(iv, B); \
iv -> _zval | iv < shp }; \
}

#define WHERE_AxS(typ, _postfix, _fmt, _zval, _oval) \
inline \
typ[d:shp] where(bool[d:shp] p, typ[d:shp] A, typ B) \
{ \
return { iv -> _sel_VxA_(iv, p) ? _sel_VxA_(iv, A) : B }; \
return { iv -> _sel_VxA_(iv, p) ? _sel_VxA_(iv, A) : B; \
iv -> _zval | iv < shp }; \
}

#define WHERE_SxA(typ, _postfix, _fmt, _zval, _oval) \
inline \
typ[d:shp] where(bool[d:shp] p, typ A, typ[d:shp] B) \
{ \
return { iv -> _sel_VxA_(iv, p) ? A : _sel_VxA_(iv, B) }; \
return { iv -> _sel_VxA_(iv, p) ? A : _sel_VxA_(iv, B); \
iv -> _zval | iv < shp }; \
}

#define WHERE_SxS(typ, _postfix, _fmt, _zval, _oval) \
inline \
typ[b:shp] where(bool[b:shp] p, typ A, typ B) \
{ \
return { iv -> _sel_VxA_(iv, p) ? A : B }; \
return { iv -> _sel_VxA_(iv, p) ? A : B; \
iv -> _zval | iv < shp }; \
}

#define WHERE(typ, postfix, fmt, zval, oval) \
Expand Down
Loading