PageRenderTime 23ms CodeModel.GetById 16ms RepoModel.GetById 0ms app.codeStats 0ms

/libsrc/veclib/vectbl.c

https://gitlab.com/oytunistrator/QuIP
C | 507 lines | 356 code | 76 blank | 75 comment | 17 complexity | 69d9ba10e5a79e9c02485074190f6328 MD5 | raw file
    

  1. 

  2. #include "quip_config.h"
    3. 

  3. 

  4. /* this table defines all of the functions.
    5. 

  5.  * It gives their name, a mask that tells the supported precisions,
    6. 

  6.  * and an entry point...
    7. 

  7.  */
    8. 

  8. 

  9. #include <stdlib.h>	/* qsort */
    10. 

  10. #include "quip_prot.h"
    11. 

  11. #include "nvf.h"
    12. 

  12. #include "rn.h"		/* set_random_seed */
    13. 

  13. 

  14. static Item_Type *vec_func_itp=NO_ITEM_TYPE;
    15. 

  15. static ITEM_INIT_PROT(Vector_Function, vec_func)
    16. 

  16. 

  17. static ITEM_INIT_FUNC(Vector_Function, vec_func)
    18. 

  18. ITEM_LIST_FUNC(Vector_Function, vec_func)
    19. 

  19. ITEM_PICK_FUNC(Vector_Function, vec_func)
    20. 

  20. 

  21. /* This used to be an initialized table,
    22. 

  22.  * but in Objective C we have to do it differently...
    23. 

  23.  *
    24. 

  24.  * This table contains information about the functions, but isn't
    25. 

  25.  * specific to a particular platform.  The elements are the name,
    26. 

  26.  * the code, a code indicating the argument types, a mask indicating
    27. 

  27.  * what precisions (and combinations) are allowed, and a mask
    28. 

  28.  * indicating what types (real/complex/quaternion/mixed/etc)
    29. 

  29.  * are allowed.
    30. 

  30.  */
    31. 

  31. 

  32. BEGIN_VFUNC_DECLS
    33. 

  33. 

  34. CREAT_VEC_FUNC( vset,		FVSET,		S_UNARY,	M_ALL,	RCQ_MASK	)
    35. 

  35. CREAT_VEC_FUNC( vmov,		FVMOV,		V_UNARY,	M_ALL,	RCQ_MASK	)
    36. 

  36. CREAT_VEC_FUNC( vadd,		FVADD,		VV_BINARY,	M_ALLMM,RCMQP_MASK	)
    37. 

  37. CREAT_VEC_FUNC( vsub,		FVSUB,		VV_BINARY,	M_ALL,	RCMQP_MASK	)
    38. 

  38. CREAT_VEC_FUNC( vmul,		FVMUL,		VV_BINARY,	M_ALL,	RCMQP_MASK	)
    39. 

  39. CREAT_VEC_FUNC( vdiv,		FVDIV,		VV_BINARY,	M_ALL,	RCMQP_MASK	)
    40. 

  40. CREAT_VEC_FUNC( vneg,		FVNEG,		V_UNARY,	M_ALL,	RCQ_MASK	)
    41. 

  41. CREAT_VEC_FUNC( vsqr,		FVSQR,		V_UNARY,	M_ALL,	RCQ_MASK	)
    42. 

  42. CREAT_VEC_FUNC( vramp1d,	FVRAMP1D,	SS_RAMP,	M_ALL,	REAL_ARG_MASK	)
    43. 

  43. CREAT_VEC_FUNC( vramp2d,	FVRAMP2D,	SSS_RAMP,	M_ALL,	REAL_ARG_MASK	)
    44. 

  44. CREAT_VEC_FUNC( vsadd,		FVSADD,		VS_BINARY,	M_ALL,	RCMQP_MASK	)
    45. 

  45. CREAT_VEC_FUNC( vssub,		FVSSUB,		VS_BINARY,	M_ALL,	RCMQP_MASK	)
    46. 

  46. CREAT_VEC_FUNC( vsmul,		FVSMUL,		VS_BINARY,	M_ALL,	RCMQP_MASK	)
    47. 

  47. CREAT_VEC_FUNC( vsdiv,		FVSDIV,		VS_BINARY,	M_ALL,	RCMQP_MASK	)
    48. 

  48. CREAT_VEC_FUNC( vsdiv2,		FVSDIV2,	VS_BINARY,	M_ALL,	RCMQP_MASK	)
    49. 

  49. CREAT_VEC_FUNC( vabs,		FVABS,		V_UNARY,	M_ALL,	REAL_ARG_MASK	)
    50. 

  50. CREAT_VEC_FUNC( vsign,		FVSIGN,		V_UNARY,	M_ALL,	REAL_ARG_MASK	)
    51. 

  51. 

  52. CREAT_VEC_FUNC( vsqrt,		FVSQRT,		V_UNARY,	M_BP,	REAL_ARG_MASK	)
    53. 

  53. CREAT_VEC_FUNC( vsin,		FVSIN,		V_UNARY,	M_BP,	REAL_ARG_MASK	)
    54. 

  54. CREAT_VEC_FUNC( vcos,		FVCOS,		V_UNARY,	M_BP,	REAL_ARG_MASK	)
    55. 

  55. CREAT_VEC_FUNC( vatan,		FVATAN,		V_UNARY,	M_BP,	REAL_ARG_MASK	)
    56. 

  56. CREAT_VEC_FUNC( vtan,		FVTAN,		V_UNARY,	M_BP,	REAL_ARG_MASK	)
    57. 

  57. CREAT_VEC_FUNC( vatan2,		FVATAN2,	VV_BINARY,	M_BP,	REAL_ARG_MASK	)
    58. 

  58. CREAT_VEC_FUNC( vsatan2,	FVSATAN2,	VS_BINARY,	M_BP,	REAL_ARG_MASK	)
    59. 

  59. CREAT_VEC_FUNC( vsatan22,	FVSATAN22,	VS_BINARY,	M_BP,	REAL_ARG_MASK	)
    60. 

  60. CREAT_VEC_FUNC( vlog,		FVLOG,		V_UNARY,	M_BP,	REAL_ARG_MASK	)
    61. 

  61. CREAT_VEC_FUNC( vlog10,		FVLOG10,	V_UNARY,	M_BP,	REAL_ARG_MASK	)
    62. 

  62. //CREAT_VEC_FUNC( vexp,		FVEXP,		V_UNARY,	M_BP,	REAL_ARG_MASK	)
    63. 

  63. CREAT_VEC_FUNC( vexp,		FVEXP,		V_UNARY,	M_BP,	RC_MASK	)
    64. 

  64. CREAT_VEC_FUNC( verf,		FVERF,		V_UNARY,	M_BP,	REAL_ARG_MASK	)
    65. 

  65. CREAT_VEC_FUNC( verfinv,	FVERFINV,	V_UNARY,	M_BP,	REAL_ARG_MASK	)
    66. 

  66. CREAT_VEC_FUNC( vpow,		FVPOW,		VV_BINARY,	M_BP,	RC_MASK	)
    67. 

  67. CREAT_VEC_FUNC( vspow,		FVSPOW,		VS_BINARY,	M_BP,	REAL_ARG_MASK	)
    68. 

  68. CREAT_VEC_FUNC( vspow2,		FVSPOW2,	VS_BINARY,	M_BP,	REAL_ARG_MASK	)
    69. 

  69. 

  70. CREAT_VEC_FUNC( vmin,		FVMIN,		VV_BINARY,	M_ALL,	REAL_ARG_MASK	)
    71. 

  71. CREAT_VEC_FUNC( vmax,		FVMAX,		VV_BINARY,	M_ALL,	REAL_ARG_MASK	)
    72. 

  72. CREAT_VEC_FUNC( vminm,		FVMINM,		VV_BINARY,	M_ALL,	REAL_ARG_MASK	)
    73. 

  73. CREAT_VEC_FUNC( vmaxm,		FVMAXM,		VV_BINARY,	M_ALL,	REAL_ARG_MASK	)
    74. 

  74. CREAT_VEC_FUNC( vsmin,		FVSMIN,		VS_BINARY,	M_ALL,	REAL_ARG_MASK	)
    75. 

  75. CREAT_VEC_FUNC( vsmax,		FVSMAX,		VS_BINARY,	M_ALL,	REAL_ARG_MASK	)
    76. 

  76. CREAT_VEC_FUNC( vsmnm,		FVSMNM,		VS_BINARY,	M_ALL,	REAL_ARG_MASK	)
    77. 

  77. CREAT_VEC_FUNC( vsmxm,		FVSMXM,		VS_BINARY,	M_ALL,	REAL_ARG_MASK	)
    78. 

  78. 

  79. CREAT_VEC_FUNC( vminv,		FVMINV,		V_PROJECTION,	M_ALL,	REAL_ARG_MASK	)
    80. 

  80. CREAT_VEC_FUNC( vmaxv,		FVMAXV,		V_PROJECTION,	M_ALL,	REAL_ARG_MASK	)
    81. 

  81. CREAT_VEC_FUNC( vmnmv,		FVMNMV,		V_PROJECTION,	M_ALL,	REAL_ARG_MASK	)
    82. 

  82. CREAT_VEC_FUNC( vmxmv,		FVMXMV,		V_PROJECTION,	M_ALL,	REAL_ARG_MASK	)
    83. 

  83. CREAT_VEC_FUNC( vmini,		FVMINI,		V_INT_PROJECTION,	M_ALL,	REAL_ARG_MASK	)
    84. 

  84. CREAT_VEC_FUNC( vmaxi,		FVMAXI,		V_INT_PROJECTION,	M_ALL,	REAL_ARG_MASK	)
    85. 

  85. CREAT_VEC_FUNC( vmnmi,		FVMNMI,		V_INT_PROJECTION,	M_ALL,	REAL_ARG_MASK	)
    86. 

  86. CREAT_VEC_FUNC( vmxmi,		FVMXMI,		V_INT_PROJECTION,	M_ALL,	REAL_ARG_MASK	)
    87. 

  87. CREAT_VEC_FUNC( vming,		FVMING,		V_SCALRET2,	M_ALL,	REAL_ARG_MASK	)
    88. 

  88. CREAT_VEC_FUNC( vmaxg,		FVMAXG,		V_SCALRET2,	M_ALL,	REAL_ARG_MASK	)
    89. 

  89. CREAT_VEC_FUNC( vmnmg,		FVMNMG,		V_SCALRET2,	M_ALL,	REAL_ARG_MASK	)
    90. 

  90. CREAT_VEC_FUNC( vmxmg,		FVMXMG,		V_SCALRET2,	M_ALL,	REAL_ARG_MASK	)
    91. 

  91. 

  92. CREAT_VEC_FUNC( vfloor,		FVFLOOR,	V_UNARY,	M_BP,	REAL_ARG_MASK	)
    93. 

  93. CREAT_VEC_FUNC( vtrunc,		FVTRUNC,	V_UNARY,	M_BP,	REAL_ARG_MASK	)
    94. 

  94. CREAT_VEC_FUNC( vround,		FVROUND,	V_UNARY,	M_BP,	REAL_ARG_MASK	)
    95. 

  95. CREAT_VEC_FUNC( vceil,		FVCEIL,		V_UNARY,	M_BP,	REAL_ARG_MASK	)
    96. 

  96. CREAT_VEC_FUNC( vrint,		FVRINT,		V_UNARY,	M_BP,	REAL_ARG_MASK	)
    97. 

  97. CREAT_CPU_VEC_FUNC( vj0,		FVJ0,		V_UNARY,	M_BP,	REAL_ARG_MASK	)
    98. 

  98. CREAT_CPU_VEC_FUNC( vj1,		FVJ1,		V_UNARY,	M_BP,	REAL_ARG_MASK	)
    99. 

  99. CREAT_VEC_FUNC( vacos,		FVACOS,		V_UNARY,	M_BP,	REAL_ARG_MASK	)
    100. 

  100. CREAT_VEC_FUNC( vasin,		FVASIN,		V_UNARY,	M_BP,	REAL_ARG_MASK	)
    101. 

  101. CREAT_VEC_FUNC( vatn2,		FVATN2,		V_UNARY_C,	M_BP,	RC_MASK	)
    102. 

  102. CREAT_VEC_FUNC( vuni,		FVUNI,		V_NO_ARGS,	M_BP,	REAL_ARG_MASK	)
    103. 

  103. 

  104. CREAT_VEC_FUNC( vand,		FVAND,		VV_BINARY,	M_AI,	REAL_ARG_MASK	)
    105. 

  105. CREAT_VEC_FUNC( vnand,		FVNAND,		VV_BINARY,	M_AI,	REAL_ARG_MASK	)
    106. 

  106. CREAT_VEC_FUNC( vor,		FVOR,		VV_BINARY,	M_AI,	REAL_ARG_MASK	)
    107. 

  107. CREAT_VEC_FUNC( vxor,		FVXOR,		VV_BINARY,	M_AI,	REAL_ARG_MASK	)
    108. 

  108. CREAT_VEC_FUNC( vnot,		FVNOT,		V_UNARY,	M_AI,	REAL_ARG_MASK	)
    109. 

  109. CREAT_VEC_FUNC( vmod,		FVMOD,		VV_BINARY,	M_AI,	REAL_ARG_MASK	)
    110. 

  110. CREAT_VEC_FUNC( vsmod,		FVSMOD,		VS_BINARY,	M_AI,	REAL_ARG_MASK	)
    111. 

  111. CREAT_VEC_FUNC( vsmod2,		FVSMOD2,	VS_BINARY,	M_AI,	REAL_ARG_MASK	)
    112. 

  112. 

  113. CREAT_VEC_FUNC( vsand,		FVSAND,		VS_BINARY,	M_AI,	REAL_ARG_MASK	)
    114. 

  114. CREAT_VEC_FUNC( vsor,		FVSOR,		VS_BINARY,	M_AI,	REAL_ARG_MASK	)
    115. 

  115. CREAT_VEC_FUNC( vsxor,		FVSXOR,		VS_BINARY,	M_AI,	REAL_ARG_MASK	)
    116. 

  116. CREAT_VEC_FUNC( vshr,		FVSHR,		VV_BINARY,	M_AI,	REAL_ARG_MASK	)
    117. 

  117. CREAT_VEC_FUNC( vsshr,		FVSSHR,		VS_BINARY,	M_AI,	REAL_ARG_MASK	)
    118. 

  118. CREAT_VEC_FUNC( vsshr2,		FVSSHR2,	VS_BINARY,	M_AI,	REAL_ARG_MASK	)
    119. 

  119. CREAT_VEC_FUNC( vshl,		FVSHL,		VV_BINARY,	M_AI,	REAL_ARG_MASK	)
    120. 

  120. CREAT_VEC_FUNC( vsshl,		FVSSHL,		VS_BINARY,	M_AI,	REAL_ARG_MASK	)
    121. 

  121. CREAT_VEC_FUNC( vsshl2,		FVSSHL2,	VS_BINARY,	M_AI,	REAL_ARG_MASK	)
    122. 

  122. 

  123. CREAT_VEC_FUNC( vconv2by,	FVCONV2BY,	V_UNARY,	M_ALL,	REAL_ARG_MASK	)
    124. 

  124. CREAT_VEC_FUNC( vconv2in,	FVCONV2IN,	V_UNARY,	M_ALL,	REAL_ARG_MASK	)
    125. 

  125. CREAT_VEC_FUNC( vconv2di,	FVCONV2DI,	V_UNARY,	M_ALL,	REAL_ARG_MASK	)
    126. 

  126. CREAT_VEC_FUNC( vconv2li,	FVCONV2LI,	V_UNARY,	M_ALL,	REAL_ARG_MASK	)
    127. 

  127. CREAT_VEC_FUNC( vconv2uby,	FVCONV2UBY,	V_UNARY,	M_ALL,	REAL_ARG_MASK	)
    128. 

  128. CREAT_VEC_FUNC( vconv2uin,	FVCONV2UIN,	V_UNARY,	M_ALL,	REAL_ARG_MASK	)
    129. 

  129. CREAT_VEC_FUNC( vconv2udi,	FVCONV2UDI,	V_UNARY,	M_ALL,	REAL_ARG_MASK	)
    130. 

  130. CREAT_VEC_FUNC( vconv2uli,	FVCONV2ULI,	V_UNARY,	M_ALL,	REAL_ARG_MASK	)
    131. 

  131. CREAT_VEC_FUNC( vconv2sp,	FVCONV2SP,	V_UNARY,	M_ALL,	REAL_ARG_MASK	)
    132. 

  132. CREAT_VEC_FUNC( vconv2dp,	FVCONV2DP,	V_UNARY,	M_ALL,	REAL_ARG_MASK	)
    133. 

  133. 

  134. #ifdef OLD_STYLE_CONVERSIONS
    135. 

  135. CREAT_VEC_FUNC( vby2in,		FVBY2IN,		V_UNARY,	0,	REAL_ARG_MASK	)
    136. 

  136. CREAT_VEC_FUNC( vby2di,		FVBY2DI,		V_UNARY,	0,	REAL_ARG_MASK	)
    137. 

  137. CREAT_VEC_FUNC( vby2sp,		FVBY2SP,		V_UNARY,	0,	REAL_ARG_MASK	)
    138. 

  138. CREAT_VEC_FUNC( vby2dp,		FVBY2DP,		V_UNARY,	0,	REAL_ARG_MASK	)
    139. 

  139. CREAT_VEC_FUNC( vin2by,		FVIN2BY,		V_UNARY,	0,	REAL_ARG_MASK	)
    140. 

  140. CREAT_VEC_FUNC( vin2di,		FVIN2DI,		V_UNARY,	0,	REAL_ARG_MASK	)
    141. 

  141. CREAT_VEC_FUNC( vin2sp,		FVIN2SP,		V_UNARY,	0,	REAL_ARG_MASK	)
    142. 

  142. CREAT_VEC_FUNC( vin2dp,		FVIN2DP,		V_UNARY,	0,	REAL_ARG_MASK	)
    143. 

  143. CREAT_VEC_FUNC( vdi2by,		FVDI2BY,		V_UNARY,	0,	REAL_ARG_MASK	)
    144. 

  144. CREAT_VEC_FUNC( vdi2in,		FVDI2IN,		V_UNARY,	0,	REAL_ARG_MASK	)
    145. 

  145. CREAT_VEC_FUNC( vdi2sp,		FVDI2SP,		V_UNARY,	0,	REAL_ARG_MASK	)
    146. 

  146. CREAT_VEC_FUNC( vdi2dp,		FVDI2DP,		V_UNARY,	0,	REAL_ARG_MASK	)
    147. 

  147. CREAT_VEC_FUNC( vsp2by,		FVSP2BY,		V_UNARY,	0,	REAL_ARG_MASK	)
    148. 

  148. CREAT_VEC_FUNC( vsp2in,		FVSP2IN,		V_UNARY,	0,	REAL_ARG_MASK	)
    149. 

  149. CREAT_VEC_FUNC( vsp2di,		FVSP2DI,		V_UNARY,	0,	REAL_ARG_MASK	)
    150. 

  150. CREAT_VEC_FUNC( vsp2dp,		FVSPDP,		V_UNARY,	0,	RCQ_MASK	)
    151. 

  151. CREAT_VEC_FUNC( vdp2by,		FVDP2BY,		V_UNARY,	0,	REAL_ARG_MASK	)
    152. 

  152. CREAT_VEC_FUNC( vdp2in,		FVDP2IN,		V_UNARY,	0,	REAL_ARG_MASK	)
    153. 

  153. CREAT_VEC_FUNC( vdp2sp,		FVDPSP,		V_UNARY,	0,	RCQ_MASK	)
    154. 

  154. CREAT_VEC_FUNC( vdp2di,		FVDP2DI,		V_UNARY,	0,	REAL_ARG_MASK	)
    155. 

  155. 

  156. // unsigned conversions
    157. 

  157. CREAT_VEC_FUNC( vuby2by,	FVUBY2BY,		V_UNARY,	0,	REAL_ARG_MASK	)
    158. 

  158. CREAT_VEC_FUNC( vuby2in,	FVUBY2IN,		V_UNARY,	0,	REAL_ARG_MASK	)
    159. 

  159. CREAT_VEC_FUNC( vuby2di,	FVUBY2DI,		V_UNARY,	0,	REAL_ARG_MASK	)
    160. 

  160. CREAT_VEC_FUNC( vuby2sp,	FVUBY2SP,	V_UNARY,	0,	REAL_ARG_MASK	)
    161. 

  161. CREAT_VEC_FUNC( vuby2dp,	FVUBY2DP,	V_UNARY,	0,	REAL_ARG_MASK	)
    162. 

  162. CREAT_VEC_FUNC( vuby2uin,	FVUBY2UIN,	V_UNARY,	0,	REAL_ARG_MASK	)
    163. 

  163. CREAT_VEC_FUNC( vuby2udi,	FVUBY2UDI,	V_UNARY,	0,	REAL_ARG_MASK	)
    164. 

  164. CREAT_VEC_FUNC( vuin2by,	FVUIN2BY,		V_UNARY,	0,	REAL_ARG_MASK	)
    165. 

  165. CREAT_VEC_FUNC( vuin2in,	FVUIN2IN,		V_UNARY,	0,	REAL_ARG_MASK	)
    166. 

  166. CREAT_VEC_FUNC( vuin2di,	FVUIN2DI,		V_UNARY,	0,	REAL_ARG_MASK	)
    167. 

  167. CREAT_VEC_FUNC( vuin2sp,	FVUIN2SP,	V_UNARY,	0,	REAL_ARG_MASK	)
    168. 

  168. CREAT_VEC_FUNC( vuin2dp,	FVUIN2DP,	V_UNARY,	0,	REAL_ARG_MASK	)
    169. 

  169. CREAT_VEC_FUNC( vuin2uby,	FVUIN2UBY,	V_UNARY,	0,	REAL_ARG_MASK	)
    170. 

  170. CREAT_VEC_FUNC( vuin2udi,	FVUIN2UDI,	V_UNARY,	0,	REAL_ARG_MASK	)
    171. 

  171. CREAT_VEC_FUNC( vudi2by,	FVUDI2BY,		V_UNARY,	0,	REAL_ARG_MASK	)
    172. 

  172. CREAT_VEC_FUNC( vudi2in,	FVUDI2IN,		V_UNARY,	0,	REAL_ARG_MASK	)
    173. 

  173. CREAT_VEC_FUNC( vudi2di,	FVUDI2DI,		V_UNARY,	0,	REAL_ARG_MASK	)
    174. 

  174. CREAT_VEC_FUNC( vudi2sp,	FVUDI2SP,	V_UNARY,	0,	REAL_ARG_MASK	)
    175. 

  175. CREAT_VEC_FUNC( vudi2dp,	FVUDI2DP,	V_UNARY,	0,	REAL_ARG_MASK	)
    176. 

  176. CREAT_VEC_FUNC( vudi2uby,	FVUDI2UBY,	V_UNARY,	0,	REAL_ARG_MASK	)
    177. 

  177. CREAT_VEC_FUNC( vudi2uin,	FVUDI2UIN,	V_UNARY,	0,	REAL_ARG_MASK	)
    178. 

  178. CREAT_VEC_FUNC( vby2uby,	FVBY2UBY,		V_UNARY,	0,	REAL_ARG_MASK	)
    179. 

  179. CREAT_VEC_FUNC( vin2uby,	FVIN2UBY,		V_UNARY,	0,	REAL_ARG_MASK	)
    180. 

  180. CREAT_VEC_FUNC( vdi2uby,	FVDI2UBY,		V_UNARY,	0,	REAL_ARG_MASK	)
    181. 

  181. CREAT_VEC_FUNC( vsp2uby,	FVSP2UBY,	V_UNARY,	0,	REAL_ARG_MASK	)
    182. 

  182. CREAT_VEC_FUNC( vdp2uby,	FVDP2UBY,	V_UNARY,	0,	REAL_ARG_MASK	)
    183. 

  183. CREAT_VEC_FUNC( vby2uin,	FVBY2UIN,		V_UNARY,	0,	REAL_ARG_MASK	)
    184. 

  184. CREAT_VEC_FUNC( vin2uin,	FVIN2UIN,		V_UNARY,	0,	REAL_ARG_MASK	)
    185. 

  185. CREAT_VEC_FUNC( vdi2uin,	FVDI2UIN,		V_UNARY,	0,	REAL_ARG_MASK	)
    186. 

  186. CREAT_VEC_FUNC( vsp2uin,	FVSP2UIN,	V_UNARY,	0,	REAL_ARG_MASK	)
    187. 

  187. CREAT_VEC_FUNC( vdp2uin,	FVDP2UIN,	V_UNARY,	0,	REAL_ARG_MASK	)
    188. 

  188. CREAT_VEC_FUNC( vby2udi,	FVBY2UDI,		V_UNARY,	0,	REAL_ARG_MASK	)
    189. 

  189. CREAT_VEC_FUNC( vin2udi,	FVIN2UDI,		V_UNARY,	0,	REAL_ARG_MASK	)
    190. 

  190. CREAT_VEC_FUNC( vdi2udi,	FVDI2UDI,		V_UNARY,	0,	REAL_ARG_MASK	)
    191. 

  191. CREAT_VEC_FUNC( vsp2udi,	FVSP2UDI,	V_UNARY,	0,	REAL_ARG_MASK	)
    192. 

  192. CREAT_VEC_FUNC( vdp2udi,	FVDP2UDI,	V_UNARY,	0,	REAL_ARG_MASK	)
    193. 

  193. // long long conversions
    194. 

  194. CREAT_VEC_FUNC( vby2li,		FVBY2LI,		V_UNARY,	0,	REAL_ARG_MASK	)
    195. 

  195. CREAT_VEC_FUNC( vin2li,		FVIN2LI,		V_UNARY,	0,	REAL_ARG_MASK	)
    196. 

  196. CREAT_VEC_FUNC( vdi2li,		FVDI2LI,		V_UNARY,	0,	REAL_ARG_MASK	)
    197. 

  197. CREAT_VEC_FUNC( vsp2li,		FVSP2LI,	V_UNARY,	0,	REAL_ARG_MASK	)
    198. 

  198. CREAT_VEC_FUNC( vdp2li,		FVDP2LI,	V_UNARY,	0,	REAL_ARG_MASK	)
    199. 

  199. CREAT_VEC_FUNC( vuby2li,	FVUBY2LI,	V_UNARY,	0,	REAL_ARG_MASK	)
    200. 

  200. CREAT_VEC_FUNC( vuin2li,	FVUIN2LI,	V_UNARY,	0,	REAL_ARG_MASK	)
    201. 

  201. CREAT_VEC_FUNC( vudi2li,	FVUDI2LI,	V_UNARY,	0,	REAL_ARG_MASK	)
    202. 

  202. CREAT_VEC_FUNC( vuli2li,	FVULI2LI,	V_UNARY,	0,	REAL_ARG_MASK	)
    203. 

  203. 

  204. CREAT_VEC_FUNC( vby2uli,	FVBY2ULI,	V_UNARY,	0,	REAL_ARG_MASK	)
    205. 

  205. CREAT_VEC_FUNC( vin2uli,	FVIN2ULI,	V_UNARY,	0,	REAL_ARG_MASK	)
    206. 

  206. CREAT_VEC_FUNC( vdi2uli,	FVDI2ULI,	V_UNARY,	0,	REAL_ARG_MASK	)
    207. 

  207. CREAT_VEC_FUNC( vli2uli,	FVLI2ULI,	V_UNARY,	0,	REAL_ARG_MASK	)
    208. 

  208. CREAT_VEC_FUNC( vsp2uli,	FVSP2ULI,	V_UNARY,	0,	REAL_ARG_MASK	)
    209. 

  209. CREAT_VEC_FUNC( vdp2uli,	FVDP2ULI,	V_UNARY,	0,	REAL_ARG_MASK	)
    210. 

  210. CREAT_VEC_FUNC( vuby2uli,	FVUBY2ULI,	V_UNARY,	0,	REAL_ARG_MASK	)
    211. 

  211. CREAT_VEC_FUNC( vuin2uli,	FVUIN2ULI,	V_UNARY,	0,	REAL_ARG_MASK	)
    212. 

  212. CREAT_VEC_FUNC( vudi2uli,	FVUDI2ULI,	V_UNARY,	0,	REAL_ARG_MASK	)
    213. 

  213. 

  214. CREAT_VEC_FUNC( vli2by,		FVLI2BY,		V_UNARY,	0,	REAL_ARG_MASK	)
    215. 

  215. CREAT_VEC_FUNC( vli2in,		FVLI2IN,		V_UNARY,	0,	REAL_ARG_MASK	)
    216. 

  216. CREAT_VEC_FUNC( vli2di,		FVLI2DI,		V_UNARY,	0,	REAL_ARG_MASK	)
    217. 

  217. CREAT_VEC_FUNC( vli2sp,		FVLI2SP,	V_UNARY,	0,	REAL_ARG_MASK	)
    218. 

  218. CREAT_VEC_FUNC( vli2dp,		FVLI2DP,	V_UNARY,	0,	REAL_ARG_MASK	)
    219. 

  219. CREAT_VEC_FUNC( vli2uby,	FVLI2UBY,	V_UNARY,	0,	REAL_ARG_MASK	)
    220. 

  220. CREAT_VEC_FUNC( vli2uin,	FVLI2UIN,	V_UNARY,	0,	REAL_ARG_MASK	)
    221. 

  221. CREAT_VEC_FUNC( vli2udi,	FVLI2UDI,	V_UNARY,	0,	REAL_ARG_MASK	)
    222. 

  222. 

  223. CREAT_VEC_FUNC( vuli2by,	FVULI2BY,	V_UNARY,	0,	REAL_ARG_MASK	)
    224. 

  224. CREAT_VEC_FUNC( vuli2in,	FVULI2IN,	V_UNARY,	0,	REAL_ARG_MASK	)
    225. 

  225. CREAT_VEC_FUNC( vuli2di,	FVULI2DI,	V_UNARY,	0,	REAL_ARG_MASK	)
    226. 

  226. CREAT_VEC_FUNC( vuli2sp,	FVULI2SP,	V_UNARY,	0,	REAL_ARG_MASK	)
    227. 

  227. CREAT_VEC_FUNC( vuli2dp,	FVULI2DP,	V_UNARY,	0,	REAL_ARG_MASK	)
    228. 

  228. CREAT_VEC_FUNC( vuli2uby,	FVULI2UBY,	V_UNARY,	0,	REAL_ARG_MASK	)
    229. 

  229. CREAT_VEC_FUNC( vuli2uin,	FVULI2UIN,	V_UNARY,	0,	REAL_ARG_MASK	)
    230. 

  230. CREAT_VEC_FUNC( vuli2udi,	FVULI2UDI,	V_UNARY,	0,	REAL_ARG_MASK	)
    231. 

  231. #endif // OLD_STYLE_CONVERSIONS
    232. 

  232. 

  233. 

  234. 

  235. /* max mag,	min max changed to M_ALL to allow long destination... */
    236. 

  236. CREAT_VEC_FUNC( vsum,		FVSUM,		V_PROJECTION,	M_ALL,	RCQ_MASK	)
    237. 

  237. CREAT_VEC_FUNC( vdot,		FVDOT,		V_PROJECTION2,	M_ALL,	RC_MASK	)
    238. 

  238. CREAT_CPU_VEC_FUNC( vrand,		FVRAND,		V_UNARY,	M_ALL,	RC_MASK	)
    239. 

  239. 

  240. CREAT_VEC_FUNC( vsm_lt,		FVSMLT,		VS_TEST,	M_ALL,	REAL_ARG_MASK	)
    241. 

  241. CREAT_VEC_FUNC( vsm_gt,		FVSMGT,		VS_TEST,	M_ALL,	REAL_ARG_MASK	)
    242. 

  242. CREAT_VEC_FUNC( vsm_le,		FVSMLE,		VS_TEST,	M_ALL,	REAL_ARG_MASK	)
    243. 

  243. CREAT_VEC_FUNC( vsm_ge,		FVSMGE,		VS_TEST,	M_ALL,	REAL_ARG_MASK	)
    244. 

  244. CREAT_VEC_FUNC( vsm_ne,		FVSMNE,		VS_TEST,	M_ALL,	REAL_ARG_MASK	)
    245. 

  245. CREAT_VEC_FUNC( vsm_eq,		FVSMEQ,		VS_TEST,	M_ALL,	REAL_ARG_MASK	)
    246. 

  246. CREAT_VEC_FUNC( vvm_lt,		FVVMLT,		VV_TEST,	M_ALL,	REAL_ARG_MASK	)
    247. 

  247. CREAT_VEC_FUNC( vvm_gt,		FVVMGT,		VV_TEST,	M_ALL,	REAL_ARG_MASK	)
    248. 

  248. CREAT_VEC_FUNC( vvm_le,		FVVMLE,		VV_TEST,	M_ALL,	REAL_ARG_MASK	)
    249. 

  249. CREAT_VEC_FUNC( vvm_ge,		FVVMGE,		VV_TEST,	M_ALL,	REAL_ARG_MASK	)
    250. 

  250. CREAT_VEC_FUNC( vvm_ne,		FVVMNE,		VV_TEST,	M_ALL,	REAL_ARG_MASK	)
    251. 

  251. CREAT_VEC_FUNC( vvm_eq,		FVVMEQ,		VV_TEST,	M_ALL,	REAL_ARG_MASK	)
    252. 

  252. 

  253. CREAT_VEC_FUNC( vvv_slct,	FVVVSLCT,	VV_SELECT,	M_ALL,	REAL_ARG_MASK	)
    254. 

  254. CREAT_VEC_FUNC( vvs_slct,	FVVSSLCT,	VS_SELECT,	M_ALL,	REAL_ARG_MASK	)
    255. 

  255. CREAT_VEC_FUNC( vss_slct,	FVSSSLCT,	SS_SELECT,	M_ALL,	REAL_ARG_MASK	)
    256. 

  256. 

  257. /* New conditionals */
    258. 

  258. CREAT_VEC_FUNC( vv_vv_lt,	FVV_VV_LT,	VVVVCA,		M_ALL,	REAL_ARG_MASK	)
    259. 

  259. CREAT_VEC_FUNC( vv_vv_gt,	FVV_VV_GT,	VVVVCA,		M_ALL,	REAL_ARG_MASK	)
    260. 

  260. CREAT_VEC_FUNC( vv_vv_le,	FVV_VV_LE,	VVVVCA,		M_ALL,	REAL_ARG_MASK	)
    261. 

  261. CREAT_VEC_FUNC( vv_vv_ge,	FVV_VV_GE,	VVVVCA,		M_ALL,	REAL_ARG_MASK	)
    262. 

  262. CREAT_VEC_FUNC( vv_vv_eq,	FVV_VV_EQ,	VVVVCA,		M_ALL,	REAL_ARG_MASK	)
    263. 

  263. CREAT_VEC_FUNC( vv_vv_ne,	FVV_VV_NE,	VVVVCA,		M_ALL,	REAL_ARG_MASK	)
    264. 

  264. 

  265. CREAT_VEC_FUNC( vv_vs_lt,	FVV_VS_LT,	VVVSCA,		M_ALL,	REAL_ARG_MASK	)
    266. 

  266. CREAT_VEC_FUNC( vv_vs_gt,	FVV_VS_GT,	VVVSCA,		M_ALL,	REAL_ARG_MASK	)
    267. 

  267. CREAT_VEC_FUNC( vv_vs_le,	FVV_VS_LE,	VVVSCA,		M_ALL,	REAL_ARG_MASK	)
    268. 

  268. CREAT_VEC_FUNC( vv_vs_ge,	FVV_VS_GE,	VVVSCA,		M_ALL,	REAL_ARG_MASK	)
    269. 

  269. CREAT_VEC_FUNC( vv_vs_eq,	FVV_VS_EQ,	VVVSCA,		M_ALL,	REAL_ARG_MASK	)
    270. 

  270. CREAT_VEC_FUNC( vv_vs_ne,	FVV_VS_NE,	VVVSCA,		M_ALL,	REAL_ARG_MASK	)
    271. 

  271. 

  272. CREAT_VEC_FUNC( vs_vv_lt,	FVS_VV_LT,	VSVVCA,		M_ALL,	REAL_ARG_MASK	)
    273. 

  273. CREAT_VEC_FUNC( vs_vv_gt,	FVS_VV_GT,	VSVVCA,		M_ALL,	REAL_ARG_MASK	)
    274. 

  274. CREAT_VEC_FUNC( vs_vv_le,	FVS_VV_LE,	VSVVCA,		M_ALL,	REAL_ARG_MASK	)
    275. 

  275. CREAT_VEC_FUNC( vs_vv_ge,	FVS_VV_GE,	VSVVCA,		M_ALL,	REAL_ARG_MASK	)
    276. 

  276. CREAT_VEC_FUNC( vs_vv_eq,	FVS_VV_EQ,	VSVVCA,		M_ALL,	REAL_ARG_MASK	)
    277. 

  277. CREAT_VEC_FUNC( vs_vv_ne,	FVS_VV_NE,	VSVVCA,		M_ALL,	REAL_ARG_MASK	)
    278. 

  278. 

  279. CREAT_VEC_FUNC( vs_vs_lt,	FVS_VS_LT,	VSVSCA,		M_ALL,	REAL_ARG_MASK	)
    280. 

  280. CREAT_VEC_FUNC( vs_vs_gt,	FVS_VS_GT,	VSVSCA,		M_ALL,	REAL_ARG_MASK	)
    281. 

  281. CREAT_VEC_FUNC( vs_vs_le,	FVS_VS_LE,	VSVSCA,		M_ALL,	REAL_ARG_MASK	)
    282. 

  282. CREAT_VEC_FUNC( vs_vs_ge,	FVS_VS_GE,	VSVSCA,		M_ALL,	REAL_ARG_MASK	)
    283. 

  283. CREAT_VEC_FUNC( vs_vs_eq,	FVS_VS_EQ,	VSVSCA,		M_ALL,	REAL_ARG_MASK	)
    284. 

  284. CREAT_VEC_FUNC( vs_vs_ne,	FVS_VS_NE,	VSVSCA,		M_ALL,	REAL_ARG_MASK	)
    285. 

  285. 

  286. CREAT_VEC_FUNC( ss_vv_lt,	FSS_VV_LT,	SSVVCA,		M_ALL,	REAL_ARG_MASK	)
    287. 

  287. CREAT_VEC_FUNC( ss_vv_gt,	FSS_VV_GT,	SSVVCA,		M_ALL,	REAL_ARG_MASK	)
    288. 

  288. CREAT_VEC_FUNC( ss_vv_le,	FSS_VV_LE,	SSVVCA,		M_ALL,	REAL_ARG_MASK	)
    289. 

  289. CREAT_VEC_FUNC( ss_vv_ge,	FSS_VV_GE,	SSVVCA,		M_ALL,	REAL_ARG_MASK	)
    290. 

  290. CREAT_VEC_FUNC( ss_vv_eq,	FSS_VV_EQ,	SSVVCA,		M_ALL,	REAL_ARG_MASK	)
    291. 

  291. CREAT_VEC_FUNC( ss_vv_ne,	FSS_VV_NE,	SSVVCA,		M_ALL,	REAL_ARG_MASK	)
    292. 

  292. 

  293. CREAT_VEC_FUNC( ss_vs_lt,	FSS_VS_LT,	SSVSCA,		M_ALL,	REAL_ARG_MASK	)
    294. 

  294. CREAT_VEC_FUNC( ss_vs_gt,	FSS_VS_GT,	SSVSCA,		M_ALL,	REAL_ARG_MASK	)
    295. 

  295. CREAT_VEC_FUNC( ss_vs_le,	FSS_VS_LE,	SSVSCA,		M_ALL,	REAL_ARG_MASK	)
    296. 

  296. CREAT_VEC_FUNC( ss_vs_ge,	FSS_VS_GE,	SSVSCA,		M_ALL,	REAL_ARG_MASK	)
    297. 

  297. CREAT_VEC_FUNC( ss_vs_eq,	FSS_VS_EQ,	SSVSCA,		M_ALL,	REAL_ARG_MASK	)
    298. 

  298. CREAT_VEC_FUNC( ss_vs_ne,	FSS_VS_NE,	SSVSCA,		M_ALL,	REAL_ARG_MASK	)
    299. 

  299. 

  300. CREAT_CPU_VEC_FUNC( visnan,		FVISNAN,	V_UNARY,	M_BP,	REAL_ARG_MASK	)
    301. 

  301. CREAT_CPU_VEC_FUNC( visinf,		FVISINF,	V_UNARY,	M_BP,	REAL_ARG_MASK	)
    302. 

  302. CREAT_CPU_VEC_FUNC( visnorm,	FVISNORM,	V_UNARY,	M_BP,	REAL_ARG_MASK	)
    303. 

  303. 

  304. CREAT_VEC_FUNC( vmgsq,		FVMGSQ,		V_UNARY_C,	M_ALL,	CPX_ARG_MASK	)
    305. 

  305. CREAT_VEC_FUNC( vcmul,		FVCMUL,		VV_BINARY,	M_ALL,	CPX_ARG_MASK	)
    306. 

  306. CREAT_VEC_FUNC( vscml,		FVSCML,		VS_BINARY,	M_BP,	CPX_ARG_MASK	)
    307. 

  307. CREAT_VEC_FUNC( vconj,		FVCONJ,		V_UNARY,	M_ALL,	CPX_ARG_MASK	)
    308. 

  308. CREAT_VEC_FUNC( vfft,		FVFFT,		V_FWD_FFT,	M_BP,	RCM_MASK	)
    309. 

  309. CREAT_VEC_FUNC( vift,		FVIFT,		V_INV_FFT,	M_BP,	RCM_MASK	)
    310. 

  310. 

  311. CREAT_VEC_FUNC( vbnd,		FVBND,		VV_BINARY,	M_ALL,	REAL_ARG_MASK	)
    312. 

  312. CREAT_VEC_FUNC( vibnd,		FVIBND,		VV_BINARY,	M_ALL,	REAL_ARG_MASK	)
    313. 

  313. CREAT_VEC_FUNC( vclip,		FVCLIP,		VS_BINARY,	M_ALL,	REAL_ARG_MASK	)
    314. 

  314. CREAT_VEC_FUNC( viclp,		FVICLP,		VS_BINARY,	M_ALL,	REAL_ARG_MASK	)
    315. 

  315. CREAT_VEC_FUNC( vcmp,		FVCMP,		VV_BINARY,	M_ALL,	REAL_ARG_MASK	)
    316. 

  316. CREAT_VEC_FUNC( vscmp,		FVSCMP,		VS_BINARY,	M_ALL,	REAL_ARG_MASK	)
    317. 

  317. CREAT_VEC_FUNC( vscmp2,		FVSCMP2,	VS_BINARY,	M_ALL,	REAL_ARG_MASK	)
    318. 

  318. 

  319. CREAT_VEC_FUNC( vcomp,		FVCOMP,		V_UNARY,	M_AI,	REAL_ARG_MASK	)
    320. 

  320. 

  321. CREAT_VEC_FUNC( vtolower,	FVTOLOWER,	V_UNARY,	M_AI,	REAL_ARG_MASK	)
    322. 

  322. CREAT_VEC_FUNC( vtoupper,	FVTOUPPER,	V_UNARY,	M_AI,	REAL_ARG_MASK	)
    323. 

  323. 

  324. CREAT_VEC_FUNC( vislower,	FVISLOWER,	V_UNARY,	M_AI,	REAL_ARG_MASK	)
    325. 

  325. CREAT_VEC_FUNC( visupper,	FVISUPPER,	V_UNARY,	M_AI,	REAL_ARG_MASK	)
    326. 

  326. CREAT_VEC_FUNC( visalnum,	FVISALNUM,	V_UNARY,	M_AI,	REAL_ARG_MASK	)
    327. 

  327. CREAT_VEC_FUNC( visalpha,	FVISALPHA,	V_UNARY,	M_AI,	REAL_ARG_MASK	)
    328. 

  328. CREAT_VEC_FUNC( visdigit,	FVISDIGIT,	V_UNARY,	M_AI,	REAL_ARG_MASK	)
    329. 

  329. CREAT_VEC_FUNC( visspace,	FVISSPACE,	V_UNARY,	M_AI,	REAL_ARG_MASK	)
    330. 

  330. CREAT_VEC_FUNC( visblank,	FVISBLANK,	V_UNARY,	M_AI,	REAL_ARG_MASK	)
    331. 

  331. CREAT_VEC_FUNC( viscntrl,	FVISCNTRL,	V_UNARY,	M_AI,	REAL_ARG_MASK	)
    332. 

  332. 

  333. #ifdef NOT_YET
    334. 

  334. CREAT_VEC_FUNC( vcsadd,		FVCSADD,	VS_BINARY,	M_ALL,	CM	)
    335. 

  335. CREAT_VEC_FUNC( vcssub,		FVCSSUB,	VS_BINARY,	M_ALL,	CM	)
    336. 

  336. CREAT_VEC_FUNC( vcsmul,		FVCSMUL,	VS_BINARY,	M_ALL,	CM	)
    337. 

  337. CREAT_VEC_FUNC( vcsdiv,		FVCSDIV,	VS_BINARY,	M_ALL,	CM	)
    338. 

  338. CREAT_VEC_FUNC( vcsdiv2,	FVCSDIV2,	VS_BINARY,	M_ALL,	CM	)
    339. 

  339. #endif
    340. 

  340. /*
    341. 

  341. CREAT_VEC_FUNC( vqsadd,		FVQSADD,	VS_BINARY,	M_ALL,	QP	)
    342. 

  342. CREAT_VEC_FUNC( vqssub,		FVQSSUB,	VS_BINARY,	M_ALL,	QP	)
    343. 

  343. CREAT_VEC_FUNC( vqsmul,		FVQSMUL,	VS_BINARY,	M_ALL,	QP	)
    344. 

  344. CREAT_VEC_FUNC( vqsdiv,		FVQSDIV,	VS_BINARY,	M_ALL,	QP	)
    345. 

  345. CREAT_VEC_FUNC( vqsdiv2,	FVQSDIV2,	VS_BINARY,	M_ALL,	QP	)
    346. 

  346. */
    347. 

  347. 

  348. #ifdef NOT_YET
    349. 

  349. CREAT_VEC_FUNC( vd2sp,		FVD2SP,		V_UNARY,	no_func, 0,	0	)
    350. 

  350. CREAT_VEC_FUNC( vsp2d,		FVSP2D,		V_UNARY,	no_func, 0,	0	)
    351. 

  351. #endif
    352. 

  352. 

  353. END_VFUNC_DECLS
    354. 

  354. 

  355. 

  356. // In the old coding, we created items and copied their values from the table...
    357. 

  357. // But we don't need to have two copies - we just have to insert the names
    358. 

  358. 

  359. #define N_NVFS		(sizeof(vec_func_tbl)/sizeof(Vector_Function))
    360. 

  360. 

  361. 

  362. static void create_vfs(SINGLE_QSP_ARG_DECL)
    363. 

  363. {
    364. 

  364. 	u_int i;
    365. 

  365. 

  366. 	init_vec_funcs(SINGLE_QSP_ARG);	// init item type
    367. 

  367. 

  368. 	for(i=0;i<N_NVFS;i++){
    369. 

  369. 		add_item(QSP_ARG  vec_func_itp, &vec_func_tbl[i], NO_NODE );
    370. 

  370. 	}
    371. 

  371. }
    372. 

  372. 

  373. static int vf_cmp(CONST void *vfp1,CONST void *vfp2)
    374. 

  374. {
    375. 

  375. 	if( ((CONST Vector_Function *)vfp1)->vf_code > ((CONST Vector_Function *)vfp2)->vf_code ) return(1);
    376. 

  376. 	else return(-1);
    377. 

  377. }
    378. 

  378. 

  379. static int vfa_cmp(CONST void *vfp1,CONST void *vfp2)
    380. 

  380. {
    381. 

  381. 	if( ((CONST Vec_Func_Array *)vfp1)->vfa_code > ((CONST Vec_Func_Array *)vfp2)->vfa_code ) return(1);
    382. 

  382. 	else return(-1);
    383. 

  383. }
    384. 

  384. 

  385. int check_vfa_tbl_size(QSP_ARG_DECL  Vec_Func_Array vfa_tbl[], int size)
    386. 

  386. {
    387. 

  387. 	if( size != N_VEC_FUNCS ){
    388. 

  388. sprintf(ERROR_STRING,"CAUTIOUS:  %d inititialized vfa_tbl entries, expected %d!?",
    389. 

  389. 			size,N_VEC_FUNCS);
    390. 

  390. 		WARN(ERROR_STRING);
    391. 

  391. 		return -1;
    392. 

  392. 	}
    393. 

  393. 	return 0;
    394. 

  394. }
    395. 

  395. 

  396. void check_vfa_tbl(QSP_ARG_DECL  Vec_Func_Array *vfa_tbl, int size)
    397. 

  397. {
    398. 

  398. 	int i;
    399. 

  399. //	int retval=0;
    400. 

  400. 

  401. //	if( check_vfa_tbl_size(QSP_ARG  vfa_tbl, size) < 0 )
    402. 

  402. //		return -1;
    403. 

  403. 

  404. 	assert( size == N_VEC_FUNCS );
    405. 

  405. 

  406. 	qsort(vfa_tbl,size,sizeof(Vec_Func_Array),vfa_cmp);
    407. 

  407. 

  408. #ifdef CAUTIOUS
    409. 

  409. 	/* make sure the table is complete */
    410. 

  410. 	for(i=0;i<size;i++){
    411. 

  411. 

  412. /*
    413. 

  413. if( verbose ){
    414. 

  414. sprintf(ERROR_STRING,"check_vfa_tbl:  vfa_tbl[%d] (%s):  code = %d (%s)",
    415. 

  415. i, VF_NAME(&vec_func_tbl[i]),
    416. 

  416. vfa_tbl[i].vfa_code,
    417. 

  417. VF_NAME(&vec_func_tbl[ vfa_tbl[i].vfa_code ])
    418. 

  418. );
    419. 

  419. ADVISE(ERROR_STRING);
    420. 

  420. }
    421. 

  421. */
    422. 

  422. 

  423. //		if( vfa_tbl[i].vfa_code != i ){
    424. 

  424. //			sprintf(ERROR_STRING,
    425. 

  425. //	"CAUTIOUS:  check_vfa_tbl:  Vec_Func_Array table entry %d (%s) has code %d (%s)!?",
    426. 

  426. //		i,VF_NAME(&vec_func_tbl[i]),
    427. 

  427. //		vfa_tbl[i].vfa_code,VF_NAME(&vec_func_tbl[ vfa_tbl[i].vfa_code ]) );
    428. 

  428. //			WARN(ERROR_STRING);
    429. 

  429. //			retval = (-1);
    430. 

  430. //		}
    431. 

  431. 

  432. 		assert( vfa_tbl[i].vfa_code == i );
    433. 

  433. 	}
    434. 

  434. #endif /* CAUTIOUS */
    435. 

  435. }
    436. 

  436. 

  437. void vl_init(SINGLE_QSP_ARG_DECL)
    438. 

  438. {
    439. 

  439. 	static int inited=0;
    440. 

  440. 	int i;
    441. 

  441. 

  442. 	if( inited ){
    443. 

  443. 		// Don't warn, could be called from warmenu & vl_menu...
    444. 

  444. 		/*warn("vl_init:  already initialized"); */
    445. 

  445. 		return;
    446. 

  446. 	}
    447. 

  447. 

  448. 	if( veclib_debug == 0 )
    449. 

  449. 		veclib_debug = add_debug_module(QSP_ARG  "veclib");
    450. 

  450. 

  451. 	/* sort the table to insure that each entry is at the location of its code */
    452. 

  452. //#ifdef CAUTIOUS
    453. 

  453. //	if( N_VEC_FUNCS != N_NVFS ){
    454. 

  454. //		sprintf(ERROR_STRING,"CAUTIOUS:  vl_init:  Vector function table is missing %ld entries!?",
    455. 

  455. //			N_VEC_FUNCS-N_NVFS);
    456. 

  456. //		ERROR1(ERROR_STRING);
    457. 

  457. //	}
    458. 

  458. //#endif // CAUTIOUS
    459. 

  459. 

  460. 	assert( N_VEC_FUNCS == N_NVFS );
    461. 

  461. 

  462. 	qsort(vec_func_tbl,N_NVFS,sizeof(Vector_Function),vf_cmp);
    463. 

  463. 

  464. #ifdef CAUTIOUS
    465. 

  465. 	/* make sure the table is complete */
    466. 

  466. 	for(i=0;i<N_NVFS;i++){
    467. 

  467. 

  468. if( verbose ){
    469. 

  469. sprintf(ERROR_STRING,"vl_init:  vec_func_tbl[%d] (%s):  code %d (%s)",
    470. 

  470. i, VF_NAME(&vec_func_tbl[i]),
    471. 

  471. VF_CODE(&vec_func_tbl[i]), VF_NAME(&vec_func_tbl[ VF_CODE(&vec_func_tbl[i]) ])
    472. 

  472. );
    473. 

  473. ADVISE(ERROR_STRING);
    474. 

  474. }
    475. 

  475. 

  476. //		if( VF_CODE(&vec_func_tbl[i]) != i ){
    477. 

  477. //			sprintf(ERROR_STRING,
    478. 

  478. //	"CAUTIOUS:  vl_init:  Vec_Func table entry %d (%s) has code %d (%s)!?",
    479. 

  479. //		i, VF_NAME(&vec_func_tbl[i]),
    480. 

  480. //		VF_CODE(&vec_func_tbl[i]),
    481. 

  481. //		VF_NAME(&vec_func_tbl[ VF_CODE(&vec_func_tbl[i]) ]) );
    482. 

  482. //			ERROR1(ERROR_STRING);
    483. 

  483. //		}
    484. 

  484. 

  485. 		assert( VF_CODE(&vec_func_tbl[i]) == i );
    486. 

  486. 	}
    487. 

  487. #endif /* CAUTIOUS */
    488. 

  488. 

  489. 	// Initialize the platforms
    490. 

  490. 	//init_all_platforms(SINGLE_QSP_ARG);
    491. 

  491. 	vl2_init_platform(SINGLE_QSP_ARG);
    492. 

  492. 

  493. 	/* now create some items */
    494. 

  494. 

  495. 	create_vfs(SINGLE_QSP_ARG);
    496. 

  496. 

  497. 	declare_vector_functions();
    498. 

  498. 

  499. 	/* We used to have these in a table, indexed by their code, for fast lookup...
    500. 

  500. 	 * Would that be a good idea still?
    501. 

  501. 	 */
    502. 

  502. 

  503. 	set_random_seed(SINGLE_QSP_ARG);	/* use low order bits of microsecond clock */
    504. 

  504. 

  505. 	inited++;
    506. 

  506. }
    507. 

  507. 

  508.