1 /***********************************************************************/ 2 /* Open Visualization Data Explorer */ 3 /* (C) Copyright IBM Corp. 1989,1999 */ 4 /* ALL RIGHTS RESERVED */ 5 /* This code licensed under the */ 6 /* "IBM PUBLIC LICENSE - Open Visualization Data Explorer" */ 7 /***********************************************************************/ 8 9 #include <dxconfig.h> 10 11 12 /* This file contains the description of each operator from a type and 13 * execution point of view. For each operator (such as COND (?:), *, 14 * min, [...], etc.) there is a structure containing the operator 15 * code, name, and a list of valid operator bindings. Each binding contains 16 * the routine to implement the operation, a routine to check the type 17 * of the operator, and type descriptors that the typeCheck routine may or 18 * may not use. For an operator, the bindings are searched sequentially 19 * until one is found to match the given arguments. If the search fails, 20 * all arguments which are ints are promoted to floats, and the search is 21 * repeated. The typecheck routine that finds a match must load the parse 22 * tree\'s type field. 23 * 24 * All of the operators defined herein function on vectors, and (if the 25 * compiler supports it) should be easily vectorisable and utilize the 26 * processor\'s floating point pipeline. 27 * 28 * Note that the routines defining the operation are followed by the 29 * OperBinding structure, and that this structure is referenced by the 30 * OperDesc structure defined just before the Externally Callable Routines. 31 * 32 * Note also that the OperBinding structures are ordered such that if 33 * the inputs match a vector routine, that routine is called first. If 34 * the inputs miss the vector binding, one vectors are treated as scalars, 35 * later on. 36 * 37 * The file exists in several sections: 38 * Macros and utility routines. 39 * Structure operators (such as const, input, construct, select, and cond). 40 * Binary and unary operators (such as *, -, dot) 41 * Builtin functions (such as min, float, sin). 42 * Externally callable routines _dxfComputeTypeCheck, 43 * _dxfComputeExecuteNode, and _dxfComputeLookupFunction 44 * 45 * To add a new operator: 46 * The Parser must be changed to recognize it, and it must be added to 47 * the set of operator codes in _compute.h 48 * The OperBinding structure must be defined that 49 * contains pointers to routines to implement and check the type must be 50 * defined. 51 * This structure must be inserted into the OperDesc structure. 52 * 53 * Adding new built-ins is a little easier, because to make the parse 54 * recognize it, it must be added to the list in _ComputeLookupFunction and 55 * the set of builtin codes shown below. 56 * 57 * Several generic routines are provided to do typechecking, but new ones may 58 * be needed for special case typechecking. The extant routines are: 59 * CheckVects -- Check input for vectors of same length 60 * CheckSameShape -- Check input for same shaped objects 61 * CheckMatch -- Check that the inputs match the types specified in 62 * the binding structure. 63 * CheckSame -- Check that the inputs (any number) match the type 64 * of input[0], which is also the output type. 65 * CheckSameAs -- Check that the inputs (any number) match the type 66 * specified for input[0] in the binding structure. 67 * CheckSameSpecReturn -- Same as CheckSame, but use the output type 68 * given in the binding structure. 69 * CheckDimAnyShape -- matches scalars in the binding exactly, but 70 * if the binding shape == 1, it allows any dimension and shape. 71 */ 72 73 #include <stdio.h> 74 #include <math.h> 75 #include <dx/dx.h> 76 #include "_compute.h" 77 #include "_compputils.h" 78 #include "_compoper.h" 79 80 #define SIZEINT(x) int x##Size = (sizeof (x) / sizeof(x[0])) 81 82 VSBINOP (addVSUBUB, unsigned char, unsigned char, unsigned char, +) 83 VSBINOP (addVSBB, signed char, signed char, signed char, +) 84 VSBINOP (addVSUSUS, unsigned short, unsigned short, unsigned short, +) 85 VSBINOP (addVSSS, signed short, signed short, signed short, +) 86 VSBINOP (addVSUIUI, unsigned int, unsigned int, unsigned int, +) 87 VSBINOP (addVSII, int, int, int, +) 88 VSBINOP(addVSFF, float, float, float, +) 89 VSBINOP(addVSDD, double, double, double, +) 90 VSFUNC2(addVSFFC, complexFloat, complexFloat, complexFloat, _dxfComputeAddComplexFloat) 91 SVBINOP (addSVUBUB, unsigned char, unsigned char, unsigned char, +) 92 SVBINOP (addSVBB, signed char, signed char, signed char, +) 93 SVBINOP (addSVUSUS, unsigned short, unsigned short, unsigned short, +) 94 SVBINOP (addSVSS, signed short, signed short, signed short, +) 95 SVBINOP (addSVUIUI, unsigned int, unsigned int, unsigned int, +) 96 SVBINOP (addSVII, signed int, signed int, signed int, +) 97 SVBINOP(addSVFF, float, float, float, +) 98 SVBINOP(addSVDD, double, double, double, +) 99 SVFUNC2(addSVFFC, complexFloat, complexFloat, complexFloat, _dxfComputeAddComplexFloat) 100 VBINOP (addVUBUB, unsigned char, unsigned char, unsigned char, +) 101 VBINOP (addVBB, signed char, signed char, signed char, +) 102 VBINOP (addVUSUS, unsigned short, unsigned short, unsigned short, +) 103 VBINOP (addVSS, signed short, signed short, signed short, +) 104 VBINOP (addVUIUI, unsigned int, unsigned int, unsigned int, +) 105 VBINOP (addVII, signed int, signed int, signed int, +) 106 VFUNC2 (addVFFC, complexFloat, complexFloat, complexFloat, _dxfComputeAddComplexFloat) 107 VBINOP (addVDD, double, double, double, +) 108 #ifndef KAILIB 109 VBINOP (addVFF, float, float, float, +) 110 #else 111 static int 112 addVFF( 113 PTreeNode *pt, 114 ObjStruct *os, 115 int numInputs, 116 Pointer *inputs, 117 Pointer result, 118 InvalidComponentHandle *invalids, 119 InvalidComponentHandle outInvalid) 120 { 121 register float *out = (float *) result; 122 register float *in0 = (float *) inputs[0]; 123 register float *in1 = (float *) inputs[1]; 124 int size0 = pt->args->metaType.items; 125 int size1 = pt->args->next->metaType.items; 126 int i, j; 127 int numBasic; 128 129 for (numBasic = 1, i = 0; 130 i < pt->metaType.rank; 131 ++i) 132 numBasic *= pt->metaType.shape[i]; 133 134 size0 *= numBasic; 135 size1 *= numBasic; 136 137 if (size0 > numBasic && size1 > numBasic) { 138 vadd(in0, 1, in1, 1, out, 1, pt->metaType.items * numBasic); 139 } 140 else if (size0 > numBasic) { 141 for (j = 0; j < numBasic; ++j) 142 vsadd(in0 + j, numBasic, in1[j], out + j, numBasic, 143 pt->metaType.items); 144 } 145 else if (size1 > numBasic) { 146 for (j = 0; j < numBasic; ++j) 147 vsadd(in1 + j, numBasic, in0[j], out + j, numBasic, 148 pt->metaType.items); 149 } 150 else { 151 vadd(in0, 1, in1, 1, out, 1, numBasic); 152 } 153 return (OK); 154 } 155 #endif 156 157 OperBinding _dxdComputeAdds[] = { 158 {1, (CompFuncV)_dxfComputeCopy, _dxfComputeCheckSame}, 159 {2, (CompFuncV)addVSUBUB, _dxfComputeCheckDimAnyShape, 160 {0, TYPE_UBYTE, CATEGORY_REAL}, 161 { {0, TYPE_UBYTE, CATEGORY_REAL, 1}, 162 {0, TYPE_UBYTE, CATEGORY_REAL, 0}}}, 163 {2, (CompFuncV)addVSBB, _dxfComputeCheckDimAnyShape, 164 {0, TYPE_BYTE, CATEGORY_REAL}, 165 { {0, TYPE_BYTE, CATEGORY_REAL, 1}, 166 {0, TYPE_BYTE, CATEGORY_REAL, 0}}}, 167 {2, (CompFuncV)addVSUSUS, _dxfComputeCheckDimAnyShape, 168 {0, TYPE_USHORT, CATEGORY_REAL}, 169 { {0, TYPE_USHORT, CATEGORY_REAL, 1}, 170 {0, TYPE_USHORT, CATEGORY_REAL, 0}}}, 171 {2, (CompFuncV)addVSSS, _dxfComputeCheckDimAnyShape, 172 {0, TYPE_SHORT, CATEGORY_REAL}, 173 { {0, TYPE_SHORT, CATEGORY_REAL, 1}, 174 {0, TYPE_SHORT, CATEGORY_REAL, 0}}}, 175 {2, (CompFuncV)addVSII, _dxfComputeCheckDimAnyShape, 176 {0, TYPE_INT, CATEGORY_REAL}, 177 { {0, TYPE_INT, CATEGORY_REAL, 1}, 178 {0, TYPE_INT, CATEGORY_REAL, 0}}}, 179 {2, (CompFuncV)addVSUIUI, _dxfComputeCheckDimAnyShape, 180 {0, TYPE_UINT, CATEGORY_REAL}, 181 { {0, TYPE_UINT, CATEGORY_REAL, 1}, 182 {0, TYPE_UINT, CATEGORY_REAL, 0}}}, 183 {2, (CompFuncV)addVSFF, _dxfComputeCheckDimAnyShape, 184 {0, TYPE_FLOAT, CATEGORY_REAL}, 185 { {0, TYPE_FLOAT, CATEGORY_REAL, 1}, 186 {0, TYPE_FLOAT, CATEGORY_REAL, 0}}}, 187 {2, (CompFuncV)addVSDD, _dxfComputeCheckDimAnyShape, 188 {0, TYPE_DOUBLE, CATEGORY_REAL}, 189 { {0, TYPE_DOUBLE, CATEGORY_REAL, 1}, 190 {0, TYPE_FLOAT, CATEGORY_REAL, 0}}}, 191 {2, (CompFuncV)addVSFFC, _dxfComputeCheckDimAnyShape, 192 {0, TYPE_FLOAT, CATEGORY_COMPLEX}, 193 { {0, TYPE_FLOAT, CATEGORY_COMPLEX, 1}, 194 {0, TYPE_FLOAT, CATEGORY_COMPLEX, 0}}}, 195 {2, (CompFuncV)addSVUBUB, _dxfComputeCheckDimAnyShape, 196 {0, TYPE_UBYTE, CATEGORY_REAL}, 197 { {0, TYPE_UBYTE, CATEGORY_REAL, 0}, 198 {0, TYPE_UBYTE, CATEGORY_REAL, 1}}}, 199 {2, (CompFuncV)addSVBB, _dxfComputeCheckDimAnyShape, 200 {0, TYPE_BYTE, CATEGORY_REAL}, 201 { {0, TYPE_BYTE, CATEGORY_REAL, 0}, 202 {0, TYPE_BYTE, CATEGORY_REAL, 1}}}, 203 {2, (CompFuncV)addSVUSUS, _dxfComputeCheckDimAnyShape, 204 {0, TYPE_USHORT, CATEGORY_REAL}, 205 { {0, TYPE_USHORT, CATEGORY_REAL, 0}, 206 {0, TYPE_USHORT, CATEGORY_REAL, 1}}}, 207 {2, (CompFuncV)addSVSS, _dxfComputeCheckDimAnyShape, 208 {0, TYPE_SHORT, CATEGORY_REAL}, 209 { {0, TYPE_SHORT, CATEGORY_REAL, 0}, 210 {0, TYPE_SHORT, CATEGORY_REAL, 1}}}, 211 {2, (CompFuncV)addSVUIUI, _dxfComputeCheckDimAnyShape, 212 {0, TYPE_UINT, CATEGORY_REAL}, 213 { {0, TYPE_UINT, CATEGORY_REAL, 0}, 214 {0, TYPE_UINT, CATEGORY_REAL, 1}}}, 215 {2, (CompFuncV)addSVII, _dxfComputeCheckDimAnyShape, 216 {0, TYPE_INT, CATEGORY_REAL}, 217 { {0, TYPE_INT, CATEGORY_REAL, 0}, 218 {0, TYPE_INT, CATEGORY_REAL, 1}}}, 219 {2, (CompFuncV)addSVFF, _dxfComputeCheckDimAnyShape, 220 {0, TYPE_FLOAT, CATEGORY_REAL}, 221 { {0, TYPE_FLOAT, CATEGORY_REAL, 0}, 222 {0, TYPE_FLOAT, CATEGORY_REAL, 1}}}, 223 {2, (CompFuncV)addSVDD, _dxfComputeCheckDimAnyShape, 224 {0, TYPE_DOUBLE, CATEGORY_REAL}, 225 { {0, TYPE_DOUBLE, CATEGORY_REAL, 0}, 226 {0, TYPE_DOUBLE, CATEGORY_REAL, 1}}}, 227 {2, (CompFuncV)addSVFFC, _dxfComputeCheckDimAnyShape, 228 {0, TYPE_FLOAT, CATEGORY_COMPLEX}, 229 { {0, TYPE_FLOAT, CATEGORY_COMPLEX, 0}, 230 {0, TYPE_FLOAT, CATEGORY_COMPLEX, 1}}}, 231 {2, (CompFuncV)addVUBUB, _dxfComputeCheckSameShape, 232 {0, TYPE_UBYTE, CATEGORY_REAL}, 233 { {0, TYPE_UBYTE, CATEGORY_REAL}, 234 {0, TYPE_UBYTE, CATEGORY_REAL}}}, 235 {2, (CompFuncV)addVBB, _dxfComputeCheckSameShape, 236 {0, TYPE_BYTE, CATEGORY_REAL}, 237 { {0, TYPE_BYTE, CATEGORY_REAL}, 238 {0, TYPE_BYTE, CATEGORY_REAL}}}, 239 {2, (CompFuncV)addVUSUS, _dxfComputeCheckSameShape, 240 {0, TYPE_USHORT, CATEGORY_REAL}, 241 { {0, TYPE_USHORT, CATEGORY_REAL}, 242 {0, TYPE_USHORT, CATEGORY_REAL}}}, 243 {2, (CompFuncV)addVSS, _dxfComputeCheckSameShape, 244 {0, TYPE_SHORT, CATEGORY_REAL}, 245 { {0, TYPE_SHORT, CATEGORY_REAL}, 246 {0, TYPE_SHORT, CATEGORY_REAL}}}, 247 {2, (CompFuncV)addVUIUI, _dxfComputeCheckSameShape, 248 {0, TYPE_UINT, CATEGORY_REAL}, 249 { {0, TYPE_UINT, CATEGORY_REAL}, 250 {0, TYPE_UINT, CATEGORY_REAL}}}, 251 {2, (CompFuncV)addVII, _dxfComputeCheckSameShape, 252 {0, TYPE_INT, CATEGORY_REAL}, 253 { {0, TYPE_INT, CATEGORY_REAL}, 254 {0, TYPE_INT, CATEGORY_REAL}}}, 255 {2, (CompFuncV)addVFF, _dxfComputeCheckSameShape, 256 {0, TYPE_FLOAT, CATEGORY_REAL}, 257 { {0, TYPE_FLOAT, CATEGORY_REAL}, 258 {0, TYPE_FLOAT, CATEGORY_REAL}}}, 259 {2, (CompFuncV)addVDD, _dxfComputeCheckSameShape, 260 {0, TYPE_DOUBLE, CATEGORY_REAL}, 261 { {0, TYPE_DOUBLE, CATEGORY_REAL}, 262 {0, TYPE_DOUBLE, CATEGORY_REAL}}}, 263 {2, (CompFuncV)addVFFC, _dxfComputeCheckSameShape, 264 {0, TYPE_FLOAT, CATEGORY_COMPLEX}, 265 { {0, TYPE_FLOAT, CATEGORY_COMPLEX}, 266 {0, TYPE_FLOAT, CATEGORY_COMPLEX}}} 267 }; 268 SIZEINT(_dxdComputeAdds); 269 270 271 272 VBINOP (subVUBUB, unsigned char, unsigned char, unsigned char, -) 273 VBINOP (subVBB, signed char, signed char, signed char, -) 274 VBINOP (subVUSUS, unsigned short, unsigned short, unsigned short, -) 275 VBINOP (subVSS, signed short, signed short, signed short, -) 276 VBINOP (subVUIUI, unsigned int, unsigned int, unsigned int, -) 277 VBINOP (subVII, signed int, signed int, signed int, -) 278 VBINOP (subVFF, float, float, float, -) 279 VBINOP (subVDD, double, double, double, -) 280 VFUNC2 (subVFFC, complexFloat, complexFloat, complexFloat, _dxfComputeSubComplexFloat) 281 VSBINOP (subVSUBUB, unsigned char, unsigned char, unsigned char, -) 282 VSBINOP (subVSBB, signed char, signed char, signed char, -) 283 VSBINOP (subVSUSUS, unsigned short, unsigned short, unsigned short, -) 284 VSBINOP (subVSSS, signed short, signed short, signed short, -) 285 VSBINOP (subVSUIUI, unsigned int, unsigned int, unsigned int, -) 286 VSBINOP (subVSII, signed int, signed int, signed int, -) 287 VSBINOP (subVSFF, float, float, float, -) 288 VSBINOP (subVSDD, double, double, double, -) 289 VSFUNC2 (subVSFFC, complexFloat, complexFloat, complexFloat, _dxfComputeSubComplexFloat) 290 SVBINOP (subSVUBUB, unsigned char, unsigned char, unsigned char, -) 291 SVBINOP (subSVBB, signed char, signed char, signed char, -) 292 SVBINOP (subSVUSUS, unsigned short, unsigned short, unsigned short, -) 293 SVBINOP (subSVSS, signed short, signed short, signed short, -) 294 SVBINOP (subSVUIUI, unsigned int, unsigned int, unsigned int, -) 295 SVBINOP (subSVII, signed int, signed int, signed int, -) 296 SVBINOP (subSVFF, float, float, float, -) 297 SVBINOP (subSVDD, double, double, double, -) 298 SVFUNC2 (subSVFFC, complexFloat, complexFloat, complexFloat, _dxfComputeSubComplexFloat) 299 VUNOP (negVB, signed char, signed char, -) 300 VUNOP (negVS, signed short, signed short, -) 301 VUNOP (negVI, int, int, -) 302 VUNOP (negVF, float, float, -) 303 VUNOP (negVD, double, double, -) 304 VFUNC1 (negVFC, complexFloat, complexFloat, _dxfComputeNegComplexFloat) 305 OperBinding _dxdComputeSubs[] = { 306 {1, (CompFuncV)negVB, _dxfComputeCheckSameShape, 307 {0, TYPE_BYTE, CATEGORY_REAL, 1}, 308 { {0, TYPE_BYTE, CATEGORY_REAL, 0}}}, 309 {1, (CompFuncV)negVS, _dxfComputeCheckSameShape, 310 {0, TYPE_SHORT, CATEGORY_REAL, 1}, 311 { {0, TYPE_SHORT, CATEGORY_REAL, 0}}}, 312 {1, (CompFuncV)negVI, _dxfComputeCheckSameShape, 313 {0, TYPE_INT, CATEGORY_REAL, 1}, 314 { {0, TYPE_INT, CATEGORY_REAL, 0}}}, 315 {1, (CompFuncV)negVF, _dxfComputeCheckSameShape, 316 {0, TYPE_FLOAT, CATEGORY_REAL, 1}, 317 { {0, TYPE_FLOAT, CATEGORY_REAL, 0}}}, 318 {1, (CompFuncV)negVD, _dxfComputeCheckSameShape, 319 {0, TYPE_DOUBLE, CATEGORY_REAL, 1}, 320 { {0, TYPE_DOUBLE, CATEGORY_REAL, 0}}}, 321 {1, (CompFuncV)negVFC, _dxfComputeCheckSameShape, 322 {0, TYPE_FLOAT, CATEGORY_COMPLEX, 1}, 323 { {0, TYPE_FLOAT, CATEGORY_COMPLEX, 0}}}, 324 {2, (CompFuncV)subVSUBUB, _dxfComputeCheckDimAnyShape, 325 {0, TYPE_UBYTE, CATEGORY_REAL, 1}, 326 { {0, TYPE_UBYTE, CATEGORY_REAL, 1}, 327 {0, TYPE_UBYTE, CATEGORY_REAL, 0}}}, 328 {2, (CompFuncV)subVSBB, _dxfComputeCheckDimAnyShape, 329 {0, TYPE_BYTE, CATEGORY_REAL, 1}, 330 { {0, TYPE_BYTE, CATEGORY_REAL, 1}, 331 {0, TYPE_BYTE, CATEGORY_REAL, 0}}}, 332 {2, (CompFuncV)subVSUSUS, _dxfComputeCheckDimAnyShape, 333 {0, TYPE_USHORT, CATEGORY_REAL, 1}, 334 { {0, TYPE_USHORT, CATEGORY_REAL, 1}, 335 {0, TYPE_USHORT, CATEGORY_REAL, 0}}}, 336 {2, (CompFuncV)subVSSS, _dxfComputeCheckDimAnyShape, 337 {0, TYPE_SHORT, CATEGORY_REAL, 1}, 338 { {0, TYPE_SHORT, CATEGORY_REAL, 1}, 339 {0, TYPE_SHORT, CATEGORY_REAL, 0}}}, 340 {2, (CompFuncV)subVSUIUI, _dxfComputeCheckDimAnyShape, 341 {0, TYPE_UINT, CATEGORY_REAL, 1}, 342 { {0, TYPE_UINT, CATEGORY_REAL, 1}, 343 {0, TYPE_UINT, CATEGORY_REAL, 0}}}, 344 {2, (CompFuncV)subVSII, _dxfComputeCheckDimAnyShape, 345 {0, TYPE_INT, CATEGORY_REAL, 1}, 346 { {0, TYPE_INT, CATEGORY_REAL, 1}, 347 {0, TYPE_INT, CATEGORY_REAL, 0}}}, 348 {2, (CompFuncV)subVSFF, _dxfComputeCheckDimAnyShape, 349 {0, TYPE_FLOAT, CATEGORY_REAL, 1}, 350 { {0, TYPE_FLOAT, CATEGORY_REAL, 1}, 351 {0, TYPE_FLOAT, CATEGORY_REAL, 0}}}, 352 {2, (CompFuncV)subVSDD, _dxfComputeCheckDimAnyShape, 353 {0, TYPE_DOUBLE, CATEGORY_REAL, 1}, 354 { {0, TYPE_DOUBLE, CATEGORY_REAL, 1}, 355 {0, TYPE_DOUBLE, CATEGORY_REAL, 0}}}, 356 {2, (CompFuncV)subVSFFC, _dxfComputeCheckDimAnyShape, 357 {0, TYPE_FLOAT, CATEGORY_COMPLEX, 1}, 358 { {0, TYPE_FLOAT, CATEGORY_COMPLEX, 1}, 359 {0, TYPE_FLOAT, CATEGORY_COMPLEX, 0}}}, 360 {2, (CompFuncV)subSVUBUB, _dxfComputeCheckDimAnyShape, 361 {0, TYPE_UBYTE, CATEGORY_REAL, 1}, 362 { {0, TYPE_UBYTE, CATEGORY_REAL, 0}, 363 {0, TYPE_UBYTE, CATEGORY_REAL, 1}}}, 364 {2, (CompFuncV)subSVBB, _dxfComputeCheckDimAnyShape, 365 {0, TYPE_BYTE, CATEGORY_REAL, 1}, 366 { {0, TYPE_BYTE, CATEGORY_REAL, 0}, 367 {0, TYPE_BYTE, CATEGORY_REAL, 1}}}, 368 {2, (CompFuncV)subSVUSUS, _dxfComputeCheckDimAnyShape, 369 {0, TYPE_USHORT, CATEGORY_REAL, 1}, 370 { {0, TYPE_USHORT, CATEGORY_REAL, 0}, 371 {0, TYPE_USHORT, CATEGORY_REAL, 1}}}, 372 {2, (CompFuncV)subSVSS, _dxfComputeCheckDimAnyShape, 373 {0, TYPE_SHORT, CATEGORY_REAL, 1}, 374 { {0, TYPE_SHORT, CATEGORY_REAL, 0}, 375 {0, TYPE_SHORT, CATEGORY_REAL, 1}}}, 376 {2, (CompFuncV)subSVUIUI, _dxfComputeCheckDimAnyShape, 377 {0, TYPE_UINT, CATEGORY_REAL, 1}, 378 { {0, TYPE_UINT, CATEGORY_REAL, 0}, 379 {0, TYPE_UINT, CATEGORY_REAL, 1}}}, 380 {2, (CompFuncV)subSVII, _dxfComputeCheckDimAnyShape, 381 {0, TYPE_INT, CATEGORY_REAL, 1}, 382 { {0, TYPE_INT, CATEGORY_REAL, 0}, 383 {0, TYPE_INT, CATEGORY_REAL, 1}}}, 384 {2, (CompFuncV)subSVFF, _dxfComputeCheckDimAnyShape, 385 {0, TYPE_FLOAT, CATEGORY_REAL, 1}, 386 { {0, TYPE_FLOAT, CATEGORY_REAL, 0}, 387 {0, TYPE_FLOAT, CATEGORY_REAL, 1}}}, 388 {2, (CompFuncV)subSVDD, _dxfComputeCheckDimAnyShape, 389 {0, TYPE_DOUBLE, CATEGORY_REAL, 1}, 390 { {0, TYPE_DOUBLE, CATEGORY_REAL, 0}, 391 {0, TYPE_DOUBLE, CATEGORY_REAL, 1}}}, 392 {2, (CompFuncV)subSVFFC, _dxfComputeCheckDimAnyShape, 393 {0, TYPE_FLOAT, CATEGORY_COMPLEX, 1}, 394 { {0, TYPE_FLOAT, CATEGORY_COMPLEX, 0}, 395 {0, TYPE_FLOAT, CATEGORY_COMPLEX, 1}}}, 396 {2, (CompFuncV)subVUBUB, _dxfComputeCheckSameShape, 397 {0, TYPE_UBYTE, CATEGORY_REAL, 1}, 398 { {0, TYPE_UBYTE, CATEGORY_REAL, 0}, 399 {0, TYPE_UBYTE, CATEGORY_REAL, 0}}}, 400 {2, (CompFuncV)subVBB, _dxfComputeCheckSameShape, 401 {0, TYPE_BYTE, CATEGORY_REAL, 1}, 402 { {0, TYPE_BYTE, CATEGORY_REAL, 0}, 403 {0, TYPE_BYTE, CATEGORY_REAL, 0}}}, 404 {2, (CompFuncV)subVUSUS, _dxfComputeCheckSameShape, 405 {0, TYPE_USHORT, CATEGORY_REAL, 1}, 406 { {0, TYPE_USHORT, CATEGORY_REAL, 0}, 407 {0, TYPE_USHORT, CATEGORY_REAL, 0}}}, 408 {2, (CompFuncV)subVSS, _dxfComputeCheckSameShape, 409 {0, TYPE_SHORT, CATEGORY_REAL, 1}, 410 { {0, TYPE_SHORT, CATEGORY_REAL, 0}, 411 {0, TYPE_SHORT, CATEGORY_REAL, 0}}}, 412 {2, (CompFuncV)subVUIUI, _dxfComputeCheckSameShape, 413 {0, TYPE_UINT, CATEGORY_REAL, 1}, 414 { {0, TYPE_UINT, CATEGORY_REAL, 0}, 415 {0, TYPE_UINT, CATEGORY_REAL, 0}}}, 416 {2, (CompFuncV)subVII, _dxfComputeCheckSameShape, 417 {0, TYPE_INT, CATEGORY_REAL, 1}, 418 { {0, TYPE_INT, CATEGORY_REAL, 0}, 419 {0, TYPE_INT, CATEGORY_REAL, 0}}}, 420 {2, (CompFuncV)subVFF, _dxfComputeCheckSameShape, 421 {0, TYPE_FLOAT, CATEGORY_REAL, 1}, 422 { {0, TYPE_FLOAT, CATEGORY_REAL, 0}, 423 {0, TYPE_FLOAT, CATEGORY_REAL, 0}}}, 424 {2, (CompFuncV)subVDD, _dxfComputeCheckSameShape, 425 {0, TYPE_DOUBLE, CATEGORY_REAL, 1}, 426 { {0, TYPE_DOUBLE, CATEGORY_REAL, 0}, 427 {0, TYPE_DOUBLE, CATEGORY_REAL, 0}}}, 428 {2, (CompFuncV)subVFFC, _dxfComputeCheckSameShape, 429 {0, TYPE_FLOAT, CATEGORY_COMPLEX, 1}, 430 { {0, TYPE_FLOAT, CATEGORY_COMPLEX, 0}, 431 {0, TYPE_FLOAT, CATEGORY_COMPLEX, 0}}} 432 }; 433 SIZEINT(_dxdComputeSubs); 434 435 /* Now follows the set of builtin functions for type conversion and 436 * truncation 437 */ 438 #ifndef sgi 439 # define ffloor floor 440 # define fceil ceil 441 # define ftrunc trunc 442 # define flog log 443 # define flog10 log10 444 # define fexp exp 445 # define fsin sin 446 # define fcos cos 447 # define ftan tan 448 # define fsinh sinh 449 # define fcosh cosh 450 # define ftanh tanh 451 # define fasin asin 452 # define facos acos 453 # define fatan atan 454 # define fatan2 atan2 455 # define fsqrt sqrt 456 #endif 457 #ifdef freebsd 458 # define trunc(x) ((float)((int)(x))) 459 #endif 460 #ifdef cygwin 461 # define trunc(x) ((float)((int)(x))) 462 #endif 463 #ifdef linux 464 # define trunc(x) ((float)((int)(x))) 465 #endif 466 #ifdef aviion 467 # define trunc(x) ((float)((int)(x))) 468 #endif 469 #ifdef sun4 470 # define trunc(x) ((float)((int)(x))) 471 #endif 472 #ifdef solaris 473 # define trunc(x) ((float)((int)(x))) 474 #endif 475 #ifdef ibmpvs 476 # define rint(x) ((float)((int)((x) + 0.5))) 477 # define trunc(x) ((float)((int)(x))) 478 #endif 479 #ifdef hp700 480 # define rint(x) ((float)((int)((x) + 0.5))) 481 # define trunc(x) ((float)((int)(x))) 482 #endif 483 #ifdef macos 484 # define trunc(x) ((float)((int)(x))) 485 #endif 486 #define SIGN(x) ((x) >= 0? (1): (-1)) 487 488 489 VFUNC1 (floorVF, float, float, ffloor ) 490 VFUNC1 (ceilVF, float, float, fceil ) 491 VFUNC1 (truncVF, float, float, ftrunc ) 492 VFUNC1 (rintVF, float, float, rint ) 493 VFUNC1 (floorVD, double, double, floor ) 494 VFUNC1 (ceilVD, double, double, ceil ) 495 VFUNC1 (truncVD, double, double, trunc ) 496 VFUNC1 (rintVD, double, double, rint ) 497 498 VFUNC1 (signVF, int, float, SIGN) 499 VFUNC1 (signVD, int, double, SIGN) 500 VFUNC1 (signVI, int, int, SIGN) 501 VFUNC1 (signVS, int, short, SIGN) 502 VFUNC1 (signVB, int, signed char, SIGN) 503 OperBinding _dxdComputeFloors[] = { 504 {1, (CompFuncV)floorVF, _dxfComputeCheckSameShape, 505 {0, TYPE_FLOAT, CATEGORY_REAL, 0}, 506 { {0, TYPE_FLOAT, CATEGORY_REAL, 0}}}, 507 {1, (CompFuncV)floorVD, _dxfComputeCheckSameShape, 508 {0, TYPE_FLOAT, CATEGORY_REAL, 0}, 509 { {0, TYPE_DOUBLE, CATEGORY_REAL, 0}}} 510 }; 511 OperBinding _dxdComputeCeils[] = { 512 {1, (CompFuncV)ceilVF, _dxfComputeCheckSameShape, 513 {0, TYPE_FLOAT, CATEGORY_REAL, 0}, 514 { {0, TYPE_FLOAT, CATEGORY_REAL, 0}}}, 515 {1, (CompFuncV)ceilVD, _dxfComputeCheckSameShape, 516 {0, TYPE_FLOAT, CATEGORY_REAL, 0}, 517 { {0, TYPE_DOUBLE, CATEGORY_REAL, 0}}} 518 }; 519 OperBinding _dxdComputeTruncs[] = { 520 {1, (CompFuncV)truncVF, _dxfComputeCheckSameShape, 521 {0, TYPE_FLOAT, CATEGORY_REAL, 0}, 522 { {0, TYPE_FLOAT, CATEGORY_REAL, 0}}}, 523 {1, (CompFuncV)truncVD, _dxfComputeCheckSameShape, 524 {0, TYPE_FLOAT, CATEGORY_REAL, 0}, 525 { {0, TYPE_DOUBLE, CATEGORY_REAL, 0}}} 526 }; 527 OperBinding _dxdComputeRints[] = { 528 {1, (CompFuncV)rintVF, _dxfComputeCheckSameShape, 529 {0, TYPE_FLOAT, CATEGORY_REAL, 0}, 530 { {0, TYPE_FLOAT, CATEGORY_REAL, 0}}}, 531 {1, (CompFuncV)rintVD, _dxfComputeCheckSameShape, 532 {0, TYPE_FLOAT, CATEGORY_REAL, 0}, 533 { {0, TYPE_DOUBLE, CATEGORY_REAL, 0}}} 534 }; 535 OperBinding _dxdComputeSigns[] = { 536 {1, (CompFuncV)signVF, _dxfComputeCheckSameShape, 537 {0, TYPE_INT, CATEGORY_REAL, 0}, 538 { {0, TYPE_FLOAT, CATEGORY_REAL, 0}}}, 539 {1, (CompFuncV)signVD, _dxfComputeCheckSameShape, 540 {0, TYPE_INT, CATEGORY_REAL, 0}, 541 { {0, TYPE_DOUBLE, CATEGORY_REAL, 0}}}, 542 {1, (CompFuncV)signVI, _dxfComputeCheckSameShape, 543 {0, TYPE_INT, CATEGORY_REAL, 0}, 544 { {0, TYPE_INT, CATEGORY_REAL, 0}}}, 545 {1, (CompFuncV)signVS, _dxfComputeCheckSameShape, 546 {0, TYPE_INT, CATEGORY_REAL, 0}, 547 { {0, TYPE_SHORT, CATEGORY_REAL, 0}}}, 548 {1, (CompFuncV)signVB, _dxfComputeCheckSameShape, 549 {0, TYPE_INT, CATEGORY_REAL, 0}, 550 { {0, TYPE_BYTE, CATEGORY_REAL, 0}}} 551 }; 552 SIZEINT(_dxdComputeFloors); 553 SIZEINT(_dxdComputeCeils); 554 SIZEINT(_dxdComputeTruncs); 555 SIZEINT(_dxdComputeRints); 556 SIZEINT(_dxdComputeSigns); 557 558 559 VMULTIOP(minFs, float, float, MIN, DXD_MAX_FLOAT) 560 VMULTIOP(minDs, double, double, MIN, DXD_MAX_DOUBLE) 561 VMULTIOP(minUIs, unsigned int, unsigned int, MIN, 0xffffffff) 562 VMULTIOP(minIs, int, int, MIN, 0x7fffffff) 563 VMULTIOP(minUBs, unsigned char, unsigned char, MIN, 0xff) 564 VMULTIOP(minBs, signed char, signed char, MIN, 0x7f) 565 VMULTIOP(minUSs, unsigned short, unsigned short, MIN, 0xffff) 566 VMULTIOP(minSs, signed short, signed short, MIN, 0x7fff) 567 OperBinding _dxdComputeMins[] = { 568 {-1, (CompFuncV)minUBs, _dxfComputeCheckSameAs, 569 {0, TYPE_UBYTE, CATEGORY_REAL, 0}, 570 { {0, TYPE_UBYTE, CATEGORY_REAL, 0}}}, 571 {-1, (CompFuncV)minBs, _dxfComputeCheckSameAs, 572 {0, TYPE_BYTE, CATEGORY_REAL, 0}, 573 { {0, TYPE_BYTE, CATEGORY_REAL, 0}}}, 574 {-1, (CompFuncV)minUSs, _dxfComputeCheckSameAs, 575 {0, TYPE_USHORT, CATEGORY_REAL, 0}, 576 { {0, TYPE_USHORT, CATEGORY_REAL, 0}}}, 577 {-1, (CompFuncV)minSs, _dxfComputeCheckSameAs, 578 {0, TYPE_SHORT, CATEGORY_REAL, 0}, 579 { {0, TYPE_SHORT, CATEGORY_REAL, 0}}}, 580 {-1, (CompFuncV)minUIs, _dxfComputeCheckSameAs, 581 {0, TYPE_UINT, CATEGORY_REAL, 0}, 582 { {0, TYPE_UINT, CATEGORY_REAL, 0}}}, 583 {-1, (CompFuncV)minIs, _dxfComputeCheckSameAs, 584 {0, TYPE_INT, CATEGORY_REAL, 0}, 585 { {0, TYPE_INT, CATEGORY_REAL, 0}}}, 586 {-1, (CompFuncV)minDs, _dxfComputeCheckSameAs, 587 {0, TYPE_DOUBLE, CATEGORY_REAL, 0}, 588 { {0, TYPE_DOUBLE, CATEGORY_REAL, 0}}}, 589 {-1, (CompFuncV)minFs, _dxfComputeCheckSameAs, 590 {0, TYPE_FLOAT, CATEGORY_REAL, 0}, 591 { {0, TYPE_FLOAT, CATEGORY_REAL, 0}}} 592 }; 593 SIZEINT(_dxdComputeMins); 594 595 VMULTIOP(maxFs, float, float, MAX, -DXD_MAX_FLOAT) 596 VMULTIOP(maxDs, double, double, MAX, -DXD_MAX_DOUBLE) 597 VMULTIOP(maxIs, int, int, MAX, DXD_MIN_INT) 598 VMULTIOP(maxSs, short, short, MAX, DXD_MIN_SHORT) 599 VMULTIOP(maxBs, signed char, signed char, MAX, DXD_MIN_BYTE) 600 VMULTIOP(maxUIs, unsigned int, unsigned int, MAX, 0) 601 VMULTIOP(maxUSs, unsigned short, unsigned short, MAX, 0) 602 VMULTIOP(maxUBs, unsigned char, unsigned char, MAX, 0) 603 604 OperBinding _dxdComputeMaxs[] = { 605 {-1, (CompFuncV)maxBs, _dxfComputeCheckSameAs, 606 {0, TYPE_BYTE, CATEGORY_REAL, 0}, 607 { {0, TYPE_BYTE, CATEGORY_REAL, 0}}}, 608 {-1, (CompFuncV)maxSs, _dxfComputeCheckSameAs, 609 {0, TYPE_SHORT, CATEGORY_REAL, 0}, 610 { {0, TYPE_SHORT, CATEGORY_REAL, 0}}}, 611 {-1, (CompFuncV)maxIs, _dxfComputeCheckSameAs, 612 {0, TYPE_INT, CATEGORY_REAL, 0}, 613 { {0, TYPE_INT, CATEGORY_REAL, 0}}}, 614 {-1, (CompFuncV)maxUBs, _dxfComputeCheckSameAs, 615 {0, TYPE_UBYTE, CATEGORY_REAL, 0}, 616 { {0, TYPE_UBYTE, CATEGORY_REAL, 0}}}, 617 {-1, (CompFuncV)maxUSs, _dxfComputeCheckSameAs, 618 {0, TYPE_USHORT, CATEGORY_REAL, 0}, 619 { {0, TYPE_USHORT, CATEGORY_REAL, 0}}}, 620 {-1, (CompFuncV)maxUIs, _dxfComputeCheckSameAs, 621 {0, TYPE_UINT, CATEGORY_REAL, 0}, 622 { {0, TYPE_UINT, CATEGORY_REAL, 0}}}, 623 {-1, (CompFuncV)maxDs, _dxfComputeCheckSameAs, 624 {0, TYPE_DOUBLE, CATEGORY_REAL, 0}, 625 { {0, TYPE_DOUBLE, CATEGORY_REAL, 0}}}, 626 {-1, (CompFuncV)maxFs, _dxfComputeCheckSameAs, 627 {0, TYPE_FLOAT, CATEGORY_REAL, 0}, 628 { {0, TYPE_FLOAT, CATEGORY_REAL, 0}}} 629 }; 630 SIZEINT(_dxdComputeMaxs); 631 632 633