IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Nov 25, 2008, 4:51:39 PM (18 years ago)
Author:
eugene
Message:

convert opihi vectors to double type, add option for int type as well

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branch_20081124/Ohana/src/opihi/lib.shell/stack_math.c

    r20827 r20839  
    99
    1010  int i, Nx;
    11   float *out, *M1, *M2;
    1211  char line[512]; // this is only used to report an error
    1312 
     13  // the vectors have to match in length
     14  if (V1[0].vector[0].Nelements != V2[0].vector[0].Nelements) {
     15    return (FALSE);
     16  }
     17
    1418  Nx = V1[0].vector[0].Nelements;
    15   if (Nx != V2[0].vector[0].Nelements) {
    16     return (FALSE);
    17   }
    18 
    19   if (V1[0].type == 'v') {  /** use V1 as temp buffer **/
    20     OUT[0].vector = V1[0].vector;
    21     V1[0].type = 'V'; /* prevent it from being freed below */
    22   } else {
    23     if (V2[0].type == 'v') { /** use V2 as temp buffer, but header of V1 **/
    24       OUT[0].vector = V2[0].vector;
    25       V2[0].type = 'V'; /* prevent it from being freed below */
    26     } else {  /* no spare temp buffer */
    27       OUT[0].vector = InitVector ();
    28       CopyVector (OUT[0].vector, V1[0].vector);
    29     }
    30   }
    31   OUT[0].type = 'v'; /*** <<--- says this is a temporary matrix ***/
    32 
    33   M1  = V1[0].ptr;
    34   M2  = V2[0].ptr;
    35   out = OUT[0].ptr = (float *)OUT[0].vector[0].elements;
    36 
    37 // XXX this is not quite there:
    38 // 1) do I drop the .ptr element of StackVar?
    39 // 2) things below are using type from a StackVar to get the vector type -- wrong place
    40 // 3) the temp would need lots of work -- is it worth it?
    41 // 4) some operators force the output to be float -- we cannot use a single bit of code to
    42 //    define the output type based on which is a float and which is not.  getting ugly.
    43 // ??? how much more work to bring the MV, etc functions into shape ???
    44 
     19
     20  // XXX we temporarily drop the concept of using one of the temporary input vectors for
     21  // the output vector (thus saving an ALLOC): we have to juggle the size of the input vectors
     22  // as well as their temporary state
     23
     24  // create the output vector guaranteed to be temporary until the very end
     25  OUT[0].vector = InitVector ();
     26  OUT[0].type = 'v';
     27
     28  // set up the possible operations : int OP int -> int, all else yield float
     29  // OP is the operation performed on *M1 and *M2
    4530# define VV_FUNC(OP) \
    46   if ((M1->type == OPIHI_FLOAT) && (M2->type == OPIHI_FLOAT)) { \
    47     // output must be float, can use either as a temp \
    48     opihi_float *M1 = V1[0].vector[0].elements; \
    49     opihi_float *M2 = V2[0].vector[0].elements; \
     31  if ((V1->vector->type == OPIHI_FLT) && (V2->vector->type == OPIHI_FLT)) { \
     32    CopyVector (OUT[0].vector, V1[0].vector); \
     33    opihi_flt *M1  =  V1[0].vector[0].elements.Flt; \
     34    opihi_flt *M2  =  V2[0].vector[0].elements.Flt; \
     35    opihi_flt *out = OUT[0].vector[0].elements.Flt; \
    5036    for (i = 0; i < Nx; i++, out++, M1++, M2++) { \
    51         *out = *M1 OP *M2; \
     37        *out = OP; \
    5238    } \
    5339    break; \
    5440  } \
    55   if ((M1->type != OPIHI_FLOAT) && (M2->type == OPIHI_FLOAT)) { \
    56     // output must be float, can use M2 as a temp \
    57     opihi_float *M1 = V1[0].vector[0].elementsInt; \
    58     opihi_float *M2 = V2[0].vector[0].elements; \
     41  if ((V1->vector->type == OPIHI_FLT) && (V2->vector->type != OPIHI_FLT)) { \
     42    CopyVector (OUT[0].vector, V1[0].vector); \
     43    opihi_flt *M1  =  V1[0].vector[0].elements.Flt; \
     44    opihi_int *M2  =  V2[0].vector[0].elements.Int; \
     45    opihi_flt *out = OUT[0].vector[0].elements.Flt; \
    5946    for (i = 0; i < Nx; i++, out++, M1++, M2++) { \
    60         *out = *M1 OP *M2; \
     47        *out = OP; \
    6148    } \
    6249    break; \
    6350  } \
    64   if ((M1->type == OPIHI_FLOAT) && (M2->type != OPIHI_FLOAT)) { \
    65     // output must be float, can use M1 as a temp \
    66     opihi_float *M1 = V1[0].vector[0].elements; \
    67     opihi_float *M2 = V2[0].vector[0].elementsInt; \
     51  if ((V1->vector->type != OPIHI_FLT) && (V2->vector->type == OPIHI_FLT)) { \
     52    CopyVector (OUT[0].vector, V2[0].vector); \
     53    opihi_int *M1  =  V1[0].vector[0].elements.Int; \
     54    opihi_flt *M2  =  V2[0].vector[0].elements.Flt; \
     55    opihi_flt *out = OUT[0].vector[0].elements.Flt; \
    6856    for (i = 0; i < Nx; i++, out++, M1++, M2++) { \
    69         *out = *M1 OP *M2; \
     57        *out = OP; \
    7058    } \
    7159    break; \
    7260  } \
    73   if ((M1->type != OPIHI_FLOAT) && (M2->type != OPIHI_FLOAT)) { \
    74     // output may be int, can use either as temp \
    75     opihi_float *M1 = V1[0].vector[0].elementsInt; \
    76     opihi_float *M2 = V2[0].vector[0].elementsInt; \
     61  if ((V1->vector->type != OPIHI_FLT) && (V2->vector->type != OPIHI_FLT)) { \
     62    CopyVector (OUT[0].vector, V1[0].vector); \
     63    opihi_int *M1  =  V1[0].vector[0].elements.Int; \
     64    opihi_int *M2  =  V2[0].vector[0].elements.Int; \
     65    opihi_int *out = OUT[0].vector[0].elements.Int; \
    7766    for (i = 0; i < Nx; i++, out++, M1++, M2++) { \
    78         *out = *M1 OP *M2; \
     67        *out = OP; \
    7968    } \
    8069    break; \
    … …  
    8271
    8372  switch (op[0]) {
    84   case '+':
    85     VV_FUNC
    86 
    87     if ((M1->type == OPIHI_FLOAT) && (M2->type == OPIHI_FLOAT)) {
    88       // output must be float, can use either as a temp
    89       M1 = V1[0].vector[0].elements;
    90       M2 = V2[0].vector[0].elements;
    91       for (i = 0; i < Nx; i++, out++, M1++, M2++) {
    92         *out = *M1 + *M2;
    93       }
    94       break;
    95     }
    96     if ((M1->type != OPIHI_FLOAT) && (M2->type == OPIHI_FLOAT)) {
    97       // output must be float, can use M2 as a temp
    98       M1 = V1[0].vector[0].elementsInt;
    99       M2 = V2[0].vector[0].elements;
    100       for (i = 0; i < Nx; i++, out++, M1++, M2++) {
    101         *out = *M1 + *M2;
    102       }
    103       break;
    104     }
    105     if ((M1->type == OPIHI_FLOAT) && (M2->type != OPIHI_FLOAT)) {
    106       // output must be float, can use M1 as a temp
    107       M1 = V1[0].vector[0].elements;
    108       M2 = V2[0].vector[0].elementsInt;
    109       for (i = 0; i < Nx; i++, out++, M1++, M2++) {
    110         *out = *M1 + *M2;
    111       }
    112       break;
    113     }
    114     if ((M1->type != OPIHI_FLOAT) && (M2->type != OPIHI_FLOAT)) {
    115       // output may be int, can use either as temp
    116       M1 = V1[0].vector[0].elementsInt;
    117       M2 = V2[0].vector[0].elementsInt;
    118       for (i = 0; i < Nx; i++, out++, M1++, M2++) {
    119         *out = *M1 + *M2;
    120       }
    121       break;
    122     }
    123   case '-':
    124     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    125       *out = *M1 - *M2;
    126     break;
    127   case '*':
    128     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    129       *out = *M1 * *M2;
    130     break;
    131   case '/':
    132     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    133       *out = *M1 / *M2;
    134     break;
    135   case '%':
    136     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    137       *out = (int) *M1 % (int) *M2;
    138     break;
    139   case 0x5e:
    140     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    141       *out = pow (*M1, *M2);
    142     break;
    143   case '@':
    144     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    145       *out = DEG_RAD*atan2 (*M1, *M2);
    146     break;
    147   case 'D':
    148     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    149       *out = MIN (*M1, *M2);
    150     break;
    151   case 'U':
    152     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    153       *out = MAX (*M1, *M2);
    154     break;
    155   case '<':
    156     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    157       *out = (*M1 < *M2) ? 1 : 0;
    158     break;
    159   case '>':
    160     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    161       *out = (*M1 > *M2) ? 1 : 0;
    162     break;
    163   case '&':
    164     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    165       *out = ((int)*M1 & (int)*M2);
    166     break;
    167   case '|':
    168     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    169       *out = ((int)*M1 | (int)*M2);
    170     break;
    171   case 'E':
    172     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    173       *out = (*M1 == *M2) ? 1 : 0;
    174     break;
    175   case 'N':
    176     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    177       *out = (*M1 != *M2) ? 1 : 0;
    178     break;
    179   case 'L':
    180     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    181       *out = (*M1 <= *M2) ? 1 : 0;
    182     break;
    183   case 'G':
    184     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    185       *out = (*M1 >= *M2) ? 1 : 0;
    186     break;
    187   case 'A':
    188     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    189       *out = (*M1 && *M2) ? 1 : 0;
    190     break;
    191   case 'O':
    192     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    193       *out = (*M1 || *M2) ? 1 : 0;
    194     break;
     73    case '+': VV_FUNC(*M1 + *M2);
     74    case '-': VV_FUNC(*M1 - *M2);
     75    case '*': VV_FUNC(*M1 * *M2);
     76    case '/': VV_FUNC(*M1 / *M2);
     77    case '%': VV_FUNC((int)*M1 % (int)*M2);
     78    case '^': VV_FUNC(pow (*M1, *M2));
     79    case '@': VV_FUNC(DEG_RAD*atan2 (*M1, *M2));
     80    case 'D': VV_FUNC(MIN (*M1, *M2));
     81    case 'U': VV_FUNC(MAX (*M1, *M2));
     82    case '<': VV_FUNC((*M1 < *M2) ? 1 : 0);
     83    case '>': VV_FUNC((*M1 > *M2) ? 1 : 0);
     84    case '&': VV_FUNC(((int)*M1 & (int)*M2));
     85    case '|': VV_FUNC(((int)*M1 | (int)*M2));
     86    case 'E': VV_FUNC((*M1 == *M2) ? 1 : 0);
     87    case 'N': VV_FUNC((*M1 != *M2) ? 1 : 0);
     88    case 'L': VV_FUNC((*M1 <= *M2) ? 1 : 0);
     89    case 'G': VV_FUNC((*M1 >= *M2) ? 1 : 0);
     90    case 'A': VV_FUNC((*M1 && *M2) ? 1 : 0);
     91    case 'O': VV_FUNC((*M1 || *M2) ? 1 : 0);
    19592  default:
    19693    sprintf (line, "error: op %c not defined!", op[0]);
    … …  
    19895    return (FALSE);
    19996  }
     97# undef VV_FUNC
    20098
    20199  /** free up any temporary buffers: **/
    202100
    203101  if (V1[0].type == 'v') {
    204     free (V1[0].vector[0].elements);
     102    free (V1[0].vector[0].elements.Ptr);
    205103    free (V1[0].vector);
    206104  }
    207105  if (V2[0].type == 'v') {
    208     free (V2[0].vector[0].elements);
     106    free (V2[0].vector[0].elements.Ptr);
    209107    free (V2[0].vector);
    210108  }
    … …  
    220118
    221119  int i, Nx;
    222   float *out, *M1, *M2;
    223120  char line[512]; // this is only used to report an error
    224121 
    … …  
    234131  OUT[0].type = 'v';   /*** <<--- says this is a temporary matrix ***/
    235132
    236   M1  = V1[0].ptr;
    237   M2  = V2[0].ptr;
    238   out = OUT[0].ptr = (float *)OUT[0].vector[0].elements;
     133  opihi_flt  M1  = V1[0].FltValue;
     134  opihi_flt *M2  = V2[0].vector[0].elements.Flt;
     135  opihi_flt *out = OUT[0].vector[0].elements.Flt;
     136
     137# define SV_FUNC(OP) \
     138    for (i = 0; i < Nx; i++, out++, M2++) \
     139      *out = OP; \
     140    break;
    239141
    240142  switch (op[0]) {
    241   case '+':
    242     for (i = 0; i < Nx; i++, out++, M2++)
    243       *out = *M1 + *M2;
    244     break;
    245   case '-':
    246     for (i = 0; i < Nx; i++, out++, M2++)
    247       *out = *M1 - *M2;
    248     break;
    249   case '*':
    250     for (i = 0; i < Nx; i++, out++, M2++)
    251       *out = *M1 * *M2;
    252     break;
    253   case '/':
    254     for (i = 0; i < Nx; i++, out++, M2++)
    255       *out = *M1 / *M2;
    256     break;
    257   case '%':
    258     for (i = 0; i < Nx; i++, out++, M2++)
    259       *out = (int) *M1 % (int) *M2;
    260     break;
    261   case 0x5e:
    262     for (i = 0; i < Nx; i++, out++, M2++)
    263       *out = pow (*M1, *M2);
    264     break;
    265   case '@':
    266     for (i = 0; i < Nx; i++, out++, M2++)
    267       *out = DEG_RAD*atan2 (*M1, *M2);
    268     break;
    269   case 'D':
    270     for (i = 0; i < Nx; i++, out++, M2++)
    271       *out = MIN (*M1, *M2);
    272     break;
    273   case 'U':
    274     for (i = 0; i < Nx; i++, out++, M2++)
    275       *out = MAX (*M1, *M2);
    276     break;
    277   case '<':
    278     for (i = 0; i < Nx; i++, out++, M2++)
    279       *out = (*M1 < *M2) ? 1 : 0;
    280     break;
    281   case '>':
    282     for (i = 0; i < Nx; i++, out++, M2++)
    283       *out = (*M1 > *M2) ? 1 : 0;
    284     break;
    285   case '&':
    286     for (i = 0; i < Nx; i++, out++, M2++)
    287       *out = ((int)*M1 & (int)*M2);
    288     break;
    289   case '|':
    290     for (i = 0; i < Nx; i++, out++, M2++)
    291       *out = ((int)*M1 | (int)*M2);
    292     break;
    293   case 'E':
    294     for (i = 0; i < Nx; i++, out++, M2++)
    295       *out = (*M1 == *M2) ? 1 : 0;
    296     break;
    297   case 'N':
    298     for (i = 0; i < Nx; i++, out++, M2++)
    299       *out = (*M1 != *M2) ? 1 : 0;
    300     break;
    301   case 'L':
    302     for (i = 0; i < Nx; i++, out++, M2++)
    303       *out = (*M1 <= *M2) ? 1 : 0;
    304     break;
    305   case 'G':
    306     for (i = 0; i < Nx; i++, out++, M2++)
    307       *out = (*M1 >= *M2) ? 1 : 0;
    308     break;
    309   case 'A':
    310     for (i = 0; i < Nx; i++, out++, M2++)
    311       *out = (*M1 && *M2) ? 1 : 0;
    312     break;
    313   case 'O':
    314     for (i = 0; i < Nx; i++, out++, M2++)
    315       *out = (*M1 || *M2) ? 1 : 0;
    316     break;
    317   default:
    318     sprintf (line, "error: op %c not defined!", op[0]);
    319     push_error (line);
    320     return (FALSE);
    321   }
     143    case '+': SV_FUNC(M1 + *M2);
     144    case '-': SV_FUNC(M1 - *M2);
     145    case '*': SV_FUNC(M1 * *M2);
     146    case '/': SV_FUNC(M1 / *M2);
     147    case '%': SV_FUNC((int) M1 % (int) *M2);
     148    case '^': SV_FUNC(pow (M1, *M2));
     149    case '@': SV_FUNC(DEG_RAD*atan2 (M1, *M2));
     150    case 'D': SV_FUNC(MIN (M1, *M2));
     151    case 'U': SV_FUNC(MAX (M1, *M2));
     152    case '<': SV_FUNC((M1 < *M2) ? 1 : 0);
     153    case '>': SV_FUNC((M1 > *M2) ? 1 : 0);
     154    case '&': SV_FUNC(((int)M1 & (int)*M2));
     155    case '|': SV_FUNC(((int)M1 | (int)*M2));
     156    case 'E': SV_FUNC((M1 == *M2) ? 1 : 0);
     157    case 'N': SV_FUNC((M1 != *M2) ? 1 : 0);
     158    case 'L': SV_FUNC((M1 <= *M2) ? 1 : 0);
     159    case 'G': SV_FUNC((M1 >= *M2) ? 1 : 0);
     160    case 'A': SV_FUNC((M1 && *M2) ? 1 : 0);
     161    case 'O': SV_FUNC((M1 || *M2) ? 1 : 0);
     162    default:
     163      sprintf (line, "error: op %c not defined!", op[0]);
     164      push_error (line);
     165      return (FALSE);
     166  }
     167# undef SV_FUNC
    322168
    323169  /** free up any temporary buffers: **/
    324170  if (V2[0].type == 'v') {
    325     free (V2[0].vector[0].elements);
     171    free (V2[0].vector[0].elements.Ptr);
    326172    free (V2[0].vector);
    327173  }
    … …  
    338184
    339185  int i, Nx;
    340   float *out, *M1, *M2;
    341186  char line[512]; // this is only used to report an error
    342187 
    … …  
    352197  OUT[0].type = 'v';   /*** <<--- says this is a temporary matrix ***/
    353198
    354   M1  = V1[0].ptr;
    355   M2  = V2[0].ptr;
    356   out = OUT[0].ptr = (float *)OUT[0].vector[0].elements;
     199  opihi_flt *M1  = V1[0].vector[0].elements.Flt;
     200  opihi_flt  M2  = V2[0].FltValue;
     201  opihi_flt *out = OUT[0].vector[0].elements.Flt;
     202
     203# define VS_FUNC(OP) \
     204    for (i = 0; i < Nx; i++, out++, M1++) \
     205      *out = OP; \
     206    break;
    357207
    358208  switch (op[0]) {
    359   case '+':
    360     for (i = 0; i < Nx; i++, out++, M1++)
    361       *out = *M1 + *M2;
    362     break;
    363   case '-':
    364     for (i = 0; i < Nx; i++, out++, M1++)
    365       *out = *M1 - *M2;
    366     break;
    367   case '*':
    368     for (i = 0; i < Nx; i++, out++, M1++)
    369       *out = *M1 * *M2;
    370     break;
    371   case '/':
    372     for (i = 0; i < Nx; i++, out++, M1++)
    373       *out = *M1 / *M2;
    374     break;
    375   case '%':
    376     for (i = 0; i < Nx; i++, out++, M1++)
    377       *out = (int) *M1 % (int) *M2;
    378     break;
    379   case 0x5e:
    380     for (i = 0; i < Nx; i++, out++, M1++)
    381       *out = pow (*M1, *M2);
    382     break;
    383   case '@':
    384     for (i = 0; i < Nx; i++, out++, M1++)
    385       *out = DEG_RAD*atan2 (*M1, *M2);
    386     break;
    387   case 'D':
    388     for (i = 0; i < Nx; i++, out++, M1++)
    389       *out = MIN (*M1, *M2);
    390     break;
    391   case 'U':
    392     for (i = 0; i < Nx; i++, out++, M1++)
    393       *out = MAX (*M1, *M2);
    394     break;
    395   case '<':
    396     for (i = 0; i < Nx; i++, out++, M1++)
    397       *out = (*M1 < *M2) ? 1 : 0;
    398     break;
    399   case '>':
    400     for (i = 0; i < Nx; i++, out++, M1++)
    401       *out = (*M1 > *M2) ? 1 : 0;
    402     break;
    403   case '&':
    404     for (i = 0; i < Nx; i++, out++, M1++)
    405       *out = ((int)*M1 & (int)*M2);
    406     break;
    407   case '|':
    408     for (i = 0; i < Nx; i++, out++, M1++)
    409       *out = ((int)*M1 | (int)*M2);
    410     break;
    411   case 'E':
    412     for (i = 0; i < Nx; i++, out++, M1++)
    413       *out = (*M1 == *M2) ? 1 : 0;
    414     break;
    415   case 'N':
    416     for (i = 0; i < Nx; i++, out++, M1++)
    417       *out = (*M1 != *M2) ? 1 : 0;
    418     break;
    419   case 'L':
    420     for (i = 0; i < Nx; i++, out++, M1++)
    421       *out = (*M1 <= *M2) ? 1 : 0;
    422     break;
    423   case 'G':
    424     for (i = 0; i < Nx; i++, out++, M1++)
    425       *out = (*M1 >= *M2) ? 1 : 0;
    426     break;
    427   case 'A':
    428     for (i = 0; i < Nx; i++, out++, M1++)
    429       *out = (*M1 && *M2) ? 1 : 0;
    430     break;
    431   case 'O':
    432     for (i = 0; i < Nx; i++, out++, M1++)
    433       *out = (*M1 || *M2) ? 1 : 0;
    434     break;
    435   default:
    436     sprintf (line, "error: op %c not defined!", op[0]);
    437     push_error (line);
    438     return (FALSE);
    439   }
     209    case '+': VS_FUNC(*M1 + M2);
     210    case '-': VS_FUNC(*M1 - M2);
     211    case '*': VS_FUNC(*M1 * M2);
     212    case '/': VS_FUNC(*M1 / M2);
     213    case '%': VS_FUNC((int) *M1 % (int) M2);
     214    case '^': VS_FUNC(pow (*M1, M2));
     215    case '@': VS_FUNC(DEG_RAD*atan2 (*M1, M2));
     216    case 'D': VS_FUNC(MIN (*M1, M2));
     217    case 'U': VS_FUNC(MAX (*M1, M2));
     218    case '<': VS_FUNC((*M1 < M2) ? 1 : 0);
     219    case '>': VS_FUNC((*M1 > M2) ? 1 : 0);
     220    case '&': VS_FUNC(((int)*M1 & (int)M2));
     221    case '|': VS_FUNC(((int)*M1 | (int)M2));
     222    case 'E': VS_FUNC((*M1 == M2) ? 1 : 0);
     223    case 'N': VS_FUNC((*M1 != M2) ? 1 : 0);
     224    case 'L': VS_FUNC((*M1 <= M2) ? 1 : 0);
     225    case 'G': VS_FUNC((*M1 >= M2) ? 1 : 0);
     226    case 'A': VS_FUNC((*M1 && M2) ? 1 : 0);
     227    case 'O': VS_FUNC((*M1 || M2) ? 1 : 0);
     228    default:
     229      sprintf (line, "error: op %c not defined!", op[0]);
     230      push_error (line);
     231      return (FALSE);
     232  }
     233# undef VS_FUNC
    440234
    441235  /** free up any temporary buffers: **/
    442236
    443237  if (V1[0].type == 'v') {
    444     free (V1[0].vector[0].elements);
     238    free (V1[0].vector[0].elements.Ptr);
    445239    free (V1[0].vector);
    446240  }
    … …  
    454248}
    455249
     250// the vector is applied to each column
    456251int MV_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) {
    457252
    458253  int i, j, Nx, Ny;
    459   float *out, *M1, *M2;
    460254  char line[512]; // this is only used to report an error
    461255 
    … …  
    478272  OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/
    479273
    480   M1  = V1[0].ptr;
    481   M2  = V2[0].ptr;
    482   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     274  float     *M1  = (float *) V1[0].buffer[0].matrix.buffer;
     275  opihi_flt *M2  = V2[0].vector[0].elements.Flt;
     276  float     *out = (float *)OUT[0].buffer[0].matrix.buffer;
     277
     278# define MV_FUNC(OP) \
     279    for (i = 0; i < Ny; i++, M2++) { \
     280      for (j = 0; j < Nx; j++, out++, M1++) { \
     281        *out = OP; \
     282      } \
     283    } \
     284    break;
    483285
    484286  switch (op[0]) {
    485   case '+':
    486     for (i = 0; i < Ny; i++, M2++) {
    487       for (j = 0; j < Nx; j++, out++, M1++)
    488         *out = *M1 + *M2;
    489     }
    490     break;
    491   case '-':
    492     for (i = 0; i < Ny; i++, M2++) {
    493       for (j = 0; j < Nx; j++, out++, M1++)
    494         *out = *M1 - *M2;
    495     }
    496     break;
    497   case '*':
    498     for (i = 0; i < Ny; i++, M2++) {
    499       for (j = 0; j < Nx; j++, out++, M1++)
    500         *out = *M1 * *M2;
    501     }
    502     break;
    503   case '/':
    504     for (i = 0; i < Ny; i++, M2++) {
    505       for (j = 0; j < Nx; j++, out++, M1++)
    506         *out = *M1 / *M2;
    507     }
    508     break;
    509   case '%':
    510     for (i = 0; i < Ny; i++, M2++) {
    511       for (j = 0; j < Nx; j++, out++, M1++)
    512         *out = (int) *M1 % (int) *M2;
    513     }
    514     break;
    515   case 0x5e:
    516     for (i = 0; i < Ny; i++, M2++) {
    517       for (j = 0; j < Nx; j++, out++, M1++)
    518         *out = pow (*M1, *M2);
    519     }
    520     break;
    521   case '@':
    522     for (i = 0; i < Ny; i++, M2++) {
    523       for (j = 0; j < Nx; j++, out++, M1++)
    524         *out = DEG_RAD*atan2 (*M1, *M2);
    525     }
    526     break;
    527   case 'D':
    528     for (i = 0; i < Ny; i++, M2++) {
    529       for (j = 0; j < Nx; j++, out++, M1++)
    530         *out = MIN (*M1, *M2);
    531     }
    532     break;
    533   case 'U':
    534     for (i = 0; i < Ny; i++, M2++) {
    535       for (j = 0; j < Nx; j++, out++, M1++)
    536         *out = MAX (*M1, *M2);
    537     }
    538     break;
    539   case '<':
    540     for (i = 0; i < Ny; i++, M2++) {
    541       for (j = 0; j < Nx; j++, out++, M1++)
    542         *out = (*M1 < *M2) ? 1 : 0;
    543     }
    544     break;
    545   case '>':
    546     for (i = 0; i < Ny; i++, M2++) {
    547       for (j = 0; j < Nx; j++, out++, M1++)
    548         *out = (*M1 > *M2) ? 1 : 0;
    549     }
    550     break;
    551   case '&':
    552     for (i = 0; i < Ny; i++, M2++) {
    553       for (j = 0; j < Nx; j++, out++, M1++)
    554         *out = ((int)*M1 & (int)*M2);
    555     }
    556     break;
    557   case '|':
    558     for (i = 0; i < Ny; i++, M2++) {
    559       for (j = 0; j < Nx; j++, out++, M1++)
    560         *out = ((int)*M1 | (int)*M2);
    561     }
    562     break;
    563   case 'E':
    564     for (i = 0; i < Ny; i++, M2++) {
    565       for (j = 0; j < Nx; j++, out++, M1++)
    566         *out = (*M1 == *M2) ? 1 : 0;
    567     }
    568     break;
    569   case 'N':
    570     for (i = 0; i < Ny; i++, M2++) {
    571       for (j = 0; j < Nx; j++, out++, M1++)
    572         *out = (*M1 != *M2) ? 1 : 0;
    573     }
    574     break;
    575   case 'L':
    576     for (i = 0; i < Ny; i++, M2++) {
    577       for (j = 0; j < Nx; j++, out++, M1++)
    578         *out = (*M1 <= *M2) ? 1 : 0;
    579     }
    580     break;
    581   case 'G':
    582     for (i = 0; i < Ny; i++, M2++) {
    583       for (j = 0; j < Nx; j++, out++, M1++)
    584         *out = (*M1 >= *M2) ? 1 : 0;
    585     }
    586     break;
    587   case 'A':
    588     for (i = 0; i < Ny; i++, M2++) {
    589       for (j = 0; j < Nx; j++, out++, M1++)
    590         *out = (*M1 && *M2) ? 1 : 0;
    591     }
    592     break;
    593   case 'O':
    594     for (i = 0; i < Ny; i++, M2++) {
    595       for (j = 0; j < Nx; j++, out++, M1++)
    596         *out = (*M1 || *M2) ? 1 : 0;
    597     }
    598     break;
    599   default:
    600     sprintf (line, "error: op %c not defined!", op[0]);
    601     push_error (line);
    602     return (FALSE);
     287    case '+': MV_FUNC(*M1 + *M2);
     288    case '-': MV_FUNC(*M1 - *M2);
     289    case '*': MV_FUNC(*M1 * *M2);
     290    case '/': MV_FUNC(*M1 / *M2);
     291    case '%': MV_FUNC((int) *M1 % (int) *M2);
     292    case '^': MV_FUNC(pow (*M1, *M2));
     293    case '@': MV_FUNC(DEG_RAD*atan2 (*M1, *M2));
     294    case 'D': MV_FUNC(MIN (*M1, *M2));
     295    case 'U': MV_FUNC(MAX (*M1, *M2));
     296    case '<': MV_FUNC((*M1 < *M2) ? 1 : 0);
     297    case '>': MV_FUNC((*M1 > *M2) ? 1 : 0);
     298    case '&': MV_FUNC(((int)*M1 & (int)*M2));
     299    case '|': MV_FUNC(((int)*M1 | (int)*M2));
     300    case 'E': MV_FUNC((*M1 == *M2) ? 1 : 0);
     301    case 'N': MV_FUNC((*M1 != *M2) ? 1 : 0);
     302    case 'L': MV_FUNC((*M1 <= *M2) ? 1 : 0);
     303    case 'G': MV_FUNC((*M1 >= *M2) ? 1 : 0);
     304    case 'A': MV_FUNC((*M1 && *M2) ? 1 : 0);
     305    case 'O': MV_FUNC((*M1 || *M2) ? 1 : 0);
     306    default:
     307      sprintf (line, "error: op %c not defined!", op[0]);
     308      push_error (line);
     309      return (FALSE);
    603310  }
    604311
    … …  
    611318  }
    612319  if (V2[0].type == 'v') {
    613     free (V2[0].vector[0].elements);
     320    free (V2[0].vector[0].elements.Ptr);
    614321    free (V2[0].vector);
    615322  }
    … …  
    620327  /* at the end, V1 and V2 are deleted only if they were temporary */
    621328  return (TRUE);
    622 
    623 }
    624 
    625 
     329}
     330
     331// the vector is applied to each row
    626332int VM_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) {
    627333
    628334  int i, j, Nx, Ny;
    629   float *out, *M1, *M2;
    630335  char line[512]; // this is only used to report an error
    631336 
    … …  
    646351  OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/
    647352
    648   M1  = V1[0].ptr;
    649   M2  = V2[0].ptr;
    650   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     353  opihi_flt *M1  = V1[0].vector[0].elements.Flt;
     354  float     *M2  = (float *) V2[0].buffer[0].matrix.buffer;
     355  float     *out = (float *)OUT[0].buffer[0].matrix.buffer;
     356
     357# define VM_FUNC(OP) \
     358    for (i = 0; i < Ny; i++) { \
     359      M1  = V1[0].vector[0].elements.Flt; \
     360      for (j = 0; j < Nx; j++, out++, M1++, M2++) { \
     361        *out = OP; \
     362      } \
     363    } \
     364    break;
    651365
    652366  switch (op[0]) {
    653   case '+':
    654     for (i = 0; i < Ny; i++) {
    655       M1 = V1[0].ptr;
    656       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    657         *out = *M1 + *M2;
    658     }
    659     break;
    660   case '-':
    661     for (i = 0; i < Ny; i++) {
    662       M1 = V1[0].ptr;
    663       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    664         *out = *M1 - *M2;
    665     }
    666     break;
    667   case '*':
    668     for (i = 0; i < Ny; i++) {
    669       M1 = V1[0].ptr;
    670       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    671         *out = *M1 * *M2;
    672     }
    673     break;
    674   case '/':
    675     for (i = 0; i < Ny; i++) {
    676       M1 = V1[0].ptr;
    677       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    678         *out = *M1 / *M2;
    679     }
    680     break;
    681   case '%':
    682     for (i = 0; i < Ny; i++) {
    683       M1 = V1[0].ptr;
    684       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    685         *out = (int) *M1 % (int) *M2;
    686     }
    687     break;
    688   case 0x5e:
    689     for (i = 0; i < Ny; i++) {
    690       M1 = V1[0].ptr;
    691       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    692         *out = pow (*M1, *M2);
    693     }
    694     break;
    695   case '@':
    696     for (i = 0; i < Ny; i++) {
    697       M1 = V1[0].ptr;
    698       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    699         *out = DEG_RAD*atan2 (*M1, *M2);
    700     }
    701     break;
    702   case 'D':
    703     for (i = 0; i < Ny; i++) {
    704       M1 = V1[0].ptr;
    705       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    706         *out = MIN (*M1, *M2);
    707     }
    708     break;
    709   case 'U':
    710     for (i = 0; i < Ny; i++) {
    711       M1 = V1[0].ptr;
    712       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    713         *out = MAX (*M1, *M2);
    714     }
    715     break;
    716   case '<':
    717     for (i = 0; i < Ny; i++) {
    718       M1 = V1[0].ptr;
    719       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    720         *out = (*M1 < *M2) ? 1 : 0;
    721     }
    722     break;
    723   case '>':
    724     for (i = 0; i < Ny; i++) {
    725       M1 = V1[0].ptr;
    726       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    727         *out = (*M1 > *M2) ? 1 : 0;
    728     }
    729     break;
    730   case '&':
    731     for (i = 0; i < Ny; i++) {
    732       M1 = V1[0].ptr;
    733       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    734         *out = ((int)*M1 & (int)*M2);
    735     }
    736     break;
    737   case '|':
    738     for (i = 0; i < Ny; i++) {
    739       M1 = V1[0].ptr;
    740       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    741         *out = ((int)*M1 | (int)*M2);
    742     }
    743     break;
    744   case 'E':
    745     for (i = 0; i < Ny; i++) {
    746       M1 = V1[0].ptr;
    747       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    748         *out = (*M1 == *M2) ? 1 : 0;
    749     }
    750     break;
    751   case 'N':
    752     for (i = 0; i < Ny; i++) {
    753       M1 = V1[0].ptr;
    754       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    755         *out = (*M1 != *M2) ? 1 : 0;
    756     }
    757     break;
    758   case 'L':
    759     for (i = 0; i < Ny; i++) {
    760       M1 = V1[0].ptr;
    761       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    762         *out = (*M1 <= *M2) ? 1 : 0;
    763     }
    764     break;
    765   case 'G':
    766     for (i = 0; i < Ny; i++) {
    767       M1 = V1[0].ptr;
    768       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    769         *out = (*M1 >= *M2) ? 1 : 0;
    770     }
    771     break;
    772   case 'A':
    773     for (i = 0; i < Ny; i++) {
    774       M1 = V1[0].ptr;
    775       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    776         *out = (*M1 && *M2) ? 1 : 0;
    777     }
    778     break;
    779   case 'O':
    780     for (i = 0; i < Ny; i++) {
    781       M1 = V1[0].ptr;
    782       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    783         *out = (*M1 || *M2) ? 1 : 0;
    784     }
    785     break;
    786   default:
    787     sprintf (line, "error: op %c not defined!", op[0]);
    788     push_error (line);
    789     return (FALSE);
     367    case '+': VM_FUNC(*M1 + *M2);
     368    case '-': VM_FUNC(*M1 - *M2);
     369    case '*': VM_FUNC(*M1 * *M2);
     370    case '/': VM_FUNC(*M1 / *M2);
     371    case '%': VM_FUNC((int) *M1 % (int) *M2);
     372    case '^': VM_FUNC(pow (*M1, *M2));
     373    case '@': VM_FUNC(DEG_RAD*atan2 (*M1, *M2));
     374    case 'D': VM_FUNC(MIN (*M1, *M2));
     375    case 'U': VM_FUNC(MAX (*M1, *M2));
     376    case '<': VM_FUNC((*M1 < *M2) ? 1 : 0);
     377    case '>': VM_FUNC((*M1 > *M2) ? 1 : 0);
     378    case '&': VM_FUNC(((int)*M1 & (int)*M2));
     379    case '|': VM_FUNC(((int)*M1 | (int)*M2));
     380    case 'E': VM_FUNC((*M1 == *M2) ? 1 : 0);
     381    case 'N': VM_FUNC((*M1 != *M2) ? 1 : 0);
     382    case 'L': VM_FUNC((*M1 <= *M2) ? 1 : 0);
     383    case 'G': VM_FUNC((*M1 >= *M2) ? 1 : 0);
     384    case 'A': VM_FUNC((*M1 && *M2) ? 1 : 0);
     385    case 'O': VM_FUNC((*M1 || *M2) ? 1 : 0);
     386    default:
     387      sprintf (line, "error: op %c not defined!", op[0]);
     388      push_error (line);
     389      return (FALSE);
    790390  }
    791391
    … …  
    793393
    794394  if (V1[0].type == 'v') {
    795     free (V1[0].vector[0].elements);
     395    free (V1[0].vector[0].elements.Ptr);
    796396    free (V1[0].vector);
    797397  }
    … …  
    833433  OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/
    834434
    835   M1  = V1[0].ptr;
    836   M2  = V2[0].ptr;
    837   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     435  M1  = (float *)V1[0].buffer[0].matrix.buffer;
     436  M2  = (float *)V2[0].buffer[0].matrix.buffer;
     437  out = (float *)OUT[0].buffer[0].matrix.buffer;
    838438
    839439  switch (op[0]) {
    … …  
    945545
    946546  int i, Nx, Ny;
    947   float *out, *M1, *M2;
     547  float *out, *M1;
     548  opihi_flt M2;
    948549  char line[512]; // this is only used to report an error
    949550 
    … …  
    961562  OUT[0].type = 'm';      /*** <<--- says this is a temporary matrix ***/
    962563
    963   M1  = V1[0].ptr;
    964   M2  = V2[0].ptr;
    965   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     564  M1  = (float *)V1[0].buffer[0].matrix.buffer;
     565  M2  = V2[0].FltValue;
     566  out = (float *)OUT[0].buffer[0].matrix.buffer;
    966567
    967568  switch (op[0]) {
    968569  case '+':
    969570    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    970       *out = *M1 + *M2;
     571      *out = *M1 + M2;
    971572    break;
    972573  case '-':
    973574    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    974       *out = *M1 - *M2;
     575      *out = *M1 - M2;
    975576    break;
    976577  case '*':
    977578    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    978       *out = *M1 * *M2;
     579      *out = *M1 * M2;
    979580    break;
    980581  case '/':
    981582    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    982       *out = *M1 / *M2;
     583      *out = *M1 / M2;
    983584    break;
    984585  case '%':
    985586    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    986       *out = (int) *M1 % (int) *M2;
     587      *out = (int) *M1 % (int) M2;
    987588    break;
    988589  case 0x5e:
    989590    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    990       *out = pow (*M1, *M2);
     591      *out = pow (*M1, M2);
    991592    break;
    992593  case '@':
    993594    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    994       *out = DEG_RAD*atan2 (*M1, *M2);
     595      *out = DEG_RAD*atan2 (*M1, M2);
    995596    break;
    996597  case 'D':
    997598    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    998       *out = MIN (*M1, *M2);
     599      *out = MIN (*M1, M2);
    999600    break;
    1000601  case 'U':
    1001602    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1002       *out = MAX (*M1, *M2);
     603      *out = MAX (*M1, M2);
    1003604    break;
    1004605  case '<':
    1005606    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1006       *out = (*M1 < *M2) ? 1 : 0;
     607      *out = (*M1 < M2) ? 1 : 0;
    1007608    break;
    1008609  case '>':
    1009610    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1010       *out = (*M1 > *M2) ? 1 : 0;
     611      *out = (*M1 > M2) ? 1 : 0;
    1011612    break;
    1012613  case '&':
    1013614    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1014       *out = ((int)*M1 & (int)*M2);
     615      *out = ((int)*M1 & (int)M2);
    1015616    break;
    1016617  case '|':
    1017618    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1018       *out = ((int)*M1 | (int)*M2);
     619      *out = ((int)*M1 | (int)M2);
    1019620    break;
    1020621  case 'E':
    1021622    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1022       *out = (*M1 == *M2) ? 1 : 0;
     623      *out = (*M1 == M2) ? 1 : 0;
    1023624    break;
    1024625  case 'N':
    1025626    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1026       *out = (*M1 != *M2) ? 1 : 0;
     627      *out = (*M1 != M2) ? 1 : 0;
    1027628    break;
    1028629  case 'L':
    1029630    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1030       *out = (*M1 <= *M2) ? 1 : 0;
     631      *out = (*M1 <= M2) ? 1 : 0;
    1031632    break;
    1032633  case 'G':
    1033634    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1034       *out = (*M1 >= *M2) ? 1 : 0;
     635      *out = (*M1 >= M2) ? 1 : 0;
    1035636    break;
    1036637  case 'A':
    1037638    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1038       *out = (*M1 && *M2) ? 1 : 0;
     639      *out = (*M1 && M2) ? 1 : 0;
    1039640    break;
    1040641  case 'O':
    1041642    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1042       *out = (*M1 || *M2) ? 1 : 0;
     643      *out = (*M1 || M2) ? 1 : 0;
    1043644    break;
    1044645  default:
    … …  
    1064665
    1065666  int i, Nx, Ny;
    1066   float *out, *M1, *M2;
     667  float *out, *M2;
     668  opihi_flt M1;
    1067669  char line[512]; // this is only used to report an error
    1068670 
    … …  
    1079681  OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/
    1080682
    1081   M1  = V1[0].ptr;
    1082   M2  = V2[0].ptr;
    1083   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     683  M1  = V1[0].FltValue;
     684  M2  = (float *)OUT[0].buffer[0].matrix.buffer;
     685  out = (float *)OUT[0].buffer[0].matrix.buffer;
    1084686
    1085687  switch (op[0]) {
    1086688  case '+':
    1087689    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1088       *out = *M1 + *M2;
     690      *out = M1 + *M2;
    1089691    break;
    1090692  case '-':
    1091693    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1092       *out = *M1 - *M2;
     694      *out = M1 - *M2;
    1093695    break;
    1094696  case '*':
    1095697    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1096       *out = *M1 * *M2;
     698      *out = M1 * *M2;
    1097699    break;
    1098700  case '/':
    1099701    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1100       *out = *M1 / *M2;
     702      *out = M1 / *M2;
    1101703    break;
    1102704  case '%':
    1103705    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1104       *out = (int) *M1 % (int) *M2;
     706      *out = (int) M1 % (int) *M2;
    1105707    break;
    1106708  case 0x5e:
    1107709    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1108       *out = pow (*M1, *M2);
     710      *out = pow (M1, *M2);
    1109711    break;
    1110712  case '@':
    1111713    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1112       *out = DEG_RAD*atan2 (*M1, *M2);
     714      *out = DEG_RAD*atan2 (M1, *M2);
    1113715    break;
    1114716  case 'D':
    1115717    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1116       *out = MIN (*M1, *M2);
     718      *out = MIN (M1, *M2);
    1117719    break;
    1118720  case 'U':
    1119721    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1120       *out = MAX (*M1, *M2);
     722      *out = MAX (M1, *M2);
    1121723    break;
    1122724  case '<':
    1123725    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1124       *out = (*M1 < *M2) ? 1 : 0;
     726      *out = (M1 < *M2) ? 1 : 0;
    1125727    break;
    1126728  case '>':
    1127729    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1128       *out = (*M1 > *M2) ? 1 : 0;
     730      *out = (M1 > *M2) ? 1 : 0;
    1129731    break;
    1130732  case '&':
    1131733    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1132       *out = ((int)*M1 & (int)*M2);
     734      *out = ((int)M1 & (int)*M2);
    1133735    break;
    1134736  case '|':
    1135737    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1136       *out = ((int)*M1 | (int)*M2);
     738      *out = ((int)M1 | (int)*M2);
    1137739    break;
    1138740  case 'E':
    1139741    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1140       *out = (*M1 == *M2) ? 1 : 0;
     742      *out = (M1 == *M2) ? 1 : 0;
    1141743    break;
    1142744  case 'N':
    1143745    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1144       *out = (*M1 != *M2) ? 1 : 0;
     746      *out = (M1 != *M2) ? 1 : 0;
    1145747    break;
    1146748  case 'L':
    1147749    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1148       *out = (*M1 <= *M2) ? 1 : 0;
     750      *out = (M1 <= *M2) ? 1 : 0;
    1149751    break;
    1150752  case 'G':
    1151753    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1152       *out = (*M1 >= *M2) ? 1 : 0;
     754      *out = (M1 >= *M2) ? 1 : 0;
    1153755    break;
    1154756  case 'A':
    1155757    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1156       *out = (*M1 && *M2) ? 1 : 0;
     758      *out = (M1 && *M2) ? 1 : 0;
    1157759    break;
    1158760  case 'O':
    1159761    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1160       *out = (*M1 || *M2) ? 1 : 0;
     762      *out = (M1 || *M2) ? 1 : 0;
    1161763    break;
    1162764  default:
    … …  
    1181783int SS_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) {
    1182784
    1183   float *M1, *M2, *out;
     785  opihi_flt M1, M2;
    1184786  char line[512]; // this is only used to report an error
    1185787
    1186   M1  = V1[0].ptr;
    1187   M2  = V2[0].ptr;
    1188   OUT[0].ptr = V1[0].ptr;
    1189   out = OUT[0].ptr;
    1190 
     788  M1 = V1[0].FltValue;
     789  M2 = V2[0].FltValue;
     790  OUT[0].type = 'S';
    1191791
    1192792  switch (op[0]) {
    1193793  case '+':
    1194     *out = *M1 + *M2;
     794    OUT[0].FltValue = M1 + M2;
    1195795    break;   
    1196796  case '-':
    1197     *out = *M1 - *M2;
     797    OUT[0].FltValue = M1 - M2;
    1198798    break;   
    1199799  case '*':
    1200     *out = *M1 * *M2;
     800    OUT[0].FltValue = M1 * M2;
    1201801    break;   
    1202802  case '/':
    1203     *out = *M1 / *M2;
     803    OUT[0].FltValue = M1 / M2;
    1204804    break;
    1205805  case '%':
    1206     *out = (int) *M1 % (int) *M2;
     806    OUT[0].FltValue = (int) M1 % (int) M2;
    1207807    break;
    1208808  case 0x5e:
    1209     *out = pow (*M1, *M2);
     809    OUT[0].FltValue = pow (M1, M2);
    1210810    break;
    1211811  case '@':
    1212     *out = DEG_RAD*atan2 (*M1, *M2);
     812    OUT[0].FltValue = DEG_RAD*atan2 (M1, M2);
    1213813    break;
    1214814  case 'D':
    1215     *out = MIN (*M1, *M2);
     815    OUT[0].FltValue = MIN (M1, M2);
    1216816    break;
    1217817  case 'U':
    1218     *out = MAX (*M1, *M2);
     818    OUT[0].FltValue = MAX (M1, M2);
    1219819    break;
    1220820  case '<':
    1221     *out = (*M1 < *M2) ? 1 : 0;
     821    OUT[0].FltValue = (M1 < M2) ? 1 : 0;
    1222822    break;
    1223823  case '>':
    1224     *out = (*M1 > *M2) ? 1 : 0;
     824    OUT[0].FltValue = (M1 > M2) ? 1 : 0;
    1225825    break;
    1226826  case '&':
    1227     *out = ((int)*M1 & (int)*M2);
     827    OUT[0].FltValue = ((int)M1 & (int)M2);
    1228828    break;
    1229829  case '|':
    1230     *out = ((int)*M1 | (int)*M2);
     830    OUT[0].FltValue = ((int)M1 | (int)M2);
    1231831    break;
    1232832  case 'E':
    1233     *out = (*M1 == *M2) ? 1 : 0;
     833    OUT[0].FltValue = (M1 == M2) ? 1 : 0;
    1234834    break;
    1235835  case 'N':
    1236     *out = (*M1 != *M2) ? 1 : 0;
     836    OUT[0].FltValue = (M1 != M2) ? 1 : 0;
    1237837    break;
    1238838  case 'L':
    1239     *out = (*M1 <= *M2) ? 1 : 0;
     839    OUT[0].FltValue = (M1 <= M2) ? 1 : 0;
    1240840    break;
    1241841  case 'G':
    1242     *out = (*M1 >= *M2) ? 1 : 0;
     842    OUT[0].FltValue = (M1 >= M2) ? 1 : 0;
    1243843    break;
    1244844  case 'A':
    1245     *out = (*M1 && *M2) ? 1 : 0;
     845    OUT[0].FltValue = (M1 && M2) ? 1 : 0;
    1246846    break;
    1247847  case 'O':
    1248     *out = (*M1 || *M2) ? 1 : 0;
     848    OUT[0].FltValue = (M1 || M2) ? 1 : 0;
    1249849    break;
    1250850  default:
    … …  
    1253853    return (FALSE);
    1254854  }
    1255   OUT[0].Float = *(OUT[0].ptr);
    1256   OUT[0].type = 'S';
    1257855
    1258856  clear_stack (V1);
    … …  
    1304902
    1305903escape:
    1306   OUT[0].Float = value;
     904  OUT[0].FltValue = value;
    1307905  OUT[0].type = 'S';
    1308   OUT[0].ptr = &OUT[0].Float;
    1309906
    1310907  clear_stack (V1);
    … …  
    1317914int S_unary (StackVar *OUT, StackVar *V1, char *op) {
    1318915
    1319   float *out, *M1;
     916  opihi_flt M1;
    1320917 
    1321   out = OUT[0].ptr = V1[0].ptr;
    1322   M1  = V1[0].ptr;
     918  M1  = V1[0].FltValue;
     919  OUT[0].type = 'S';
    1323920
    1324921  if (!strcmp (op, "="))     {    }
    1325   if (!strcmp (op, "abs"))   {    *out = fabs(*M1);           }
    1326   if (!strcmp (op, "int"))   {    *out = (float)(int)(*M1);   }
    1327   if (!strcmp (op, "exp"))   {    *out = exp (*M1);           }
    1328   if (!strcmp (op, "ten"))   {    *out = pow (10.0,*M1);      }
    1329   if (!strcmp (op, "log"))   {    *out = log10 (*M1);         }
    1330   if (!strcmp (op, "ln"))    {    *out = log (*M1);           }
    1331   if (!strcmp (op, "sqrt"))  {    *out = sqrt (*M1);          }
    1332   if (!strcmp (op, "erf"))   {    *out = erf (*M1);           }
    1333 
    1334   if (!strcmp (op, "sinh"))  {    *out = sinh (*M1);          }
    1335   if (!strcmp (op, "cosh"))  {    *out = cosh (*M1);          }
    1336   if (!strcmp (op, "asinh")) {    *out = asinh (*M1);         }
    1337   if (!strcmp (op, "acosh")) {    *out = acosh (*M1);         }
    1338   if (!strcmp (op, "lgamma")) {   *out = lgamma (*M1);        }
    1339 
    1340   if (!strcmp (op, "sin"))   {    *out = sin (*M1);           }
    1341   if (!strcmp (op, "cos"))   {    *out = cos (*M1);           }
    1342   if (!strcmp (op, "tan"))   {    *out = tan (*M1);           }
    1343   if (!strcmp (op, "dsin"))  {    *out = sin (*M1*RAD_DEG);   }
    1344   if (!strcmp (op, "dcos"))  {    *out = cos (*M1*RAD_DEG);   }
    1345   if (!strcmp (op, "dtan"))  {    *out = tan (*M1*RAD_DEG);   }
    1346   if (!strcmp (op, "asin"))  {    *out = asin (*M1);          }
    1347   if (!strcmp (op, "acos"))  {    *out = acos (*M1);          }
    1348   if (!strcmp (op, "atan"))  {    *out = atan (*M1);          }
    1349   if (!strcmp (op, "dasin")) {    *out = asin (*M1)*DEG_RAD;  }
    1350   if (!strcmp (op, "dacos")) {    *out = acos (*M1)*DEG_RAD;  }
    1351   if (!strcmp (op, "datan")) {    *out = atan (*M1)*DEG_RAD;  }
    1352   if (!strcmp (op, "rnd"))   {    *out = drand48();           }
    1353   if (!strcmp (op, "not"))   {    *out = !(*M1);              }
    1354   if (!strcmp (op, "--"))    {    *out = - (*M1);             }
    1355   if (!strcmp (op, "isinf")) {    *out = !finite(*M1);        }
    1356   if (!strcmp (op, "isnan")) {    *out = isnan(*M1);          }
    1357 
    1358   OUT[0].Float = *out;
    1359   OUT[0].type = 'S';
     922  if (!strcmp (op, "abs"))   {    OUT[0].FltValue = fabs(M1);           }
     923  if (!strcmp (op, "int"))   {    OUT[0].FltValue = (float)(int)(M1);   }
     924  if (!strcmp (op, "exp"))   {    OUT[0].FltValue = exp (M1);           }
     925  if (!strcmp (op, "ten"))   {    OUT[0].FltValue = pow (10.0,M1);      }
     926  if (!strcmp (op, "log"))   {    OUT[0].FltValue = log10 (M1);         }
     927  if (!strcmp (op, "ln"))    {    OUT[0].FltValue = log (M1);           }
     928  if (!strcmp (op, "sqrt"))  {    OUT[0].FltValue = sqrt (M1);          }
     929  if (!strcmp (op, "erf"))   {    OUT[0].FltValue = erf (M1);           }
     930
     931  if (!strcmp (op, "sinh"))  {    OUT[0].FltValue = sinh (M1);          }
     932  if (!strcmp (op, "cosh"))  {    OUT[0].FltValue = cosh (M1);          }
     933  if (!strcmp (op, "asinh")) {    OUT[0].FltValue = asinh (M1);         }
     934  if (!strcmp (op, "acosh")) {    OUT[0].FltValue = acosh (M1);         }
     935  if (!strcmp (op, "lgamma")) {   OUT[0].FltValue = lgamma (M1);        }
     936
     937  if (!strcmp (op, "sin"))   {    OUT[0].FltValue = sin (M1);           }
     938  if (!strcmp (op, "cos"))   {    OUT[0].FltValue = cos (M1);           }
     939  if (!strcmp (op, "tan"))   {    OUT[0].FltValue = tan (M1);           }
     940  if (!strcmp (op, "dsin"))  {    OUT[0].FltValue = sin (M1*RAD_DEG);   }
     941  if (!strcmp (op, "dcos"))  {    OUT[0].FltValue = cos (M1*RAD_DEG);   }
     942  if (!strcmp (op, "dtan"))  {    OUT[0].FltValue = tan (M1*RAD_DEG);   }
     943  if (!strcmp (op, "asin"))  {    OUT[0].FltValue = asin (M1);          }
     944  if (!strcmp (op, "acos"))  {    OUT[0].FltValue = acos (M1);          }
     945  if (!strcmp (op, "atan"))  {    OUT[0].FltValue = atan (M1);          }
     946  if (!strcmp (op, "dasin")) {    OUT[0].FltValue = asin (M1)*DEG_RAD;  }
     947  if (!strcmp (op, "dacos")) {    OUT[0].FltValue = acos (M1)*DEG_RAD;  }
     948  if (!strcmp (op, "datan")) {    OUT[0].FltValue = atan (M1)*DEG_RAD;  }
     949  if (!strcmp (op, "rnd"))   {    OUT[0].FltValue = drand48();           }
     950  if (!strcmp (op, "not"))   {    OUT[0].FltValue = !(M1);              }
     951  if (!strcmp (op, "--"))    {    OUT[0].FltValue = - (M1);             }
     952  if (!strcmp (op, "isinf")) {    OUT[0].FltValue = !finite(M1);        }
     953  if (!strcmp (op, "isnan")) {    OUT[0].FltValue = isnan(M1);          }
    1360954
    1361955  clear_stack (V1);
    … …  
    1367961
    1368962  int i, Nx;
    1369   float *out, *M1;
    1370963 
    1371964  Nx = V1[0].vector[0].Nelements;
    … …  
    1379972  }
    1380973  OUT[0].type = 'v'; /*** <<--- says this is a temporary matrix ***/
    1381   M1  = V1[0].ptr;
    1382   out = OUT[0].ptr = (float *)OUT[0].vector[0].elements;
     974  opihi_flt *M1  = V1[0].vector[0].elements.Flt;
     975  opihi_flt *out = OUT[0].vector[0].elements.Flt;
    1383976
    1384977  if (!strcmp (op, "="))     { } /* already set equal */
    … …  
    14231016
    14241017  if (V1[0].type == 'v') {
    1425     free (V1[0].vector[0].elements);
     1018    free (V1[0].vector[0].elements.Ptr);
    14261019    free (V1[0].vector);
    14271020    V1[0].vector = NULL;
    … …  
    14491042  }
    14501043  OUT[0].type = 'm';      /*** <<--- says this is a temporary matrix ***/
    1451   M1  = V1[0].ptr;
    1452   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     1044  M1  = (float *) V1[0].buffer[0].matrix.buffer;
     1045  out = (float *)OUT[0].buffer[0].matrix.buffer;
    14531046
    14541047  if (!strcmp (op, "="))     { }
Note: See TracChangeset for help on using the changeset viewer.