RubyGems - carray - Versions diffs - 3.0.1 → 3.0.3 - Mend

carray 3.0.1 → 3.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (229) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +824 -0
data/README.md +5 -6
data/carray.gemspec +1 -1
data/ext/ca_axis_dispatch.c +258 -4
data/ext/ca_axis_group.c +368 -184
data/ext/ca_binop_dispatch.c +54 -32
data/ext/ca_binop_dispatch.h +1 -0
data/ext/ca_categorical_iterator.c +90 -41
data/ext/ca_compare.c +8 -2
data/ext/ca_for_buffer.h +21 -68
data/ext/ca_group_iter.c +27 -11
data/ext/ca_kernel_iterator.c +960 -245
data/ext/ca_kernel_iterator.h +352 -181
data/ext/ca_monop_dispatch.c +4 -4
data/ext/ca_monop_dispatch.h +4 -0
data/ext/ca_obj_array.c +194 -42
data/ext/ca_obj_bincmp.c +152 -121
data/ext/ca_obj_binop.c +107 -210
data/ext/ca_obj_bitarray.c +37 -24
data/ext/ca_obj_bitfield.c +95 -62
data/ext/ca_obj_block.c +5 -4
data/ext/ca_obj_byte_swap.c +40 -40
data/ext/ca_obj_const_string.c +180 -50
data/ext/ca_obj_face.c +428 -62
data/ext/ca_obj_face.h +107 -47
data/ext/ca_obj_fake.c +21 -50
data/ext/ca_obj_farray.c +1 -0
data/ext/ca_obj_field.c +16 -3
data/ext/ca_obj_fixlen_string.c +39 -26
data/ext/ca_obj_grid.c +181 -124
data/ext/ca_obj_meld.c +235 -55
data/ext/ca_obj_moncmp.c +61 -61
data/ext/ca_obj_monop.c +125 -107
data/ext/ca_obj_object.c +551 -233
data/ext/ca_obj_record.c +51 -16
data/ext/ca_obj_reduce.c +5 -8
data/ext/ca_obj_refer.c +117 -33
data/ext/ca_obj_remap.c +57 -17
data/ext/ca_obj_repeat.c +21 -5
data/ext/ca_obj_roll.c +115 -11
data/ext/ca_obj_select.c +88 -75
data/ext/ca_obj_select_axis.c +58 -60
data/ext/ca_obj_shift.c +22 -102
data/ext/ca_obj_stack.c +223 -123
data/ext/ca_obj_stride.c +267 -35
data/ext/ca_obj_string.c +25 -22
data/ext/ca_obj_tile.c +32 -16
data/ext/ca_obj_time.c +23 -25
data/ext/ca_obj_timedelta.c +21 -23
data/ext/ca_obj_transpose.c +12 -3
data/ext/ca_obj_triop.c +110 -117
data/ext/ca_obj_window.c +157 -29
data/ext/ca_op_ipower.c +25 -13
data/ext/ca_op_powi.h +57 -30
data/ext/ca_pow5_table.h +656 -0
data/ext/ca_rng_normal.h +42 -0
data/ext/ca_rng_xoshiro256pp.h +105 -0
data/ext/ca_sort_kernels.h +70 -0
data/ext/ca_sweep_engine.c +385 -198
data/ext/ca_sweep_engine.h +31 -23
data/ext/ca_triop_dispatch.c +4 -1
data/ext/ca_triop_dispatch.h +5 -2
data/ext/caframe_csv_reader.c +463 -0
data/ext/carray.h +90 -28
data/ext/carray_access.c +487 -231
data/ext/carray_address_basis.c +731 -0
data/ext/carray_attribute.c +45 -3
data/ext/carray_bincount.c +32 -2
data/ext/carray_broadcast.c +49 -17
data/ext/carray_call_cfunc.c +667 -511
data/ext/carray_cast.c +1556 -247
data/ext/carray_cast_func.rb +34 -21
data/ext/carray_conversion.c +197 -73
data/ext/carray_copy.c +84 -38
data/ext/carray_core.c +591 -119
data/ext/carray_count.c +148 -96
data/ext/carray_element.c +18 -27
data/ext/carray_factorize.c +604 -291
data/ext/carray_generate.c +76 -40
data/ext/carray_histogram.c +152 -94
data/ext/carray_hold.c +2 -1
data/ext/carray_index_classifier.c +63 -96
data/ext/carray_internal.h +400 -1
data/ext/carray_lazy.c +834 -79
data/ext/carray_loop.c +88 -66
data/ext/carray_mask.c +705 -324
data/ext/carray_math_kernel.h +1 -0
data/ext/carray_median_percentile.c +263 -63
data/ext/carray_memory_view.c +254 -248
data/ext/carray_operator.c +1093 -363
data/ext/carray_order.c +133 -69
data/ext/carray_partition.c +102 -56
data/ext/carray_random.c +582 -204
data/ext/carray_scatter.c +308 -65
data/ext/carray_segment.c +257 -0
data/ext/carray_slab.c +183 -70
data/ext/carray_sort.c +235 -240
data/ext/carray_sort_kernel.c +8 -1
data/ext/carray_struct.c +99 -21
data/ext/carray_test.c +167 -64
data/ext/carray_time_text.c +1182 -0
data/ext/carray_utils.c +363 -98
data/ext/extconf.rb +27 -2
data/ext/mk_call_cfunc.rb +103 -118
data/ext/mk_pow5_table.rb +35 -0
data/ext/mkkernel.rb +1349 -851
data/ext/ruby_carray.c +17 -2
data/ext/version.h +4 -4
data/ext/version.rb +4 -2
data/lib/carray/attribute.rb +39 -0
data/lib/carray/autoload_carray.rb +24 -3
data/lib/carray/autoload_method_extension.rb +18 -0
data/lib/carray/axis_group.rb +245 -20
data/lib/carray/basics.rb +95 -25
data/lib/carray/bincount_nd.rb +6 -0
data/lib/carray/block_iterator.rb +200 -54
data/lib/carray/boolean_reduce.rb +21 -29
data/lib/carray/categorical.rb +244 -59
data/lib/carray/categorical_iterator.rb +391 -757
data/lib/carray/complex.rb +36 -29
data/lib/carray/conditional.rb +94 -7
data/lib/carray/const_string.rb +177 -27
data/lib/carray/construct.rb +40 -0
data/lib/carray/data_type_extension.rb +3 -0
data/lib/carray/data_type_limits.rb +91 -0
data/lib/carray/fixlen_string.rb +1 -1
data/lib/carray/frame/concat.rb +157 -6
data/lib/carray/frame/convert.rb +13 -7
data/lib/carray/frame/csv_parser.rb +590 -76
data/lib/carray/frame/describe.rb +79 -0
data/lib/carray/frame/frame.rb +205 -35
data/lib/carray/frame/group.rb +199 -40
data/lib/carray/frame/io.rb +452 -60
data/lib/carray/frame/join.rb +134 -46
data/lib/carray/frame/records.rb +54 -19
data/lib/carray/frame/reshape.rb +448 -0
data/lib/carray/frame/sort.rb +26 -2
data/lib/carray/frame/verbs.rb +726 -56
data/lib/carray/frame.rb +2 -0
data/lib/carray/fuse_source.rb +111 -2
data/lib/carray/fusion.rb +229 -38
data/lib/carray/inspect.rb +71 -20
data/lib/carray/iterator.rb +157 -2
data/lib/carray/lazy.rb +54 -67
data/lib/carray/mask_gap_fill.rb +66 -50
data/lib/carray/math.rb +32 -19
data/lib/carray/meld_reduce.rb +40 -7
data/lib/carray/methods/align_addr.rb +8 -4
data/lib/carray/methods/bincount.rb +2 -2
data/lib/carray/methods/bit_string.rb +14 -3
data/lib/carray/methods/composition.rb +16 -10
data/lib/carray/methods/discovery_along.rb +74 -0
data/lib/carray/methods/factorize.rb +50 -0
data/lib/carray/methods/gather_nd.rb +13 -2
data/lib/carray/methods/insert_block.rb +9 -14
data/lib/carray/methods/is_in.rb +130 -6
data/lib/carray/methods/join.rb +1 -1
data/lib/carray/methods/locate_addr.rb +235 -21
data/lib/carray/methods/mask_duplicates.rb +35 -1
data/lib/carray/methods/mode.rb +18 -1
data/lib/carray/methods/nunique.rb +22 -1
data/lib/carray/methods/repeat.rb +91 -0
data/lib/carray/methods/resize.rb +21 -23
data/lib/carray/methods/snap.rb +34 -12
data/lib/carray/methods/unique.rb +52 -3
data/lib/carray/record_order.rb +208 -0
data/lib/carray/rng.rb +86 -0
data/lib/carray/runtime.rb +14 -11
data/lib/carray/segment_iterator.rb +990 -0
data/lib/carray/serialize.rb +197 -27
data/lib/carray/slab_iterator.rb +109 -40
data/lib/carray/stack.rb +10 -4
data/lib/carray/string_operation_extension.rb +9 -4
data/lib/carray/struct.rb +142 -51
data/lib/carray/struct_builder.rb +110 -14
data/lib/carray/table.rb +2 -2
data/lib/carray/time.rb +535 -105
data/lib/carray/window_iterator.rb +259 -82
data/lib/carray.rb +4 -2
data/yard-stubs/ca_obj_array.rb +4 -4
data/yard-stubs/ca_obj_bitarray.rb +7 -0
data/yard-stubs/ca_obj_bitfield.rb +23 -12
data/yard-stubs/ca_obj_block.rb +2 -7
data/yard-stubs/ca_obj_fake.rb +1 -1
data/yard-stubs/ca_obj_field.rb +1 -1
data/yard-stubs/ca_obj_refer.rb +3 -3
data/yard-stubs/ca_obj_roll.rb +0 -1
data/yard-stubs/ca_obj_stride.rb +10 -7
data/yard-stubs/ca_obj_transpose.rb +1 -1
data/yard-stubs/ca_obj_window.rb +11 -4
data/yard-stubs/carray_access.rb +6 -5
data/yard-stubs/carray_broadcast.rb +2 -2
data/yard-stubs/carray_cast.rb +78 -43
data/yard-stubs/carray_conversion.rb +13 -1
data/yard-stubs/carray_copy.rb +8 -3
data/yard-stubs/carray_core.rb +3 -83
data/yard-stubs/carray_count.rb +16 -2
data/yard-stubs/carray_lazy.rb +210 -1
data/yard-stubs/carray_loop.rb +4 -1
data/yard-stubs/carray_mask.rb +34 -10
data/yard-stubs/carray_math.rb +1499 -4
data/yard-stubs/carray_median_percentile.rb +26 -8
data/yard-stubs/carray_order.rb +43 -82
data/yard-stubs/carray_scatter.rb +10 -3
data/yard-stubs/carray_segment.rb +72 -0
data/yard-stubs/carray_slab.rb +11 -8
data/yard-stubs/carray_sort.rb +50 -8
data/yard-stubs/carray_test.rb +10 -0
data/yard-stubs/carray_utils.rb +0 -26
metadata +19 -19
data/ext/ca_for_each_element.h +0 -239
data/ext/carray_build_flags.h +0 -3
data/ext/carray_config.h +0 -28
data/ext/carray_kernels_bincmp.c +0 -4446
data/ext/carray_kernels_binop.c +0 -11001
data/ext/carray_kernels_init.c +0 -1131
data/ext/carray_kernels_map.c +0 -3467
data/ext/carray_kernels_moncmp.c +0 -2097
data/ext/carray_kernels_monop.c +0 -18313
data/ext/carray_kernels_reduce_aggregate.c +0 -25837
data/ext/carray_kernels_reduce_boolean.c +0 -330
data/ext/carray_kernels_reduce_cumulative.c +0 -14593
data/ext/carray_kernels_reduce_extreme.c +0 -16948
data/ext/carray_kernels_reduce_variance.c +0 -3910
data/ext/carray_kernels_scan.c +0 -3693
data/ext/carray_kernels_search.c +0 -32138
data/ext/carray_kernels_sort.c +0 -10626
data/ext/carray_kernels_triop.c +0 -1392

