home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_200 / 274_01 / a_binop.h < prev    next >
Text File  |  1979-12-31  |  10KB  |  312 lines
  1. /* Array Handling Package
  2. (C) Copyright 1985,1987,1988 James P. Cruse - All Rights Reserved
  3.  
  4. a_binop.h 
  5.  
  6. A Part of the User-Supported Array Handling package. Please see
  7. the file ARRAY.h for discussion concerning the registration and 
  8. usage of the package.
  9.  
  10. declares all binary operations:
  11.  
  12. Notation:
  13.     d[]    =>    all elements of d (from 0 to n-1)
  14.     d[i]    =>    the i'th element of d (from 0 to n-1)
  15.     d[i-1]    =>    the i-1'th element of d (from 1 to n-1)
  16.     s    =>    parameter s
  17.     f()    =>    function parameter f (i.e. cos)
  18.     T    =>    function type T (i.e. float)
  19.  
  20.     running "sums" are d[0] = a[0], d[1] = d[0] "+" a[1], ...
  21.         d[n-2] = d[n-3] "+" a[n-2], d[n-1] = d[n-2] "+" a[n-1]
  22.  
  23.  
  24. Note:
  25.     for each operation, there are 3 macros, for each combination
  26.         of arrays and constants, for example:
  27.  
  28.     aa_op(n,d,a,b)     array, array operation        (d[] = a[] + b[])
  29.     ac_op(n,d,a,c)    array, constant operation     (d[] = a[] * c)
  30.     ca_op(n,d,c,a)    constant, array operation    (d[] = c - a[])
  31.  
  32. The functions are: 
  33.     aa_add(n,d,a,b)    d[] = a[] + b[]        add a[] and b[]
  34.     ac_add(n,d,a,c)    d[] = a[] + c          add a[] and c  
  35.     ca_add(n,d,c,b)    d[] = c   + b[]        add c and b[]
  36.  
  37.     aa_sub(n,d,a,b)    d[] = a[] - b[]        sub b[] from a[]
  38.     ac_sub(n,d,a,c)    d[] = a[] - c          sub c from b[]
  39.     ca_sub(n,d,c,b)    d[] = c   - b[]        sub b[] from c
  40.  
  41.     aa_mul(n,d,a,b)    d[] = a[] * b[]        multiply a[] and b[]
  42.     ac_mul(n,d,a,c)    d[] = a[] * c          multiply a[] and c
  43.     ca_mul(n,d,c,b)    d[] = c   * b[]        multiply c and b[]
  44.  
  45.     aa_div(n,d,a,b)    d[] = a[] / b[]        divide a[] by b[]
  46.     ac_div(n,d,a,c)    d[] = a[] / c          divide a[] by c
  47.     ca_div(n,d,c,b)    d[] = c   / b[]        divide c by a[]
  48.  
  49.     aa_mod(n,d,a,b)    d[] = a[] % b[]        Modulo a[] by b[]
  50.     ac_mod(n,d,a,c)    d[] = a[] % c          Modulo a[] by c
  51.     ca_mod(n,d,c,b)    d[] = c   % b[]        Modulo c by a[]
  52.  
  53.     aa_max(n,d,a,b)    d[] = ARR_MAX(a[],b[])    max of a[] and b[]
  54.     ac_max(n,d,a,c)    d[] = ARR_MAX(a[],c)    max of a[] and c
  55.     ca_max(n,d,c,b)    d[] = ARR_MAX(c,b[])    max of c and b[]
  56.  
  57.     aa_min(n,d,a,b)    d[] = ARR_MIN(a[],b[])    min of a[] and b[]
  58.     ac_min(n,d,a,c)    d[] = ARR_MIN(a[],c)    min of a[] and c
  59.     ca_min(n,d,c,b)    d[] = ARR_MIN(c,b[])    min of c and b[]
  60.  
  61.     aa_equ(n,d,a,b)    d[] = a[] == b[]    a[] equal b[]
  62.     ac_equ(n,d,a,c)    d[] = a[] == c      a[] equal c
  63.     ca_equ(n,d,c,b)    d[] = c   == b[]    c equal b[]
  64.  
  65.     aa_geq(n,d,a,b)    d[] = a[] >= b[]    a[] greater than or equal b[]
  66.     ac_geq(n,d,a,c)    d[] = a[] >= c      a[] greater than or equal c
  67.     ca_geq(n,d,c,b)    d[] = c   >= b[]    c   greater than or equal b[]
  68.  
  69.     aa_gtr(n,d,a,b)    d[] = a[] >  b[]    a[] greater than b[]
  70.     ac_gtr(n,d,a,c)    d[] = a[] >  c      a[] greater than c
  71.     ca_gtr(n,d,c,b)    d[] = c   >  b[]    c   greater than b[]
  72.  
  73.     aa_leq(n,d,a,b)    d[] = a[] <= b[]    a[] less than or equal b[]
  74.     ac_leq(n,d,a,c)    d[] = a[] <= c      a[] less than or equal c
  75.     ca_leq(n,d,c,b)    d[] = c   <= b[]    c   less than or equal b[]
  76.  
  77.     aa_les(n,d,a,b)    d[] = a[] <  b[]    a[] less than b[]
  78.     ac_les(n,d,a,c)    d[] = a[] <  c      a[] less than c
  79.     ca_les(n,d,c,b)    d[] = c   <  b[]    c   less than b[]
  80.  
  81.     aa_fun(n,d,a,b,f())            call f on a[] and b[]
  82.             d[] = f( a[] , b[] )
  83.     ac_fun(n,d,a,c,f())            call f on a[] and c
  84.             d[] = f( a[] , c )
  85.     ca_fun(n,d,c,b,f())            call f on c and a[]
  86.             d[] = f( c , a[] )
  87.  
  88.     aa_t_fun(n,d,a,b,f(),T)            call f on a[] and b[]
  89.             d[] = f((T)a[],(T)b[])    forcing a[i],b[i] to type T
  90.     ac_t_fun(n,d,a,c,f(),T)            call f on a[] and c
  91.             d[] = f( (T)a[], (T)c )    forcing a[i],c to type T
  92.     ca_t_fun(n,d,c,b,f(),T)            call f on c and a[]
  93.             d[] = f( (T)c, (T)a[] )    forcing c,a[i] to type T
  94.  
  95.  
  96. */    
  97.  
  98. /* check to make sure array.h has been included */
  99. #ifndef    ARR_IF_NEEDED
  100. #include "array.h"
  101. #endif
  102.  
  103.  
  104. /* check to see if we have been loaded */
  105. #ifndef    ARR_BINOP_LOADED
  106. #define    ARR_BINOP_LOADED    1
  107.  
  108. /* addition */
  109. #define    aa_add(N,D,A,B)    ARR_IF1 { \
  110.     ARR_TYPE_IND ARR_IND = (N); \
  111.     while ( ARR_IND-- ) \
  112.         (D)[ARR_IND] = (A)[ARR_IND] + (B)[ARR_IND]; \
  113.     } ARR_IF2
  114. #define    ac_add(N,D,A,B)    ARR_IF1 { \
  115.     ARR_TYPE_IND ARR_IND = (N); \
  116.     while ( ARR_IND-- ) \
  117.         (D)[ARR_IND] = (A)[ARR_IND] + (B); \
  118.     } ARR_IF2
  119. #define ca_add(N,D,A,B)    ac_add(N,D,B,A)        /* same operation */
  120.  
  121. /* subtraction */
  122. #define    aa_sub(N,D,A,B)    ARR_IF1 { \
  123.     ARR_TYPE_IND ARR_IND = (N); \
  124.     while ( ARR_IND-- ) \
  125.         (D)[ARR_IND] = (A)[ARR_IND] - (B)[ARR_IND]; \
  126.     } ARR_IF2
  127. #define    ac_sub(N,D,A,B)    ARR_IF1 { \
  128.     ARR_TYPE_IND ARR_IND = (N); \
  129.     while ( ARR_IND-- ) \
  130.         (D)[ARR_IND] = (A)[ARR_IND] - (B); \
  131.     } ARR_IF2
  132. #define    ca_sub(N,D,A,B)    ARR_IF1 { \
  133.     ARR_TYPE_IND ARR_IND = (N); \
  134.     while ( ARR_IND-- ) \
  135.         (D)[ARR_IND] = (A) - (B)[ARR_IND]; \
  136.     } ARR_IF2
  137.  
  138. /* Multiplication */
  139. #define    aa_mul(N,D,A,B)    ARR_IF1 { \
  140.     ARR_TYPE_IND ARR_IND = (N); \
  141.     while ( ARR_IND-- ) \
  142.         (D)[ARR_IND] = (A)[ARR_IND] * (B)[ARR_IND]; \
  143.     } ARR_IF2
  144. #define    ac_mul(N,D,A,B)    ARR_IF1 { \
  145.     ARR_TYPE_IND ARR_IND = (N); \
  146.     while ( ARR_IND-- ) \
  147.         (D)[ARR_IND] = (A)[ARR_IND] * (B); \
  148.     } ARR_IF2
  149. #define ca_mul(N,D,A,B)    ac_mul(N,D,B,A)        /* same operation */
  150.  
  151. /* division */
  152. #define    aa_div(N,D,A,B)    ARR_IF1 { \
  153.     ARR_TYPE_IND ARR_IND = (N); \
  154.     while ( ARR_IND-- ) \
  155.         (D)[ARR_IND] = (A)[ARR_IND] / (B)[ARR_IND]; \
  156.     } ARR_IF2
  157. #define    ac_div(N,D,A,B)    ARR_IF1 { \
  158.     ARR_TYPE_IND ARR_IND = (N); \
  159.     while ( ARR_IND-- ) \
  160.         (D)[ARR_IND] = (A)[ARR_IND] / (B); \
  161.     } ARR_IF2
  162. #define    ca_div(N,D,A,B)    ARR_IF1 { \
  163.     ARR_TYPE_IND ARR_IND = (N); \
  164.     while ( ARR_IND-- ) \
  165.         (D)[ARR_IND] = (A) / (B)[ARR_IND]; \
  166.     } ARR_IF2
  167.  
  168. /* minimum */
  169. #define    aa_min(N,D,A,B)    ARR_IF1 { \
  170.     ARR_TYPE_IND ARR_IND = (N); \
  171.     while ( ARR_IND-- ) \
  172.         (D)[ARR_IND] = ARR_MIN( (A)[ARR_IND] , (B)[ARR_IND] ); \
  173.     } ARR_IF2
  174. #define    ac_min(N,D,A,B)    ARR_IF1 { \
  175.     ARR_TYPE_IND ARR_IND = (N); \
  176.     while ( ARR_IND-- ) \
  177.         (D)[ARR_IND] = ARR_MIN( (A)[ARR_IND] , (B) ); \
  178.     } ARR_IF2
  179. #define ca_min(N,D,A,B)    ac_min(N,D,B,A)        /* same operation */
  180.  
  181. /* maximum */
  182. #define    aa_max(N,D,A,B)    ARR_IF1 { \
  183.     ARR_TYPE_IND ARR_IND = (N); \
  184.     while ( ARR_IND-- ) \
  185.         (D)[ARR_IND] = ARR_MAX( (A)[ARR_IND] , (B)[ARR_IND] ); \
  186.     } ARR_IF2
  187. #define    ac_max(N,D,A,B)    ARR_IF1 { \
  188.     ARR_TYPE_IND ARR_IND = (N); \
  189.     while ( ARR_IND-- ) \
  190.         (D)[ARR_IND] = ARR_MAX( (A)[ARR_IND] , (B) ); \
  191.     } ARR_IF2
  192. #define ca_max(N,D,A,B)    ac_max(N,D,B,A)        /* same operation */
  193.  
  194. /* modulo */
  195. #define    aa_mod(N,D,A,B)    ARR_IF1 { \
  196.     ARR_TYPE_IND ARR_IND = (N); \
  197.     while ( ARR_IND-- ) \
  198.         (D)[ARR_IND] = (A)[ARR_IND] % (B)[ARR_IND] ; \
  199.     } ARR_IF2
  200. #define    ac_mod(N,D,A,B)    ARR_IF1 { \
  201.     ARR_TYPE_IND ARR_IND = (N); \
  202.     while ( ARR_IND-- ) \
  203.         (D)[ARR_IND] = (A)[ARR_IND] % (B) ; \
  204.     } ARR_IF2
  205. #define    ca_mod(N,D,A,B)    ARR_IF1 { \
  206.     ARR_TYPE_IND ARR_IND = (N); \
  207.     while ( ARR_IND-- ) \
  208.         (D)[ARR_IND] = (A) % (B)[ARR_IND] ; \
  209.     } ARR_IF2
  210.  
  211. /* == */
  212. #define    aa_equ(N,D,A,B)    ARR_IF1 { \
  213.     ARR_TYPE_IND ARR_IND = (N); \
  214.     while ( ARR_IND-- ) \
  215.         (D)[ARR_IND] = ((A)[ARR_IND] == (B)[ARR_IND]); \
  216.     } ARR_IF2
  217. #define    ac_equ(N,D,A,B)    ARR_IF1 { \
  218.     ARR_TYPE_IND ARR_IND = (N); \
  219.     while ( ARR_IND-- ) \
  220.         (D)[ARR_IND] = ((A)[ARR_IND] == (B)); \
  221.     } ARR_IF2
  222. #define ca_equ(N,D,A,B)    ac_equ(N,D,B,A)        /* same operation */
  223.  
  224. /* >= */
  225. #define    aa_geq(N,D,A,B)    ARR_IF1 { \
  226.     ARR_TYPE_IND ARR_IND = (N); \
  227.     while ( ARR_IND-- ) \
  228.         (D)[ARR_IND] = ((A)[ARR_IND] >= (B)[ARR_IND]); \
  229.     } ARR_IF2
  230. #define    ac_geq(N,D,A,B)    ARR_IF1 { \
  231.     ARR_TYPE_IND ARR_IND = (N); \
  232.     while ( ARR_IND-- ) \
  233.         (D)[ARR_IND] = ((A)[ARR_IND] >= (B)); \
  234.     } ARR_IF2
  235. #define ca_geq(N,D,A,B)    ac_leq(N,D,B,A)        /* reversed, opposite test */
  236.  
  237.  
  238. /* > */
  239. #define    aa_gtr(N,D,A,B)    ARR_IF1 { \
  240.     ARR_TYPE_IND ARR_IND = (N); \
  241.     while ( ARR_IND-- ) \
  242.         (D)[ARR_IND] = ((A)[ARR_IND] > (B)[ARR_IND]); \
  243.     } ARR_IF2
  244. #define    ac_gtr(N,D,A,B)    ARR_IF1 { \
  245.     ARR_TYPE_IND ARR_IND = (N); \
  246.     while ( ARR_IND-- ) \
  247.         (D)[ARR_IND] = ((A)[ARR_IND] > (B)); \
  248.     } ARR_IF2
  249. #define ca_gtr(N,D,A,B)    ac_les(N,D,B,A)        /* reversed, opposite test */
  250.  
  251. /* <= */
  252. #define    aa_leq(N,D,A,B)    ARR_IF1 { \
  253.     ARR_TYPE_IND ARR_IND = (N); \
  254.     while ( ARR_IND-- ) \
  255.         (D)[ARR_IND] = ((A)[ARR_IND] <= (B)[ARR_IND]); \
  256.     } ARR_IF2
  257. #define    ac_leq(N,D,A,B)    ARR_IF1 { \
  258.     ARR_TYPE_IND ARR_IND = (N); \
  259.     while ( ARR_IND-- ) \
  260.         (D)[ARR_IND] = ((A)[ARR_IND] <= (B)); \
  261.     } ARR_IF2
  262. #define ca_leq(N,D,A,B)    ac_geq(N,D,B,A)        /* reversed, opposite test */
  263.  
  264. /* < */
  265. #define    aa_les(N,D,A,B)    ARR_IF1 { \
  266.     ARR_TYPE_IND ARR_IND = (N); \
  267.     while ( ARR_IND-- ) \
  268.         (D)[ARR_IND] = ((A)[ARR_IND] < (B)[ARR_IND]); \
  269.     } ARR_IF2
  270. #define    ac_les(N,D,A,B)    ARR_IF1 { \
  271.     ARR_TYPE_IND ARR_IND = (N); \
  272.     while ( ARR_IND-- ) \
  273.         (D)[ARR_IND] = ((A)[ARR_IND] < (B)); \
  274.     } ARR_IF2
  275. #define ca_les(N,D,A,B)    ac_gtr(N,D,B,A)        /* reversed, opposite test */
  276.  
  277. /* functions */
  278. #define    aa_fun(N,D,A,B,F)    ARR_IF1 { \
  279.     ARR_TYPE_IND ARR_IND = (N); \
  280.     while ( ARR_IND-- ) \
  281.         (D)[ARR_IND] = F( (A)[ARR_IND] , (B)[ARR_IND] ); \
  282.     } ARR_IF2
  283. #define    ac_fun(N,D,A,B,F)    ARR_IF1 { \
  284.     ARR_TYPE_IND ARR_IND = (N); \
  285.     while ( ARR_IND-- ) \
  286.         (D)[ARR_IND] = F( (A)[ARR_IND] , (B) ); \
  287.     } ARR_IF2
  288. #define    ca_fun(N,D,A,B,F)    ARR_IF1 { \
  289.     ARR_TYPE_IND ARR_IND = (N); \
  290.     while ( ARR_IND-- ) \
  291.         (D)[ARR_IND] = F( (A)          , (B)[ARR_IND] ); \
  292.     } ARR_IF2
  293.  
  294. /* typed functions */
  295. #define    aa_t_fun(N,D,A,B,F,T)    ARR_IF1 { \
  296.     ARR_TYPE_IND ARR_IND = (N); \
  297.     while ( ARR_IND-- ) \
  298.         (D)[ARR_IND] = F( ((T)((A)[ARR_IND])), ((T)((B)[ARR_IND]))); \
  299.     } ARR_IF2
  300. #define    ac_t_fun(N,D,A,B,F,T)    ARR_IF1 { \
  301.     ARR_TYPE_IND ARR_IND = (N); \
  302.     while ( ARR_IND-- ) \
  303.         (D)[ARR_IND] = F( ( (T) ((A)[ARR_IND]) ) , ((T) (B)) ); \
  304.     } ARR_IF2
  305. #define    ca_t_fun(N,D,A,B,F,T)    ARR_IF1 { \
  306.     ARR_TYPE_IND ARR_IND = (N); \
  307.     while ( ARR_IND-- ) \
  308.         (D)[ARR_IND] = F( ( (T) (A) ) , ((T) ((B)[ARR_IND]) ) ); \
  309.     } ARR_IF2
  310.  
  311. #endif
  312.