data/ext/carray_kernels_init.c DELETED Viewed

@@ -1,1131 +0,0 @@
-/* GENERATED aggregator: dispatches to per-tag Init_carray_kernels_<tag>() */
-#include "carray.h"
-void Init_carray_kernels_reduce_aggregate (void);
-void Init_carray_kernels_reduce_extreme (void);
-void Init_carray_kernels_reduce_cumulative (void);
-void Init_carray_kernels_reduce_boolean (void);
-void Init_carray_kernels_reduce_variance (void);
-void Init_carray_kernels_map (void);
-void Init_carray_kernels_scan (void);
-void Init_carray_kernels_sort (void);
-void Init_carray_kernels_search (void);
-void Init_carray_kernels_monop (void);
-void Init_carray_kernels_binop (void);
-void Init_carray_kernels_triop (void);
-void Init_carray_kernels_moncmp (void);
-void Init_carray_kernels_bincmp (void);
-/* The text of every kernel body, for a caller that compiles the same
-   operation elsewhere.  Placeholders are left in place. */
-typedef struct {
-  const char *kind;
-  const char *name;
-  const char *data_type;
-  const char *body;
-} ca_kernel_body_t;
-static const ca_kernel_body_t ca_kernel_bodies[] = {
-  { "monop", "zero", "int8",
-    "(#2) = 0;" },
-  { "monop", "zero", "uint8",
-    "(#2) = 0;" },
-  { "monop", "zero", "int16",
-    "(#2) = 0;" },
-  { "monop", "zero", "uint16",
-    "(#2) = 0;" },
-  { "monop", "zero", "int32",
-    "(#2) = 0;" },
-  { "monop", "zero", "uint32",
-    "(#2) = 0;" },
-  { "monop", "zero", "int64",
-    "(#2) = 0;" },
-  { "monop", "zero", "uint64",
-    "(#2) = 0;" },
-  { "monop", "zero", "float32",
-    "(#2) = 0;" },
-  { "monop", "zero", "float64",
-    "(#2) = 0;" },
-  { "monop", "zero", "boolean",
-    "(#2) = 0;" },
-  { "monop", "zero", "cmplx64",
-    "(#2) = 0.0;" },
-  { "monop", "zero", "cmplx128",
-    "(#2) = 0.0;" },
-  { "monop", "one", "int8",
-    "(#2) = 1;" },
-  { "monop", "one", "uint8",
-    "(#2) = 1;" },
-  { "monop", "one", "int16",
-    "(#2) = 1;" },
-  { "monop", "one", "uint16",
-    "(#2) = 1;" },
-  { "monop", "one", "int32",
-    "(#2) = 1;" },
-  { "monop", "one", "uint32",
-    "(#2) = 1;" },
-  { "monop", "one", "int64",
-    "(#2) = 1;" },
-  { "monop", "one", "uint64",
-    "(#2) = 1;" },
-  { "monop", "one", "float32",
-    "(#2) = 1;" },
-  { "monop", "one", "float64",
-    "(#2) = 1;" },
-  { "monop", "one", "boolean",
-    "(#2) = 1;" },
-  { "monop", "one", "cmplx64",
-    "(#2) = 1.0;" },
-  { "monop", "one", "cmplx128",
-    "(#2) = 1.0;" },
-  { "monop", "frac", "int8",
-    "(#2) = 0;" },
-  { "monop", "frac", "uint8",
-    "(#2) = 0;" },
-  { "monop", "frac", "int16",
-    "(#2) = 0;" },
-  { "monop", "frac", "uint16",
-    "(#2) = 0;" },
-  { "monop", "frac", "int32",
-    "(#2) = 0;" },
-  { "monop", "frac", "uint32",
-    "(#2) = 0;" },
-  { "monop", "frac", "int64",
-    "(#2) = 0;" },
-  { "monop", "frac", "uint64",
-    "(#2) = 0;" },
-  { "monop", "frac", "float32",
-    "(#2) = ((#1)>0.0) ? (#1)-floor(#1) : ((#1)<0.0) ? (#1)-ceil(#1) : (#1);" },
-  { "monop", "frac", "float64",
-    "(#2) = ((#1)>0.0) ? (#1)-floor(#1) : ((#1)<0.0) ? (#1)-ceil(#1) : (#1);" },
-  { "monop", "neg", "int8",
-    "(#2) = -(#1);" },
-  { "monop", "neg", "uint8",
-    "(#2) = -(#1);" },
-  { "monop", "neg", "int16",
-    "(#2) = -(#1);" },
-  { "monop", "neg", "uint16",
-    "(#2) = -(#1);" },
-  { "monop", "neg", "int32",
-    "(#2) = -(#1);" },
-  { "monop", "neg", "uint32",
-    "(#2) = -(#1);" },
-  { "monop", "neg", "int64",
-    "(#2) = -(#1);" },
-  { "monop", "neg", "uint64",
-    "(#2) = -(#1);" },
-  { "monop", "neg", "float32",
-    "(#2) = -(#1);" },
-  { "monop", "neg", "float64",
-    "(#2) = -(#1);" },
-  { "monop", "neg", "cmplx64",
-    "(#2) = -(#1);" },
-  { "monop", "neg", "cmplx128",
-    "(#2) = -(#1);" },
-  { "monop", "bit_neg", "int8",
-    "(#2) = ~(#1);" },
-  { "monop", "bit_neg", "uint8",
-    "(#2) = ~(#1);" },
-  { "monop", "bit_neg", "int16",
-    "(#2) = ~(#1);" },
-  { "monop", "bit_neg", "uint16",
-    "(#2) = ~(#1);" },
-  { "monop", "bit_neg", "int32",
-    "(#2) = ~(#1);" },
-  { "monop", "bit_neg", "uint32",
-    "(#2) = ~(#1);" },
-  { "monop", "bit_neg", "int64",
-    "(#2) = ~(#1);" },
-  { "monop", "bit_neg", "uint64",
-    "(#2) = ~(#1);" },
-  { "monop", "bit_neg", "boolean",
-    "(#2) = (#1) ? 0 : 1;" },
-  { "monop", "abs_i", "int8",
-    "(#2) = abs(#1);" },
-  { "monop", "abs_i", "uint8",
-    "(#2) = (#1);" },
-  { "monop", "abs_i", "int16",
-    "(#2) = abs(#1);" },
-  { "monop", "abs_i", "uint16",
-    "(#2) = (#1);" },
-  { "monop", "abs_i", "int32",
-    "(#2) = abs(#1);" },
-  { "monop", "abs_i", "uint32",
-    "(#2) = (#1);" },
-  { "monop", "abs_i", "int64",
-    "(#2) = llabs(#1);" },
-  { "monop", "abs_i", "uint64",
-    "(#2) = (#1);" },
-  { "monop", "abs_i", "float32",
-    "(#2) = fabs((float64_t)#1);" },
-  { "monop", "abs_i", "float64",
-    "(#2) = fabs((float64_t)#1);" },
-  { "monop", "abs_i", "cmplx64",
-    "(#2) = cabsf(#1);" },
-  { "monop", "abs_i", "cmplx128",
-    "(#2) = cabs(#1);" },
-  { "monop", "abs", "int8",
-    "(#2) = abs(#1);" },
-  { "monop", "abs", "uint8",
-    "(#2) = (#1);" },
-  { "monop", "abs", "int16",
-    "(#2) = abs(#1);" },
-  { "monop", "abs", "uint16",
-    "(#2) = (#1);" },
-  { "monop", "abs", "int32",
-    "(#2) = abs(#1);" },
-  { "monop", "abs", "uint32",
-    "(#2) = (#1);" },
-  { "monop", "abs", "int64",
-    "(#2) = llabs(#1);" },
-  { "monop", "abs", "uint64",
-    "(#2) = (#1);" },
-  { "monop", "abs", "float32",
-    "(#2) = fabs(#1);" },
-  { "monop", "abs", "float64",
-    "(#2) = fabs(#1);" },
-  { "monop", "abs", "cmplx64",
-    "(#2) = cabsf(#1);" },
-  { "monop", "abs", "cmplx128",
-    "(#2) = cabs(#1);" },
-  { "monop", "abs2", "int8",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "abs2", "uint8",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "abs2", "int16",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "abs2", "uint16",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "abs2", "int32",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "abs2", "uint32",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "abs2", "int64",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "abs2", "uint64",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "abs2", "float32",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "abs2", "float64",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "abs2", "cmplx64",
-    "{ float _r = crealf(#1); float _i = cimagf(#1); (#2) = _r * _r + _i * _i; }" },
-  { "monop", "abs2", "cmplx128",
-    "{ double _r = creal(#1); double _i = cimag(#1); (#2) = _r * _r + _i * _i; }" },
-  { "monop", "conj", "int8",
-    "(#2) = (#1);" },
-  { "monop", "conj", "uint8",
-    "(#2) = (#1);" },
-  { "monop", "conj", "int16",
-    "(#2) = (#1);" },
-  { "monop", "conj", "uint16",
-    "(#2) = (#1);" },
-  { "monop", "conj", "int32",
-    "(#2) = (#1);" },
-  { "monop", "conj", "uint32",
-    "(#2) = (#1);" },
-  { "monop", "conj", "int64",
-    "(#2) = (#1);" },
-  { "monop", "conj", "uint64",
-    "(#2) = (#1);" },
-  { "monop", "conj", "float32",
-    "(#2) = (#1);" },
-  { "monop", "conj", "float64",
-    "(#2) = (#1);" },
-  { "monop", "conj", "cmplx64",
-    "(#2) = conjf(#1);" },
-  { "monop", "conj", "cmplx128",
-    "(#2) = conj(#1);" },
-  { "monop", "sign", "int8",
-    "(#2) = ((#1) > 0) - ((#1) < 0);" },
-  { "monop", "sign", "uint8",
-    "(#2) = ((#1) > 0) ? 1 : 0;" },
-  { "monop", "sign", "int16",
-    "(#2) = ((#1) > 0) - ((#1) < 0);" },
-  { "monop", "sign", "uint16",
-    "(#2) = ((#1) > 0) ? 1 : 0;" },
-  { "monop", "sign", "int32",
-    "(#2) = ((#1) > 0) - ((#1) < 0);" },
-  { "monop", "sign", "uint32",
-    "(#2) = ((#1) > 0) ? 1 : 0;" },
-  { "monop", "sign", "int64",
-    "(#2) = ((#1) > 0) - ((#1) < 0);" },
-  { "monop", "sign", "uint64",
-    "(#2) = ((#1) > 0) ? 1 : 0;" },
-  { "monop", "sign", "float32",
-    "(#2) = isnan(#1) ? (#1) : (((#1) > 0) - ((#1) < 0));" },
-  { "monop", "sign", "float64",
-    "(#2) = isnan(#1) ? (#1) : (((#1) > 0) - ((#1) < 0));" },
-  { "monop", "sign", "boolean",
-    "(#2) = (#1) ? 1 : 0;" },
-  { "monop", "sign", "cmplx64",
-    "{ float _m = cabsf(#1); (#2) = (_m == 0) ? 0 : ((#1) / _m); }" },
-  { "monop", "sign", "cmplx128",
-    "{ double _m = cabs(#1); (#2) = (_m == 0) ? 0 : ((#1) / _m); }" },
-  { "monop", "arg", "int8",
-    "(#2) = carg((cmplx128_t)(#1));" },
-  { "monop", "arg", "uint8",
-    "(#2) = carg((cmplx128_t)(#1));" },
-  { "monop", "arg", "int16",
-    "(#2) = carg((cmplx128_t)(#1));" },
-  { "monop", "arg", "uint16",
-    "(#2) = carg((cmplx128_t)(#1));" },
-  { "monop", "arg", "int32",
-    "(#2) = carg((cmplx128_t)(#1));" },
-  { "monop", "arg", "uint32",
-    "(#2) = carg((cmplx128_t)(#1));" },
-  { "monop", "arg", "int64",
-    "(#2) = carg((cmplx128_t)(#1));" },
-  { "monop", "arg", "uint64",
-    "(#2) = carg((cmplx128_t)(#1));" },
-  { "monop", "arg", "float32",
-    "(#2) = carg((cmplx128_t)(#1));" },
-  { "monop", "arg", "float64",
-    "(#2) = carg((cmplx128_t)(#1));" },
-  { "monop", "arg", "cmplx64",
-    "(#2) = cargf(#1);" },
-  { "monop", "arg", "cmplx128",
-    "(#2) = carg(#1);" },
-  { "monop", "imag_i", "int8",
-    "(#2) = 0;" },
-  { "monop", "imag_i", "uint8",
-    "(#2) = 0;" },
-  { "monop", "imag_i", "int16",
-    "(#2) = 0;" },
-  { "monop", "imag_i", "uint16",
-    "(#2) = 0;" },
-  { "monop", "imag_i", "int32",
-    "(#2) = 0;" },
-  { "monop", "imag_i", "uint32",
-    "(#2) = 0;" },
-  { "monop", "imag_i", "int64",
-    "(#2) = 0;" },
-  { "monop", "imag_i", "uint64",
-    "(#2) = 0;" },
-  { "monop", "imag_i", "float32",
-    "(#2) = 0;" },
-  { "monop", "imag_i", "float64",
-    "(#2) = 0;" },
-  { "monop", "imag_i", "cmplx64",
-    "(#2) = cimagf(#1);" },
-  { "monop", "imag_i", "cmplx128",
-    "(#2) = cimag(#1);" },
-  { "monop", "arg_i", "float32",
-    "(#2) = cargf((cmplx64_t)(#1));" },
-  { "monop", "arg_i", "float64",
-    "(#2) = carg((cmplx128_t)(#1));" },
-  { "monop", "arg_i", "cmplx64",
-    "(#2) = cargf(#1);" },
-  { "monop", "arg_i", "cmplx128",
-    "(#2) = carg(#1);" },
-  { "monop", "not", "boolean",
-    "(#2) = (#1) ? 0 : 1;" },
-  { "monop", "rad", "float32",
-    "(#2) = (0.0174532925199433*(#1));" },
-  { "monop", "rad", "float64",
-    "(#2) = (0.0174532925199433*(#1));" },
-  { "monop", "deg", "float32",
-    "(#2) = (57.2957795130823*(#1));" },
-  { "monop", "deg", "float64",
-    "(#2) = (57.2957795130823*(#1));" },
-  { "monop", "ceil", "int8",
-    "(#2) = (#1);" },
-  { "monop", "ceil", "uint8",
-    "(#2) = (#1);" },
-  { "monop", "ceil", "int16",
-    "(#2) = (#1);" },
-  { "monop", "ceil", "uint16",
-    "(#2) = (#1);" },
-  { "monop", "ceil", "int32",
-    "(#2) = (#1);" },
-  { "monop", "ceil", "uint32",
-    "(#2) = (#1);" },
-  { "monop", "ceil", "int64",
-    "(#2) = (#1);" },
-  { "monop", "ceil", "uint64",
-    "(#2) = (#1);" },
-  { "monop", "ceil", "float32",
-    "(#2) = ceil(#1);" },
-  { "monop", "ceil", "float64",
-    "(#2) = ceil(#1);" },
-  { "monop", "floor", "int8",
-    "(#2) = (#1);" },
-  { "monop", "floor", "uint8",
-    "(#2) = (#1);" },
-  { "monop", "floor", "int16",
-    "(#2) = (#1);" },
-  { "monop", "floor", "uint16",
-    "(#2) = (#1);" },
-  { "monop", "floor", "int32",
-    "(#2) = (#1);" },
-  { "monop", "floor", "uint32",
-    "(#2) = (#1);" },
-  { "monop", "floor", "int64",
-    "(#2) = (#1);" },
-  { "monop", "floor", "uint64",
-    "(#2) = (#1);" },
-  { "monop", "floor", "float32",
-    "(#2) = floor(#1);" },
-  { "monop", "floor", "float64",
-    "(#2) = floor(#1);" },
-  { "monop", "round", "int8",
-    "(#2) = (#1);" },
-  { "monop", "round", "uint8",
-    "(#2) = (#1);" },
-  { "monop", "round", "int16",
-    "(#2) = (#1);" },
-  { "monop", "round", "uint16",
-    "(#2) = (#1);" },
-  { "monop", "round", "int32",
-    "(#2) = (#1);" },
-  { "monop", "round", "uint32",
-    "(#2) = (#1);" },
-  { "monop", "round", "int64",
-    "(#2) = (#1);" },
-  { "monop", "round", "uint64",
-    "(#2) = (#1);" },
-  { "monop", "round", "float32",
-    "(#2) = ((#1)>0.0) ? floor((#1)+0.5) : ((#1)<0.0) ? ceil((#1)-0.5) : (#1);" },
-  { "monop", "round", "float64",
-    "(#2) = ((#1)>0.0) ? floor((#1)+0.5) : ((#1)<0.0) ? ceil((#1)-0.5) : (#1);" },
-  { "monop", "rcp", "int8",
-    "if ((#1)==0) {ca_zerodiv();}; (#2) = 1/(#1);" },
-  { "monop", "rcp", "uint8",
-    "if ((#1)==0) {ca_zerodiv();}; (#2) = 1/(#1);" },
-  { "monop", "rcp", "int16",
-    "if ((#1)==0) {ca_zerodiv();}; (#2) = 1/(#1);" },
-  { "monop", "rcp", "uint16",
-    "if ((#1)==0) {ca_zerodiv();}; (#2) = 1/(#1);" },
-  { "monop", "rcp", "int32",
-    "if ((#1)==0) {ca_zerodiv();}; (#2) = 1/(#1);" },
-  { "monop", "rcp", "uint32",
-    "if ((#1)==0) {ca_zerodiv();}; (#2) = 1/(#1);" },
-  { "monop", "rcp", "int64",
-    "if ((#1)==0) {ca_zerodiv();}; (#2) = 1/(#1);" },
-  { "monop", "rcp", "uint64",
-    "if ((#1)==0) {ca_zerodiv();}; (#2) = 1/(#1);" },
-  { "monop", "rcp", "float32",
-    "(#2) = 1/(#1);" },
-  { "monop", "rcp", "float64",
-    "(#2) = 1/(#1);" },
-  { "monop", "rcp", "cmplx64",
-    "(#2) = op_crcp_cmplx64(#1);" },
-  { "monop", "rcp", "cmplx128",
-    "(#2) = 1/(#1);" },
-  { "monop", "sqrt", "float32",
-    "(#2) = sqrtf(#1);" },
-  { "monop", "sqrt", "float64",
-    "(#2) = sqrt(#1);" },
-  { "monop", "sqrt", "cmplx64",
-    "(#2) = csqrtf(#1);" },
-  { "monop", "sqrt", "cmplx128",
-    "(#2) = csqrt(#1);" },
-  { "monop", "exp", "float32",
-    "(#2) = expf(#1);" },
-  { "monop", "exp", "float64",
-    "(#2) = exp(#1);" },
-  { "monop", "exp", "cmplx64",
-    "(#2) = cexpf(#1);" },
-  { "monop", "exp", "cmplx128",
-    "(#2) = cexp(#1);" },
-  { "monop", "sin", "float32",
-    "(#2) = sinf(#1);" },
-  { "monop", "sin", "float64",
-    "(#2) = sin(#1);" },
-  { "monop", "sin", "cmplx64",
-    "(#2) = csinf(#1);" },
-  { "monop", "sin", "cmplx128",
-    "(#2) = csin(#1);" },
-  { "monop", "cos", "float32",
-    "(#2) = cosf(#1);" },
-  { "monop", "cos", "float64",
-    "(#2) = cos(#1);" },
-  { "monop", "cos", "cmplx64",
-    "(#2) = ccosf(#1);" },
-  { "monop", "cos", "cmplx128",
-    "(#2) = ccos(#1);" },
-  { "monop", "tan", "float32",
-    "(#2) = tanf(#1);" },
-  { "monop", "tan", "float64",
-    "(#2) = tan(#1);" },
-  { "monop", "tan", "cmplx64",
-    "(#2) = ctanf(#1);" },
-  { "monop", "tan", "cmplx128",
-    "(#2) = ctan(#1);" },
-  { "monop", "asin", "float32",
-    "(#2) = asinf(#1);" },
-  { "monop", "asin", "float64",
-    "(#2) = asin(#1);" },
-  { "monop", "asin", "cmplx64",
-    "(#2) = casinf(#1);" },
-  { "monop", "asin", "cmplx128",
-    "(#2) = casin(#1);" },
-  { "monop", "acos", "float32",
-    "(#2) = acosf(#1);" },
-  { "monop", "acos", "float64",
-    "(#2) = acos(#1);" },
-  { "monop", "acos", "cmplx64",
-    "(#2) = cacosf(#1);" },
-  { "monop", "acos", "cmplx128",
-    "(#2) = cacos(#1);" },
-  { "monop", "atan", "float32",
-    "(#2) = atanf(#1);" },
-  { "monop", "atan", "float64",
-    "(#2) = atan(#1);" },
-  { "monop", "atan", "cmplx64",
-    "(#2) = catanf(#1);" },
-  { "monop", "atan", "cmplx128",
-    "(#2) = catan(#1);" },
-  { "monop", "log", "float32",
-    "(#2) = logf(#1);" },
-  { "monop", "log", "float64",
-    "(#2) = log(#1);" },
-  { "monop", "log", "cmplx64",
-    "(#2) = clog(#1);" },
-  { "monop", "log", "cmplx128",
-    "(#2) = clog(#1);" },
-  { "monop", "exp2", "float32",
-    "(#2) = exp2f(#1);" },
-  { "monop", "exp2", "float64",
-    "(#2) = exp2(#1);" },
-  { "monop", "exp2", "cmplx64",
-    "(#2) = cpow(2, (#1));" },
-  { "monop", "exp2", "cmplx128",
-    "(#2) = cpow(2, (#1));" },
-  { "monop", "log10", "float32",
-    "(#2) = log10f(#1);" },
-  { "monop", "log10", "float64",
-    "(#2) = log10(#1);" },
-  { "monop", "log2", "float32",
-    "(#2) = log2f(#1);" },
-  { "monop", "log2", "float64",
-    "(#2) = log2(#1);" },
-  { "monop", "logb", "float32",
-    "(#2) = logbf(#1);" },
-  { "monop", "logb", "float64",
-    "(#2) = logb(#1);" },
-  { "monop", "exp10", "float32",
-    "(#2) = powf(10, (#1));" },
-  { "monop", "exp10", "float64",
-    "(#2) = pow(10, (#1));" },
-  { "monop", "exp10", "cmplx64",
-    "(#2) = cpow(10, (#1));" },
-  { "monop", "exp10", "cmplx128",
-    "(#2) = cpow(10, (#1));" },
-  { "monop", "sinh", "float32",
-    "(#2) = sinhf(#1);" },
-  { "monop", "sinh", "float64",
-    "(#2) = sinh(#1);" },
-  { "monop", "sinh", "cmplx64",
-    "(#2) = csinhf(#1);" },
-  { "monop", "sinh", "cmplx128",
-    "(#2) = csinh(#1);" },
-  { "monop", "cosh", "float32",
-    "(#2) = coshf(#1);" },
-  { "monop", "cosh", "float64",
-    "(#2) = cosh(#1);" },
-  { "monop", "cosh", "cmplx64",
-    "(#2) = ccoshf(#1);" },
-  { "monop", "cosh", "cmplx128",
-    "(#2) = ccosh(#1);" },
-  { "monop", "tanh", "float32",
-    "(#2) = tanhf(#1);" },
-  { "monop", "tanh", "float64",
-    "(#2) = tanh(#1);" },
-  { "monop", "tanh", "cmplx64",
-    "(#2) = ctanhf(#1);" },
-  { "monop", "tanh", "cmplx128",
-    "(#2) = ctanh(#1);" },
-  { "monop", "asinh", "float32",
-    "(#2) = asinhf(#1);" },
-  { "monop", "asinh", "float64",
-    "(#2) = asinh(#1);" },
-  { "monop", "asinh", "cmplx64",
-    "(#2) = casinhf(#1);" },
-  { "monop", "asinh", "cmplx128",
-    "(#2) = casinh(#1);" },
-  { "monop", "acosh", "float32",
-    "(#2) = acoshf(#1);" },
-  { "monop", "acosh", "float64",
-    "(#2) = acosh(#1);" },
-  { "monop", "acosh", "cmplx64",
-    "(#2) = cacoshf(#1);" },
-  { "monop", "acosh", "cmplx128",
-    "(#2) = cacosh(#1);" },
-  { "monop", "atanh", "float32",
-    "(#2) = atanhf(#1);" },
-  { "monop", "atanh", "float64",
-    "(#2) = atanh(#1);" },
-  { "monop", "atanh", "cmplx64",
-    "(#2) = catanhf(#1);" },
-  { "monop", "atanh", "cmplx128",
-    "(#2) = catanh(#1);" },
-  { "monop", "expm1", "float32",
-    "(#2) = expm1f(#1);" },
-  { "monop", "expm1", "float64",
-    "(#2) = expm1(#1);" },
-  { "monop", "log1p", "float32",
-    "(#2) = log1pf(#1);" },
-  { "monop", "log1p", "float64",
-    "(#2) = log1p(#1);" },
-  { "monop", "rsqrt", "float32",
-    "(#2) = ((float)1.0) / sqrtf(#1);" },
-  { "monop", "rsqrt", "float64",
-    "(#2) = ((double)1.0) / sqrt(#1);" },
-  { "monop", "rsqrt", "cmplx64",
-    "(#2) = ((float)1.0) / csqrtf(#1);" },
-  { "monop", "rsqrt", "cmplx128",
-    "(#2) = ((double)1.0) / csqrt(#1);" },
-  { "monop", "trunc", "int8",
-    "(#2) = (#1);" },
-  { "monop", "trunc", "uint8",
-    "(#2) = (#1);" },
-  { "monop", "trunc", "int16",
-    "(#2) = (#1);" },
-  { "monop", "trunc", "uint16",
-    "(#2) = (#1);" },
-  { "monop", "trunc", "int32",
-    "(#2) = (#1);" },
-  { "monop", "trunc", "uint32",
-    "(#2) = (#1);" },
-  { "monop", "trunc", "int64",
-    "(#2) = (#1);" },
-  { "monop", "trunc", "uint64",
-    "(#2) = (#1);" },
-  { "monop", "trunc", "float32",
-    "(#2) = trunc(#1);" },
-  { "monop", "trunc", "float64",
-    "(#2) = trunc(#1);" },
-  { "monop", "square", "int8",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "square", "uint8",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "square", "int16",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "square", "uint16",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "square", "int32",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "square", "uint32",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "square", "int64",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "square", "uint64",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "square", "float32",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "square", "float64",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "square", "cmplx64",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "square", "cmplx128",
-    "(#2) = (#1) * (#1);" },
-  { "monop", "deg_360", "float32",
-    "{\n  double _a = (double)(#1);\n  double _fa = _a / 360.0;\n  (#2) = (_a >= 0)\n           ? (_fa - floor(_fa)) * 360.0\n           : (_fa - ceil(_fa) + 1.0) * 360.0;\n}\n" },
-  { "monop", "deg_360", "float64",
-    "{\n  double _a = (double)(#1);\n  double _fa = _a / 360.0;\n  (#2) = (_a >= 0)\n           ? (_fa - floor(_fa)) * 360.0\n           : (_fa - ceil(_fa) + 1.0) * 360.0;\n}\n" },
-  { "monop", "deg_180", "float32",
-    "{\n  double _a = (double)(#1);\n  double _fa = (_a + 180.0) / 360.0;\n  double _b = (_a >= 0)\n                ? (_fa - floor(_fa)) * 360.0 - 180.0\n                : (_fa - ceil(_fa))  * 360.0 - 180.0;\n  if (_b <= -180.0) _b += 360.0;\n  (#2) = _b;\n}\n" },
-  { "monop", "deg_180", "float64",
-    "{\n  double _a = (double)(#1);\n  double _fa = (_a + 180.0) / 360.0;\n  double _b = (_a >= 0)\n                ? (_fa - floor(_fa)) * 360.0 - 180.0\n                : (_fa - ceil(_fa))  * 360.0 - 180.0;\n  if (_b <= -180.0) _b += 360.0;\n  (#2) = _b;\n}\n" },
-  { "monop", "rad_2pi", "float32",
-    "{\n  double _two_pi = 2.0 * M_PI;\n  double _a = (double)(#1);\n  double _fa = _a / _two_pi;\n  (#2) = (_a >= 0)\n           ? (_fa - floor(_fa)) * _two_pi\n           : (_fa - ceil(_fa) + 1.0) * _two_pi;\n}\n" },
-  { "monop", "rad_2pi", "float64",
-    "{\n  double _two_pi = 2.0 * M_PI;\n  double _a = (double)(#1);\n  double _fa = _a / _two_pi;\n  (#2) = (_a >= 0)\n           ? (_fa - floor(_fa)) * _two_pi\n           : (_fa - ceil(_fa) + 1.0) * _two_pi;\n}\n" },
-  { "monop", "rad_pi", "float32",
-    "{\n  double _two_pi = 2.0 * M_PI;\n  double _a = (double)(#1);\n  double _fa = (_a + M_PI) / _two_pi;\n  double _b = (_a >= 0)\n                ? (_fa - floor(_fa)) * _two_pi - M_PI\n                : (_fa - ceil(_fa))  * _two_pi - M_PI;\n  if (_b <= -M_PI) _b += _two_pi;\n  (#2) = _b;\n}\n" },
-  { "monop", "rad_pi", "float64",
-    "{\n  double _two_pi = 2.0 * M_PI;\n  double _a = (double)(#1);\n  double _fa = (_a + M_PI) / _two_pi;\n  double _b = (_a >= 0)\n                ? (_fa - floor(_fa)) * _two_pi - M_PI\n                : (_fa - ceil(_fa))  * _two_pi - M_PI;\n  if (_b <= -M_PI) _b += _two_pi;\n  (#2) = _b;\n}\n" },
-  { "binop", "pmax", "int8",
-    "(#3) = (#1) > (#2) ? (#1) : (#2);" },
-  { "binop", "pmax", "uint8",
-    "(#3) = (#1) > (#2) ? (#1) : (#2);" },
-  { "binop", "pmax", "int16",
-    "(#3) = (#1) > (#2) ? (#1) : (#2);" },
-  { "binop", "pmax", "uint16",
-    "(#3) = (#1) > (#2) ? (#1) : (#2);" },
-  { "binop", "pmax", "int32",
-    "(#3) = (#1) > (#2) ? (#1) : (#2);" },
-  { "binop", "pmax", "uint32",
-    "(#3) = (#1) > (#2) ? (#1) : (#2);" },
-  { "binop", "pmax", "int64",
-    "(#3) = (#1) > (#2) ? (#1) : (#2);" },
-  { "binop", "pmax", "uint64",
-    "(#3) = (#1) > (#2) ? (#1) : (#2);" },
-  { "binop", "pmax", "float32",
-    "(#3) = fmax(#1, #2);" },
-  { "binop", "pmax", "float64",
-    "(#3) = fmax(#1, #2);" },
-  { "binop", "pmin", "int8",
-    "(#3) = (#1) < (#2) ? (#1) : (#2);" },
-  { "binop", "pmin", "uint8",
-    "(#3) = (#1) < (#2) ? (#1) : (#2);" },
-  { "binop", "pmin", "int16",
-    "(#3) = (#1) < (#2) ? (#1) : (#2);" },
-  { "binop", "pmin", "uint16",
-    "(#3) = (#1) < (#2) ? (#1) : (#2);" },
-  { "binop", "pmin", "int32",
-    "(#3) = (#1) < (#2) ? (#1) : (#2);" },
-  { "binop", "pmin", "uint32",
-    "(#3) = (#1) < (#2) ? (#1) : (#2);" },
-  { "binop", "pmin", "int64",
-    "(#3) = (#1) < (#2) ? (#1) : (#2);" },
-  { "binop", "pmin", "uint64",
-    "(#3) = (#1) < (#2) ? (#1) : (#2);" },
-  { "binop", "pmin", "float32",
-    "(#3) = fmin(#1, #2);" },
-  { "binop", "pmin", "float64",
-    "(#3) = fmin(#1, #2);" },
-  { "binop", "maximum", "int8",
-    "(#3) = (#1) > (#2) ? (#1) : (#2);" },
-  { "binop", "maximum", "uint8",
-    "(#3) = (#1) > (#2) ? (#1) : (#2);" },
-  { "binop", "maximum", "int16",
-    "(#3) = (#1) > (#2) ? (#1) : (#2);" },
-  { "binop", "maximum", "uint16",
-    "(#3) = (#1) > (#2) ? (#1) : (#2);" },
-  { "binop", "maximum", "int32",
-    "(#3) = (#1) > (#2) ? (#1) : (#2);" },
-  { "binop", "maximum", "uint32",
-    "(#3) = (#1) > (#2) ? (#1) : (#2);" },
-  { "binop", "maximum", "int64",
-    "(#3) = (#1) > (#2) ? (#1) : (#2);" },
-  { "binop", "maximum", "uint64",
-    "(#3) = (#1) > (#2) ? (#1) : (#2);" },
-  { "binop", "maximum", "float32",
-    "(#3) = isnan(#1) ? (#1) : (isnan(#2) ? (#2) : ((#1) > (#2) ? (#1) : (#2)));" },
-  { "binop", "maximum", "float64",
-    "(#3) = isnan(#1) ? (#1) : (isnan(#2) ? (#2) : ((#1) > (#2) ? (#1) : (#2)));" },
-  { "binop", "minimum", "int8",
-    "(#3) = (#1) < (#2) ? (#1) : (#2);" },
-  { "binop", "minimum", "uint8",
-    "(#3) = (#1) < (#2) ? (#1) : (#2);" },
-  { "binop", "minimum", "int16",
-    "(#3) = (#1) < (#2) ? (#1) : (#2);" },
-  { "binop", "minimum", "uint16",
-    "(#3) = (#1) < (#2) ? (#1) : (#2);" },
-  { "binop", "minimum", "int32",
-    "(#3) = (#1) < (#2) ? (#1) : (#2);" },
-  { "binop", "minimum", "uint32",
-    "(#3) = (#1) < (#2) ? (#1) : (#2);" },
-  { "binop", "minimum", "int64",
-    "(#3) = (#1) < (#2) ? (#1) : (#2);" },
-  { "binop", "minimum", "uint64",
-    "(#3) = (#1) < (#2) ? (#1) : (#2);" },
-  { "binop", "minimum", "float32",
-    "(#3) = isnan(#1) ? (#1) : (isnan(#2) ? (#2) : ((#1) < (#2) ? (#1) : (#2)));" },
-  { "binop", "minimum", "float64",
-    "(#3) = isnan(#1) ? (#1) : (isnan(#2) ? (#2) : ((#1) < (#2) ? (#1) : (#2)));" },
-  { "binop", "add", "int8",
-    "(#3) = (#1) + (#2);" },
-  { "binop", "add", "uint8",
-    "(#3) = (#1) + (#2);" },
-  { "binop", "add", "int16",
-    "(#3) = (#1) + (#2);" },
-  { "binop", "add", "uint16",
-    "(#3) = (#1) + (#2);" },
-  { "binop", "add", "int32",
-    "(#3) = (#1) + (#2);" },
-  { "binop", "add", "uint32",
-    "(#3) = (#1) + (#2);" },
-  { "binop", "add", "int64",
-    "(#3) = (#1) + (#2);" },
-  { "binop", "add", "uint64",
-    "(#3) = (#1) + (#2);" },
-  { "binop", "add", "float32",
-    "(#3) = (#1) + (#2);" },
-  { "binop", "add", "float64",
-    "(#3) = (#1) + (#2);" },
-  { "binop", "add", "cmplx64",
-    "(#3) = (#1) + (#2);" },
-  { "binop", "add", "cmplx128",
-    "(#3) = (#1) + (#2);" },
-  { "binop", "sub", "int8",
-    "(#3) = (#1) - (#2);" },
-  { "binop", "sub", "uint8",
-    "(#3) = (#1) - (#2);" },
-  { "binop", "sub", "int16",
-    "(#3) = (#1) - (#2);" },
-  { "binop", "sub", "uint16",
-    "(#3) = (#1) - (#2);" },
-  { "binop", "sub", "int32",
-    "(#3) = (#1) - (#2);" },
-  { "binop", "sub", "uint32",
-    "(#3) = (#1) - (#2);" },
-  { "binop", "sub", "int64",
-    "(#3) = (#1) - (#2);" },
-  { "binop", "sub", "uint64",
-    "(#3) = (#1) - (#2);" },
-  { "binop", "sub", "float32",
-    "(#3) = (#1) - (#2);" },
-  { "binop", "sub", "float64",
-    "(#3) = (#1) - (#2);" },
-  { "binop", "sub", "cmplx64",
-    "(#3) = (#1) - (#2);" },
-  { "binop", "sub", "cmplx128",
-    "(#3) = (#1) - (#2);" },
-  { "binop", "mul", "int8",
-    "(#3) = (#1) * (#2);" },
-  { "binop", "mul", "uint8",
-    "(#3) = (#1) * (#2);" },
-  { "binop", "mul", "int16",
-    "(#3) = (#1) * (#2);" },
-  { "binop", "mul", "uint16",
-    "(#3) = (#1) * (#2);" },
-  { "binop", "mul", "int32",
-    "(#3) = (#1) * (#2);" },
-  { "binop", "mul", "uint32",
-    "(#3) = (#1) * (#2);" },
-  { "binop", "mul", "int64",
-    "(#3) = (#1) * (#2);" },
-  { "binop", "mul", "uint64",
-    "(#3) = (#1) * (#2);" },
-  { "binop", "mul", "float32",
-    "(#3) = (#1) * (#2);" },
-  { "binop", "mul", "float64",
-    "(#3) = (#1) * (#2);" },
-  { "binop", "mul", "cmplx64",
-    "(#3) = op_cmul_cmplx64((#1), (#2));" },
-  { "binop", "mul", "cmplx128",
-    "(#3) = (#1) * (#2);" },
-  { "binop", "div", "int8",
-    "\n      if ((#2)==0) {ca_zerodiv();};\n      {\n        <type> _q = (#1) / (#2);\n        if ( (#1) % (#2) != 0 && (((#1) < 0) != ((#2) < 0)) ) { _q -= 1; }\n        (#3) = _q;\n      }\n    " },
-  { "binop", "div", "uint8",
-    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) / (#2);" },
-  { "binop", "div", "int16",
-    "\n      if ((#2)==0) {ca_zerodiv();};\n      {\n        <type> _q = (#1) / (#2);\n        if ( (#1) % (#2) != 0 && (((#1) < 0) != ((#2) < 0)) ) { _q -= 1; }\n        (#3) = _q;\n      }\n    " },
-  { "binop", "div", "uint16",
-    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) / (#2);" },
-  { "binop", "div", "int32",
-    "\n      if ((#2)==0) {ca_zerodiv();};\n      {\n        <type> _q = (#1) / (#2);\n        if ( (#1) % (#2) != 0 && (((#1) < 0) != ((#2) < 0)) ) { _q -= 1; }\n        (#3) = _q;\n      }\n    " },
-  { "binop", "div", "uint32",
-    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) / (#2);" },
-  { "binop", "div", "int64",
-    "\n      if ((#2)==0) {ca_zerodiv();};\n      {\n        <type> _q = (#1) / (#2);\n        if ( (#1) % (#2) != 0 && (((#1) < 0) != ((#2) < 0)) ) { _q -= 1; }\n        (#3) = _q;\n      }\n    " },
-  { "binop", "div", "uint64",
-    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) / (#2);" },
-  { "binop", "div", "float32",
-    "(#3) = (#1) / (#2);" },
-  { "binop", "div", "float64",
-    "(#3) = (#1) / (#2);" },
-  { "binop", "div", "cmplx64",
-    "(#3) = op_cdiv_cmplx64((#1), (#2));" },
-  { "binop", "div", "cmplx128",
-    "(#3) = (#1) / (#2);" },
-  { "binop", "rcp_mul", "int8",
-    "if ((#1)==0) {ca_zerodiv();}; (#3) = (#2) / (#1);" },
-  { "binop", "rcp_mul", "uint8",
-    "if ((#1)==0) {ca_zerodiv();}; (#3) = (#2) / (#1);" },
-  { "binop", "rcp_mul", "int16",
-    "if ((#1)==0) {ca_zerodiv();}; (#3) = (#2) / (#1);" },
-  { "binop", "rcp_mul", "uint16",
-    "if ((#1)==0) {ca_zerodiv();}; (#3) = (#2) / (#1);" },
-  { "binop", "rcp_mul", "int32",
-    "if ((#1)==0) {ca_zerodiv();}; (#3) = (#2) / (#1);" },
-  { "binop", "rcp_mul", "uint32",
-    "if ((#1)==0) {ca_zerodiv();}; (#3) = (#2) / (#1);" },
-  { "binop", "rcp_mul", "int64",
-    "if ((#1)==0) {ca_zerodiv();}; (#3) = (#2) / (#1);" },
-  { "binop", "rcp_mul", "uint64",
-    "if ((#1)==0) {ca_zerodiv();}; (#3) = (#2) / (#1);" },
-  { "binop", "rcp_mul", "float32",
-    "(#3) = (#2) / (#1);" },
-  { "binop", "rcp_mul", "float64",
-    "(#3) = (#2) / (#1);" },
-  { "binop", "rcp_mul", "cmplx64",
-    "(#3) = op_cdiv_cmplx64((#2), (#1));" },
-  { "binop", "rcp_mul", "cmplx128",
-    "(#3) = (#2) / (#1);" },
-  { "binop", "mod", "int8",
-    "\n      if ((#2)==0) {ca_zerodiv();};\n      {\n        <type> _r = (#1) % (#2);\n        if ( _r != 0 && ((_r < 0) != ((#2) < 0)) ) { _r += (#2); }\n        (#3) = _r;\n      }\n    " },
-  { "binop", "mod", "uint8",
-    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);" },
-  { "binop", "mod", "int16",
-    "\n      if ((#2)==0) {ca_zerodiv();};\n      {\n        <type> _r = (#1) % (#2);\n        if ( _r != 0 && ((_r < 0) != ((#2) < 0)) ) { _r += (#2); }\n        (#3) = _r;\n      }\n    " },
-  { "binop", "mod", "uint16",
-    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);" },
-  { "binop", "mod", "int32",
-    "\n      if ((#2)==0) {ca_zerodiv();};\n      {\n        <type> _r = (#1) % (#2);\n        if ( _r != 0 && ((_r < 0) != ((#2) < 0)) ) { _r += (#2); }\n        (#3) = _r;\n      }\n    " },
-  { "binop", "mod", "uint32",
-    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);" },
-  { "binop", "mod", "int64",
-    "\n      if ((#2)==0) {ca_zerodiv();};\n      {\n        <type> _r = (#1) % (#2);\n        if ( _r != 0 && ((_r < 0) != ((#2) < 0)) ) { _r += (#2); }\n        (#3) = _r;\n      }\n    " },
-  { "binop", "mod", "uint64",
-    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);" },
-  { "binop", "mod", "float32",
-    "\n      {\n        <type> _r = fmod((#1), (#2));\n        if ( _r != 0 ) {\n          if ( (_r < 0) != ((#2) < 0) ) { _r += (#2); }\n        }\n        else { _r = copysign((<type>) 0, (#2)); }\n        (#3) = _r;\n      }\n    " },
-  { "binop", "mod", "float64",
-    "\n      {\n        <type> _r = fmod((#1), (#2));\n        if ( _r != 0 ) {\n          if ( (_r < 0) != ((#2) < 0) ) { _r += (#2); }\n        }\n        else { _r = copysign((<type>) 0, (#2)); }\n        (#3) = _r;\n      }\n    " },
-  { "binop", "fmod", "int8",
-    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);" },
-  { "binop", "fmod", "uint8",
-    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);" },
-  { "binop", "fmod", "int16",
-    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);" },
-  { "binop", "fmod", "uint16",
-    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);" },
-  { "binop", "fmod", "int32",
-    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);" },
-  { "binop", "fmod", "uint32",
-    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);" },
-  { "binop", "fmod", "int64",
-    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);" },
-  { "binop", "fmod", "uint64",
-    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);" },
-  { "binop", "fmod", "float32",
-    "(#3) = fmodf((#1), (#2));" },
-  { "binop", "fmod", "float64",
-    "(#3) = fmod((#1), (#2));" },
-  { "binop", "bit_and_i", "int8",
-    "(#3) = (#1) & (#2);" },
-  { "binop", "bit_and_i", "uint8",
-    "(#3) = (#1) & (#2);" },
-  { "binop", "bit_and_i", "int16",
-    "(#3) = (#1) & (#2);" },
-  { "binop", "bit_and_i", "uint16",
-    "(#3) = (#1) & (#2);" },
-  { "binop", "bit_and_i", "int32",
-    "(#3) = (#1) & (#2);" },
-  { "binop", "bit_and_i", "uint32",
-    "(#3) = (#1) & (#2);" },
-  { "binop", "bit_and_i", "int64",
-    "(#3) = (#1) & (#2);" },
-  { "binop", "bit_and_i", "uint64",
-    "(#3) = (#1) & (#2);" },
-  { "binop", "bit_and_i", "boolean",
-    "(#3) = (#1) & (#2);" },
-  { "binop", "bit_or_i", "int8",
-    "(#3) = (#1) | (#2);" },
-  { "binop", "bit_or_i", "uint8",
-    "(#3) = (#1) | (#2);" },
-  { "binop", "bit_or_i", "int16",
-    "(#3) = (#1) | (#2);" },
-  { "binop", "bit_or_i", "uint16",
-    "(#3) = (#1) | (#2);" },
-  { "binop", "bit_or_i", "int32",
-    "(#3) = (#1) | (#2);" },
-  { "binop", "bit_or_i", "uint32",
-    "(#3) = (#1) | (#2);" },
-  { "binop", "bit_or_i", "int64",
-    "(#3) = (#1) | (#2);" },
-  { "binop", "bit_or_i", "uint64",
-    "(#3) = (#1) | (#2);" },
-  { "binop", "bit_or_i", "boolean",
-    "(#3) = (#1) | (#2);" },
-  { "binop", "bit_xor_i", "int8",
-    "(#3) = (#1) ^ (#2);" },
-  { "binop", "bit_xor_i", "uint8",
-    "(#3) = (#1) ^ (#2);" },
-  { "binop", "bit_xor_i", "int16",
-    "(#3) = (#1) ^ (#2);" },
-  { "binop", "bit_xor_i", "uint16",
-    "(#3) = (#1) ^ (#2);" },
-  { "binop", "bit_xor_i", "int32",
-    "(#3) = (#1) ^ (#2);" },
-  { "binop", "bit_xor_i", "uint32",
-    "(#3) = (#1) ^ (#2);" },
-  { "binop", "bit_xor_i", "int64",
-    "(#3) = (#1) ^ (#2);" },
-  { "binop", "bit_xor_i", "uint64",
-    "(#3) = (#1) ^ (#2);" },
-  { "binop", "bit_xor_i", "boolean",
-    "(#3) = ((#1) != (#2)) ? 1 : 0;" },
-  { "binop", "bit_lshift", "int8",
-    "(#3) = (#1) << (#2);" },
-  { "binop", "bit_lshift", "uint8",
-    "(#3) = (#1) << (#2);" },
-  { "binop", "bit_lshift", "int16",
-    "(#3) = (#1) << (#2);" },
-  { "binop", "bit_lshift", "uint16",
-    "(#3) = (#1) << (#2);" },
-  { "binop", "bit_lshift", "int32",
-    "(#3) = (#1) << (#2);" },
-  { "binop", "bit_lshift", "uint32",
-    "(#3) = (#1) << (#2);" },
-  { "binop", "bit_lshift", "int64",
-    "(#3) = (#1) << (#2);" },
-  { "binop", "bit_lshift", "uint64",
-    "(#3) = (#1) << (#2);" },
-  { "binop", "bit_rshift", "int8",
-    "(#3) = (#1) >> (#2);" },
-  { "binop", "bit_rshift", "uint8",
-    "(#3) = (#1) >> (#2);" },
-  { "binop", "bit_rshift", "int16",
-    "(#3) = (#1) >> (#2);" },
-  { "binop", "bit_rshift", "uint16",
-    "(#3) = (#1) >> (#2);" },
-  { "binop", "bit_rshift", "int32",
-    "(#3) = (#1) >> (#2);" },
-  { "binop", "bit_rshift", "uint32",
-    "(#3) = (#1) >> (#2);" },
-  { "binop", "bit_rshift", "int64",
-    "(#3) = (#1) >> (#2);" },
-  { "binop", "bit_rshift", "uint64",
-    "(#3) = (#1) >> (#2);" },
-  { "binop", "and", "boolean",
-    "(#3) = (#1) && (#2);" },
-  { "binop", "or", "boolean",
-    "(#3) = (#1) || (#2);" },
-  { "binop", "xor", "boolean",
-    "(#3) = (((#1)==0) == ((#2)==0)) ? 0 : 1;" },
-  { "triop", "fma", "int8",
-    "(#4) = (#1) * (#2) + (#3);" },
-  { "triop", "fma", "uint8",
-    "(#4) = (#1) * (#2) + (#3);" },
-  { "triop", "fma", "int16",
-    "(#4) = (#1) * (#2) + (#3);" },
-  { "triop", "fma", "uint16",
-    "(#4) = (#1) * (#2) + (#3);" },
-  { "triop", "fma", "int32",
-    "(#4) = (#1) * (#2) + (#3);" },
-  { "triop", "fma", "uint32",
-    "(#4) = (#1) * (#2) + (#3);" },
-  { "triop", "fma", "int64",
-    "(#4) = (#1) * (#2) + (#3);" },
-  { "triop", "fma", "uint64",
-    "(#4) = (#1) * (#2) + (#3);" },
-  { "triop", "fma", "float32",
-    "(#4) = fma((#1), (#2), (#3));" },
-  { "triop", "fma", "float64",
-    "(#4) = fma((#1), (#2), (#3));" },
-  { "triop", "fma", "cmplx64",
-    "(#4) = (#1) * (#2) + (#3);" },
-  { "triop", "fma", "cmplx128",
-    "(#4) = (#1) * (#2) + (#3);" },
-  { "triop", "fms", "int8",
-    "(#4) = (#1) * (#2) - (#3);" },
-  { "triop", "fms", "uint8",
-    "(#4) = (#1) * (#2) - (#3);" },
-  { "triop", "fms", "int16",
-    "(#4) = (#1) * (#2) - (#3);" },
-  { "triop", "fms", "uint16",
-    "(#4) = (#1) * (#2) - (#3);" },
-  { "triop", "fms", "int32",
-    "(#4) = (#1) * (#2) - (#3);" },
-  { "triop", "fms", "uint32",
-    "(#4) = (#1) * (#2) - (#3);" },
-  { "triop", "fms", "int64",
-    "(#4) = (#1) * (#2) - (#3);" },
-  { "triop", "fms", "uint64",
-    "(#4) = (#1) * (#2) - (#3);" },
-  { "triop", "fms", "float32",
-    "(#4) = fma((#1), (#2), -(#3));" },
-  { "triop", "fms", "float64",
-    "(#4) = fma((#1), (#2), -(#3));" },
-  { "triop", "fms", "cmplx64",
-    "(#4) = (#1) * (#2) - (#3);" },
-  { "triop", "fms", "cmplx128",
-    "(#4) = (#1) * (#2) - (#3);" },
-  { "triop", "clip", "int8",
-    "(#4) = ((#1) < (#2)) ? (#2) : (((#1) > (#3)) ? (#3) : (#1));" },
-  { "triop", "clip", "uint8",
-    "(#4) = ((#1) < (#2)) ? (#2) : (((#1) > (#3)) ? (#3) : (#1));" },
-  { "triop", "clip", "int16",
-    "(#4) = ((#1) < (#2)) ? (#2) : (((#1) > (#3)) ? (#3) : (#1));" },
-  { "triop", "clip", "uint16",
-    "(#4) = ((#1) < (#2)) ? (#2) : (((#1) > (#3)) ? (#3) : (#1));" },
-  { "triop", "clip", "int32",
-    "(#4) = ((#1) < (#2)) ? (#2) : (((#1) > (#3)) ? (#3) : (#1));" },
-  { "triop", "clip", "uint32",
-    "(#4) = ((#1) < (#2)) ? (#2) : (((#1) > (#3)) ? (#3) : (#1));" },
-  { "triop", "clip", "int64",
-    "(#4) = ((#1) < (#2)) ? (#2) : (((#1) > (#3)) ? (#3) : (#1));" },
-  { "triop", "clip", "uint64",
-    "(#4) = ((#1) < (#2)) ? (#2) : (((#1) > (#3)) ? (#3) : (#1));" },
-  { "triop", "clip", "float32",
-    "(#4) = isnan(#1) ? (#1) : fmin(fmax((#1), (#2)), (#3));" },
-  { "triop", "clip", "float64",
-    "(#4) = isnan(#1) ? (#1) : fmin(fmax((#1), (#2)), (#3));" },
-  { "binop", "power", "int8",
-    "(#3) = op_powi_<type>((#1), (#2));" },
-  { "binop", "power", "uint8",
-    "(#3) = op_powi_<type>((#1), (#2));" },
-  { "binop", "power", "int16",
-    "(#3) = op_powi_<type>((#1), (#2));" },
-  { "binop", "power", "uint16",
-    "(#3) = op_powi_<type>((#1), (#2));" },
-  { "binop", "power", "int32",
-    "(#3) = op_powi_<type>((#1), (#2));" },
-  { "binop", "power", "uint32",
-    "(#3) = op_powi_<type>((#1), (#2));" },
-  { "binop", "power", "int64",
-    "(#3) = op_powi_<type>((#1), (#2));" },
-  { "binop", "power", "uint64",
-    "(#3) = op_powi_<type>((#1), (#2));" },
-  { "binop", "power", "float32",
-    "(#3) = powf((#1), (#2));" },
-  { "binop", "power", "float64",
-    "(#3) = pow((#1), (#2));" },
-  { "binop", "power", "cmplx64",
-    "(#3) = cpow((#1), (#2));" },
-  { "binop", "power", "cmplx128",
-    "(#3) = cpow((#1), (#2));" },
-  { "binop", "copysign", "float32",
-    "(#3) = copysignf((#1), (#2));" },
-  { "binop", "copysign", "float64",
-    "(#3) = copysign((#1), (#2));" },
-  { "binop", "nextafter", "float32",
-    "(#3) = nextafterf((#1), (#2));" },
-  { "binop", "nextafter", "float64",
-    "(#3) = nextafter((#1), (#2));" },
-  { "binop", "atan2", "float32",
-    "(#3) = atan2f((#1), (#2));" },
-  { "binop", "atan2", "float64",
-    "(#3) = atan2((#1), (#2));" },
-  { "binop", "hypot", "float32",
-    "(#3) = hypotf((#1), (#2));" },
-  { "binop", "hypot", "float64",
-    "(#3) = hypot((#1), (#2));" },
-  { "binop", "logaddexp", "float32",
-    "(#3) = fmaxf((#1), (#2)) + log1pf(expf(-fabsf((#1) - (#2))));" },
-  { "binop", "logaddexp", "float64",
-    "(#3) = fmax((#1), (#2)) + log1p(exp(-fabs((#1) - (#2))));" },
-};
-static const int ca_kernel_bodies_count = 527;
-/* CArray.__kernel_body__(kind, name, data_type) -> String, or nil where
-   this operation has no body at that data type. */
-static VALUE
-rb_ca_s_kernel_body (VALUE klass, VALUE rkind, VALUE rname, VALUE rtype)
-{
-  VALUE kind = rb_obj_as_string(rkind);
-  VALUE name = rb_obj_as_string(rname);
-  VALUE type = rb_obj_as_string(rtype);
-  const char *k = StringValueCStr(kind);
-  const char *n = StringValueCStr(name);
-  const char *t = StringValueCStr(type);
-  int i;
-  for ( i = 0; i < ca_kernel_bodies_count; i++ ) {
-    const ca_kernel_body_t *e = &ca_kernel_bodies[i];
-    if ( strcmp(e->kind, k) == 0 &&
-         strcmp(e->name, n) == 0 &&
-         strcmp(e->data_type, t) == 0 ) {
-      return rb_str_new_cstr(e->body);
-    }
-  }
-  return Qnil;
-}
-void
-Init_carray_kernels (void)
-{
-  Init_carray_kernels_reduce_aggregate();
-  Init_carray_kernels_reduce_extreme();
-  Init_carray_kernels_reduce_cumulative();
-  Init_carray_kernels_reduce_boolean();
-  Init_carray_kernels_reduce_variance();
-  Init_carray_kernels_map();
-  Init_carray_kernels_scan();
-  Init_carray_kernels_sort();
-  Init_carray_kernels_search();
-  Init_carray_kernels_monop();
-  Init_carray_kernels_binop();
-  Init_carray_kernels_triop();
-  Init_carray_kernels_moncmp();
-  Init_carray_kernels_bincmp();
-  rb_define_singleton_method(rb_cCArray, "__kernel_body__",
-                             rb_ca_s_kernel_body, 3);
-}