Fulguro: /home/christophe/src/fulguro/trunk/src/arith/flgrArith.c Source File

00001 /****************************************************************
00002  * Fulguro
00003  * Copyright (C) 2004 Christophe Clienti
00004  *
00005  * This library is free software; you can redistribute it and/or
00006  * modify it under the terms of the GNU Lesser General Public
00007  * License as published by the Free Software Foundation; either
00008  * version 2 of the License, or (at your option) any later version.
00009  *
00010  * This library is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00013  * Lesser General Public License for more details.
00014  *
00015  * You should have received a copy of the GNU Lesser General Public
00016  * License along with this library; if not, write to the
00017  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00018  * Boston, MA 02111-1307, USA.
00019  ***************************************************************/
00020 
00021 
00022 #include <stdio.h>
00023 #include <stdlib.h>
00024 #include <string.h>
00025 #include <math.h>
00026 #include <flgrCoreDispatch.h>
00027 #include <flgrCoreDataIO.h>
00028 #include <flgrCoreMalloc.h>
00029 #include <flgrCoreArithDef.h>
00030 #include "flgrArith.h"
00031 #include "flgrArithSSE.h"
00032 #include "flgrArithSSE2.h"
00033 
00043 /****************************************************************************************************/
00044 /****************************************************************************************************/
00045 /****************************************************************************************************/
00046 /******************************************* 1D Functions *******************************************/
00047 /****************************************************************************************************/
00048 /****************************************************************************************************/
00049 /****************************************************************************************************/
00050 
00051 
00052 #define FLGR_MACRO_ARITH_1D_DIADIC(dtypedest,dtype1,dtype2,operator)    \
00053   int j;                                \
00054   dtype1 *psrc1 = (dtype1*) data1->array;               \
00055   dtype2 *psrc2 = (dtype2*) data2->array;               \
00056   dtypedest *pdest = (dtypedest*) datdest->array;           \
00057   dtype1 v1;                                \
00058   dtype2 v2;                                \
00059   dtypedest result;                         \
00060   int spp = datdest->spp;                       \
00061   int length = datdest->length*spp;                 \
00062                                     \
00063                         \
00064                                     \
00065   for(j=0 ; j<length ; j++) {                       \
00066     v1 = flgr1d_get_data_array_##dtype1(psrc1,j);           \
00067     v2 = flgr1d_get_data_array_##dtype2(psrc2,j);           \
00068     result = operator(v1,v2);                       \
00069     flgr1d_set_data_array_##dtypedest(pdest,j,result);          \
00070   }                                 \
00071   return
00072 
00073 #define FLGR_MACRO_ARITH_1D_MONOADIC(dtypedest,dtype1,operator)     \
00074   int j;                                \
00075   dtype1 *psrc1 = (dtype1*) data1->array;               \
00076   dtypedest *pdest = (dtypedest*) datdest->array;           \
00077   dtype1 v1;                                \
00078   dtypedest result;                         \
00079   int spp = datdest->spp;                       \
00080   int length = datdest->length*spp;                 \
00081                                     \
00082                         \
00083                                     \
00084   for(j=0 ; j<length ; j++) {                       \
00085     v1 = flgr1d_get_data_array_##dtype1(psrc1,j);           \
00086     result = operator(v1);                      \
00087     flgr1d_set_data_array_##dtypedest(pdest,j,result);          \
00088   }                                 \
00089   return
00090 
00091 #define FLGR_MACRO_ARITH_1D_MONOADIC_PARAM(dtypedest,dtype1,operator)   \
00092   int j;                                \
00093   dtype1 *psrc1 = (dtype1*) data1->array;               \
00094   dtypedest *pdest = (dtypedest*) datdest->array;           \
00095   dtype1 v1;                                \
00096   dtypedest result;                         \
00097   int spp = datdest->spp;                       \
00098   int length = datdest->length*spp;                 \
00099                                     \
00100                         \
00101                                     \
00102   for(j=0 ; j<length ; j++) {                       \
00103     v1 = flgr1d_get_data_array_##dtype1(psrc1,j);           \
00104     result = operator(v1);                      \
00105     flgr1d_set_data_array_##dtypedest(pdest,j,result);          \
00106   }                                 \
00107   return
00108 
00109 #define FLGR_MACRO_ARITH_1D_DIADIC_CONST(dtypedest,dtype1,operator) \
00110   int j;                                \
00111   dtype1 *psrc1 = (dtype1*) data1->array;               \
00112   dtype1 *constant = (dtype1*) vec_const->array;            \
00113   dtypedest *pdest = (dtypedest*) datdest->array;           \
00114   dtype1 v1;                                \
00115   dtypedest result;                         \
00116   int spp = datdest->spp;                       \
00117   int length = datdest->length*spp;                 \
00118                                     \
00119                         \
00120                                     \
00121   for(j=0 ; j<length ; j++) {                       \
00122     v1 = flgr1d_get_data_array_##dtype1(psrc1,j);           \
00123     result = operator(v1,flgr_get_array_##dtype1(constant,j%spp));  \
00124     flgr1d_set_data_array_##dtypedest(pdest,j,result);          \
00125   }                                 \
00126   return
00127 
00128 
00129 
00130 /*******************************************************************************
00131  * INF
00132  *******************************************************************************/
00133 
00134 void flgr1d_arith_inf_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00135   #ifdef __SSE2__
00136      flgr1d_arith_inf_SSE2_fgBIT(datdest,data1,data2);
00137   #else
00138     #ifdef __SSE__
00139        flgr1d_arith_inf_SSE_fgBIT(datdest,data1,data2);
00140     #else
00141        FLGR_MACRO_ARITH_1D_DIADIC(fgBIT,fgBIT,fgBIT,flgr_defop_inf_fgBIT);
00142     #endif
00143   #endif
00144 }
00145 void flgr1d_arith_inf_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00146   #ifdef __SSE2__
00147      flgr1d_arith_inf_SSE2_fgUINT8(datdest,data1,data2);
00148   #else
00149     #ifdef __SSE__
00150        flgr1d_arith_inf_SSE_fgUINT8(datdest,data1,data2);
00151     #else
00152        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT8,fgUINT8,fgUINT8,flgr_defop_inf_fgUINT8);
00153     #endif
00154   #endif
00155 }
00156 void flgr1d_arith_inf_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00157   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT16,fgUINT16,fgUINT16,flgr_defop_inf_fgUINT16);
00158 }
00159 void flgr1d_arith_inf_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00160   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT32,fgUINT32,fgUINT32,flgr_defop_inf_fgUINT32);
00161 }
00162 void flgr1d_arith_inf_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00163   FLGR_MACRO_ARITH_1D_DIADIC(fgINT8,fgINT8,fgINT8,flgr_defop_inf_fgINT8);
00164 }
00165 void flgr1d_arith_inf_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00166   #ifdef __SSE2__
00167      flgr1d_arith_inf_SSE2_fgINT16(datdest,data1,data2);
00168   #else
00169     #ifdef __SSE__
00170        flgr1d_arith_inf_SSE_fgINT16(datdest,data1,data2);
00171     #else
00172        FLGR_MACRO_ARITH_1D_DIADIC(fgINT16,fgINT16,fgINT16,flgr_defop_inf_fgINT16);
00173     #endif
00174   #endif
00175 }
00176 void flgr1d_arith_inf_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00177   FLGR_MACRO_ARITH_1D_DIADIC(fgINT32,fgINT32,fgINT32,flgr_defop_inf_fgINT32);
00178 }
00179 void flgr1d_arith_inf_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00180   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT32,fgFLOAT32,fgFLOAT32,flgr_defop_inf_fgFLOAT32);
00181 }
00182 void flgr1d_arith_inf_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00183   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT64,fgFLOAT64,fgFLOAT64,flgr_defop_inf_fgFLOAT64);
00184 }
00185 
00187 
00193 
00194 FLGR_Ret flgr1d_arith_inf(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00195   FLGR_Ret ret;
00196 
00197   
00198 
00199   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
00200     POST_ERROR("Null objects!\n");
00201     return FLGR_RET_NULL_OBJECT;
00202   }
00203 
00204   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00205   if((ret = flgr1d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00206 
00207   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_inf,datdest,data1,data2);
00208 
00209 }
00210 
00211 
00212 /*******************************************************************************
00213  * SUP
00214  *******************************************************************************/
00215 
00216 void flgr1d_arith_sup_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00217   #ifdef __SSE2__
00218      flgr1d_arith_sup_SSE2_fgBIT(datdest,data1,data2);
00219   #else
00220     #ifdef __SSE__
00221        flgr1d_arith_sup_SSE_fgBIT(datdest,data1,data2);
00222     #else
00223        FLGR_MACRO_ARITH_1D_DIADIC(fgBIT,fgBIT,fgBIT,flgr_defop_sup_fgBIT);
00224     #endif
00225   #endif
00226 }
00227 void flgr1d_arith_sup_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00228   #ifdef __SSE2__
00229      flgr1d_arith_sup_SSE2_fgUINT8(datdest,data1,data2);
00230   #else
00231     #ifdef __SSE__
00232        flgr1d_arith_sup_SSE_fgUINT8(datdest,data1,data2);
00233     #else
00234        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT8,fgUINT8,fgUINT8,flgr_defop_sup_fgUINT8);
00235     #endif
00236   #endif
00237 }
00238 void flgr1d_arith_sup_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00239   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT16,fgUINT16,fgUINT16,flgr_defop_sup_fgUINT16);
00240 }
00241 void flgr1d_arith_sup_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00242   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT32,fgUINT32,fgUINT32,flgr_defop_sup_fgUINT32);
00243 }
00244 void flgr1d_arith_sup_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00245   FLGR_MACRO_ARITH_1D_DIADIC(fgINT8,fgINT8,fgINT8,flgr_defop_sup_fgINT8);
00246 }
00247 void flgr1d_arith_sup_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00248   #ifdef __SSE2__
00249      flgr1d_arith_sup_SSE2_fgINT16(datdest,data1,data2);
00250   #else
00251     #ifdef __SSE__
00252        flgr1d_arith_sup_SSE_fgINT16(datdest,data1,data2);
00253     #else
00254        FLGR_MACRO_ARITH_1D_DIADIC(fgINT16,fgINT16,fgINT16,flgr_defop_sup_fgINT16);
00255     #endif
00256   #endif
00257 }
00258 void flgr1d_arith_sup_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00259   FLGR_MACRO_ARITH_1D_DIADIC(fgINT32,fgINT32,fgINT32,flgr_defop_sup_fgINT32);
00260 }
00261 void flgr1d_arith_sup_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00262   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT32,fgFLOAT32,fgFLOAT32,flgr_defop_sup_fgFLOAT32);
00263 }
00264 void flgr1d_arith_sup_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00265   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT64,fgFLOAT64,fgFLOAT64,flgr_defop_sup_fgFLOAT64);
00266 }
00267 
00269 
00275 
00276 FLGR_Ret flgr1d_arith_sup(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00277   FLGR_Ret ret;
00278 
00279   
00280 
00281   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
00282     POST_ERROR("Null objects!\n");
00283     return FLGR_RET_NULL_OBJECT;
00284   }
00285 
00286   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00287   if((ret = flgr1d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00288 
00289   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_sup,datdest,data1,data2);
00290 
00291 }
00292 
00293 /*******************************************************************************
00294  * AND
00295  *******************************************************************************/
00296 
00297 void flgr1d_arith_and_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00298   #ifdef __SSE2__
00299      flgr1d_arith_and_SSE2_fgBIT(datdest,data1,data2);
00300   #else
00301     #ifdef __SSE__
00302        flgr1d_arith_and_SSE_fgBIT(datdest,data1,data2);
00303     #else
00304        FLGR_MACRO_ARITH_1D_DIADIC(fgBIT,fgBIT,fgBIT,flgr_defop_and_fgBIT);
00305     #endif
00306   #endif
00307 }
00308 void flgr1d_arith_and_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00309   #ifdef __SSE2__
00310      flgr1d_arith_and_SSE2_fgUINT8(datdest,data1,data2);
00311   #else
00312     #ifdef __SSE__
00313        flgr1d_arith_and_SSE_fgUINT8(datdest,data1,data2);
00314     #else
00315        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT8,fgUINT8,fgUINT8,flgr_defop_and_fgUINT8);
00316     #endif
00317   #endif
00318 }
00319 void flgr1d_arith_and_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00320   #ifdef __SSE2__
00321      flgr1d_arith_and_SSE2_fgUINT16(datdest,data1,data2);
00322   #else
00323     #ifdef __SSE__
00324        flgr1d_arith_and_SSE_fgUINT16(datdest,data1,data2);
00325     #else
00326        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT16,fgUINT16,fgUINT16,flgr_defop_and_fgUINT16);
00327     #endif
00328   #endif
00329 }
00330 void flgr1d_arith_and_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00331   #ifdef __SSE2__
00332      flgr1d_arith_and_SSE2_fgUINT32(datdest,data1,data2);
00333   #else
00334     #ifdef __SSE__
00335        flgr1d_arith_and_SSE_fgUINT32(datdest,data1,data2);
00336     #else
00337        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT32,fgUINT32,fgUINT32,flgr_defop_and_fgUINT32);
00338     #endif
00339   #endif
00340 }
00341 void flgr1d_arith_and_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00342   #ifdef __SSE2__
00343      flgr1d_arith_and_SSE2_fgINT8(datdest,data1,data2);
00344   #else
00345     #ifdef __SSE__
00346        flgr1d_arith_and_SSE_fgINT8(datdest,data1,data2);
00347     #else
00348        FLGR_MACRO_ARITH_1D_DIADIC(fgINT8,fgINT8,fgINT8,flgr_defop_and_fgINT8);
00349     #endif
00350   #endif
00351 }
00352 void flgr1d_arith_and_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00353   #ifdef __SSE2__
00354      flgr1d_arith_and_SSE2_fgINT16(datdest,data1,data2);
00355   #else
00356     #ifdef __SSE__
00357        flgr1d_arith_and_SSE_fgINT16(datdest,data1,data2);
00358     #else
00359        FLGR_MACRO_ARITH_1D_DIADIC(fgINT16,fgINT16,fgINT16,flgr_defop_and_fgINT16);
00360     #endif
00361   #endif
00362 }
00363 void flgr1d_arith_and_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00364   #ifdef __SSE2__
00365      flgr1d_arith_and_SSE2_fgINT32(datdest,data1,data2);
00366   #else
00367     #ifdef __SSE__
00368        flgr1d_arith_and_SSE_fgINT32(datdest,data1,data2);
00369     #else
00370        FLGR_MACRO_ARITH_1D_DIADIC(fgINT32,fgINT32,fgINT32,flgr_defop_and_fgINT32);
00371     #endif
00372   #endif
00373 }
00374 void flgr1d_arith_and_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00375   flgr_no_define_type_function(FLGR_FLOAT32);
00376 }
00377 void flgr1d_arith_and_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00378   flgr_no_define_type_function(FLGR_FLOAT64);
00379 }
00380 
00382 
00388 
00389 FLGR_Ret flgr1d_arith_and(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00390   FLGR_Ret ret;
00391 
00392   
00393 
00394   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
00395     POST_ERROR("Null objects!\n");
00396     return FLGR_RET_NULL_OBJECT;
00397   }
00398 
00399   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00400   if((ret = flgr1d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00401 
00402   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_and,datdest,data1,data2);
00403 
00404 }
00405 
00406 
00407 /*******************************************************************************
00408  * OR
00409  *******************************************************************************/
00410 
00411 void flgr1d_arith_or_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00412   #ifdef __SSE2__
00413      flgr1d_arith_or_SSE2_fgBIT(datdest,data1,data2);
00414   #else
00415     #ifdef __SSE__
00416        flgr1d_arith_or_SSE_fgBIT(datdest,data1,data2);
00417     #else
00418        FLGR_MACRO_ARITH_1D_DIADIC(fgBIT,fgBIT,fgBIT,flgr_defop_or_fgBIT);
00419     #endif
00420   #endif
00421 }
00422 void flgr1d_arith_or_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00423   #ifdef __SSE2__
00424      flgr1d_arith_or_SSE2_fgUINT8(datdest,data1,data2);
00425   #else
00426     #ifdef __SSE__
00427        flgr1d_arith_or_SSE_fgUINT8(datdest,data1,data2);
00428     #else
00429        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT8,fgUINT8,fgUINT8,flgr_defop_or_fgUINT8);
00430     #endif
00431   #endif
00432 }
00433 void flgr1d_arith_or_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00434   #ifdef __SSE2__
00435      flgr1d_arith_or_SSE2_fgUINT16(datdest,data1,data2);
00436   #else
00437     #ifdef __SSE__
00438        flgr1d_arith_or_SSE_fgUINT16(datdest,data1,data2);
00439     #else
00440        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT16,fgUINT16,fgUINT16,flgr_defop_or_fgUINT16);
00441     #endif
00442   #endif
00443 }
00444 void flgr1d_arith_or_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00445   #ifdef __SSE2__
00446      flgr1d_arith_or_SSE2_fgUINT32(datdest,data1,data2);
00447   #else
00448     #ifdef __SSE__
00449        flgr1d_arith_or_SSE_fgUINT32(datdest,data1,data2);
00450     #else
00451        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT32,fgUINT32,fgUINT32,flgr_defop_or_fgUINT32);
00452     #endif
00453   #endif
00454 }
00455 void flgr1d_arith_or_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00456   #ifdef __SSE2__
00457      flgr1d_arith_or_SSE2_fgINT8(datdest,data1,data2);
00458   #else
00459     #ifdef __SSE__
00460        flgr1d_arith_or_SSE_fgINT8(datdest,data1,data2);
00461     #else
00462        FLGR_MACRO_ARITH_1D_DIADIC(fgINT8,fgINT8,fgINT8,flgr_defop_or_fgINT8);
00463     #endif
00464   #endif
00465 }
00466 void flgr1d_arith_or_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00467   #ifdef __SSE2__
00468      flgr1d_arith_or_SSE2_fgINT16(datdest,data1,data2);
00469   #else
00470     #ifdef __SSE__
00471        flgr1d_arith_or_SSE_fgINT16(datdest,data1,data2);
00472     #else
00473        FLGR_MACRO_ARITH_1D_DIADIC(fgINT16,fgINT16,fgINT16,flgr_defop_or_fgINT16);
00474     #endif
00475   #endif
00476 }
00477 void flgr1d_arith_or_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00478   #ifdef __SSE2__
00479      flgr1d_arith_or_SSE2_fgINT32(datdest,data1,data2);
00480   #else
00481     #ifdef __SSE__
00482        flgr1d_arith_or_SSE_fgINT32(datdest,data1,data2);
00483     #else
00484        FLGR_MACRO_ARITH_1D_DIADIC(fgINT32,fgINT32,fgINT32,flgr_defop_or_fgINT32);
00485     #endif
00486   #endif
00487 }
00488 void flgr1d_arith_or_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00489   flgr_no_define_type_function(FLGR_FLOAT32);
00490 }
00491 void flgr1d_arith_or_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00492   flgr_no_define_type_function(FLGR_FLOAT64);
00493 }
00494 
00496 
00502 
00503 FLGR_Ret flgr1d_arith_or(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00504   FLGR_Ret ret;
00505   
00506 
00507   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
00508     POST_ERROR("Null objects!\n");
00509     return FLGR_RET_NULL_OBJECT;
00510   }
00511 
00512   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00513   if((ret = flgr1d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00514 
00515   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_or,datdest,data1,data2);
00516 
00517 }
00518 
00519 
00520 /*******************************************************************************
00521  * XOR
00522  *******************************************************************************/
00523 
00524 void flgr1d_arith_xor_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00525   #ifdef __SSE2__
00526      flgr1d_arith_xor_SSE2_fgBIT(datdest,data1,data2);
00527   #else
00528     #ifdef __SSE__
00529        flgr1d_arith_xor_SSE_fgBIT(datdest,data1,data2);
00530     #else
00531        FLGR_MACRO_ARITH_1D_DIADIC(fgBIT,fgBIT,fgBIT,flgr_defop_xor_fgBIT);
00532     #endif
00533   #endif
00534 }
00535 void flgr1d_arith_xor_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00536   #ifdef __SSE2__
00537      flgr1d_arith_xor_SSE2_fgUINT8(datdest,data1,data2);
00538   #else
00539     #ifdef __SSE__
00540        flgr1d_arith_xor_SSE_fgUINT8(datdest,data1,data2);
00541     #else
00542        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT8,fgUINT8,fgUINT8,flgr_defop_xor_fgUINT8);
00543     #endif
00544   #endif
00545 }
00546 void flgr1d_arith_xor_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00547   #ifdef __SSE2__
00548      flgr1d_arith_xor_SSE2_fgUINT16(datdest,data1,data2);
00549   #else
00550     #ifdef __SSE__
00551        flgr1d_arith_xor_SSE_fgUINT16(datdest,data1,data2);
00552     #else
00553        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT16,fgUINT16,fgUINT16,flgr_defop_xor_fgUINT16);
00554     #endif
00555   #endif
00556 }
00557 void flgr1d_arith_xor_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00558   #ifdef __SSE2__
00559      flgr1d_arith_xor_SSE2_fgUINT32(datdest,data1,data2);
00560   #else
00561     #ifdef __SSE__
00562        flgr1d_arith_xor_SSE_fgUINT32(datdest,data1,data2);
00563     #else
00564        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT32,fgUINT32,fgUINT32,flgr_defop_xor_fgUINT32);
00565     #endif
00566   #endif
00567 }
00568 void flgr1d_arith_xor_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00569   #ifdef __SSE2__
00570      flgr1d_arith_xor_SSE2_fgINT8(datdest,data1,data2);
00571   #else
00572     #ifdef __SSE__
00573        flgr1d_arith_xor_SSE_fgINT8(datdest,data1,data2);
00574     #else
00575        FLGR_MACRO_ARITH_1D_DIADIC(fgINT8,fgINT8,fgINT8,flgr_defop_xor_fgINT8);
00576     #endif
00577   #endif
00578 }
00579 void flgr1d_arith_xor_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00580   #ifdef __SSE2__
00581      flgr1d_arith_xor_SSE2_fgINT16(datdest,data1,data2);
00582   #else
00583     #ifdef __SSE__
00584        flgr1d_arith_xor_SSE_fgINT16(datdest,data1,data2);
00585     #else
00586        FLGR_MACRO_ARITH_1D_DIADIC(fgINT16,fgINT16,fgINT16,flgr_defop_xor_fgINT16);
00587     #endif
00588   #endif
00589 }
00590 void flgr1d_arith_xor_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00591   #ifdef __SSE2__
00592      flgr1d_arith_xor_SSE2_fgINT32(datdest,data1,data2);
00593   #else
00594     #ifdef __SSE__
00595        flgr1d_arith_xor_SSE_fgINT32(datdest,data1,data2);
00596     #else
00597        FLGR_MACRO_ARITH_1D_DIADIC(fgINT32,fgINT32,fgINT32,flgr_defop_xor_fgINT32);
00598     #endif
00599   #endif
00600 }
00601 void flgr1d_arith_xor_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00602   flgr_no_define_type_function(FLGR_FLOAT32);
00603 }
00604 void flgr1d_arith_xor_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00605   flgr_no_define_type_function(FLGR_FLOAT64);
00606 }
00607 
00609 
00615 
00616 FLGR_Ret flgr1d_arith_xor(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00617   FLGR_Ret ret;
00618   
00619 
00620   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
00621     POST_ERROR("Null objects!\n");
00622     return FLGR_RET_NULL_OBJECT;
00623   }
00624 
00625   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00626   if((ret = flgr1d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00627 
00628   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_xor,datdest,data1,data2);
00629 
00630 }
00631 
00632 
00633 /*******************************************************************************
00634  * ATAN2
00635  *******************************************************************************/
00636 
00637 void flgr1d_arith_atan2_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00638   flgr_no_define_type_function(FLGR_BIT);
00639 }
00640 void flgr1d_arith_atan2_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00641   flgr_no_define_type_function(FLGR_UINT8);
00642 }
00643 void flgr1d_arith_atan2_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00644   flgr_no_define_type_function(FLGR_UINT16);
00645 }
00646 void flgr1d_arith_atan2_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00647   flgr_no_define_type_function(FLGR_UINT32);
00648 }
00649 void flgr1d_arith_atan2_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00650   flgr_no_define_type_function(FLGR_INT8);
00651 }
00652 void flgr1d_arith_atan2_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00653   flgr_no_define_type_function(FLGR_INT16);
00654 }
00655 void flgr1d_arith_atan2_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00656   flgr_no_define_type_function(FLGR_INT32);
00657 }
00658 void flgr1d_arith_atan2_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00659   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT32,fgFLOAT32,fgFLOAT32,flgr_defop_atan2_fgFLOAT32);
00660 }
00661 void flgr1d_arith_atan2_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00662   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT64,fgFLOAT64,fgFLOAT64,flgr_defop_atan2_fgFLOAT64);
00663 }
00664 
00666 
00672 
00673 FLGR_Ret flgr1d_arith_atan2(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00674   FLGR_Ret ret;
00675   
00676 
00677   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
00678     POST_ERROR("Null objects!\n");
00679     return FLGR_RET_NULL_OBJECT;
00680   }
00681 
00682   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00683   if((ret = flgr1d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00684 
00685   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_atan2,datdest,data1,data2);
00686 
00687 }
00688 
00689 
00690 /*******************************************************************************
00691  * ARGUMENT
00692  *******************************************************************************/
00693 
00694 void flgr1d_arith_argument_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00695   flgr_no_define_type_function(FLGR_BIT);
00696 }
00697 void flgr1d_arith_argument_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00698   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT8,fgUINT8,fgUINT8,flgr_defop_argument_fgUINT8);
00699 }
00700 void flgr1d_arith_argument_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00701   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT16,fgUINT16,fgUINT16,flgr_defop_argument_fgUINT16);
00702 }
00703 void flgr1d_arith_argument_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00704   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT32,fgUINT32,fgUINT32,flgr_defop_argument_fgUINT32);
00705 }
00706 void flgr1d_arith_argument_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00707   FLGR_MACRO_ARITH_1D_DIADIC(fgINT8,fgINT8,fgINT8,flgr_defop_argument_fgINT8);
00708 }
00709 void flgr1d_arith_argument_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00710   FLGR_MACRO_ARITH_1D_DIADIC(fgINT16,fgINT16,fgINT16,flgr_defop_argument_fgINT16);
00711 }
00712 void flgr1d_arith_argument_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00713   FLGR_MACRO_ARITH_1D_DIADIC(fgINT32,fgINT32,fgINT32,flgr_defop_argument_fgINT32);
00714 }
00715 void flgr1d_arith_argument_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00716   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT32,fgFLOAT32,fgFLOAT32,flgr_defop_argument_fgFLOAT32);
00717 }
00718 void flgr1d_arith_argument_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00719   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT64,fgFLOAT64,fgFLOAT64,flgr_defop_argument_fgFLOAT64);
00720 }
00721 
00723 
00729 
00730 FLGR_Ret flgr1d_arith_argument(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00731   FLGR_Ret ret;
00732   
00733 
00734   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
00735     POST_ERROR("Null objects!\n");
00736     return FLGR_RET_NULL_OBJECT;
00737   }
00738 
00739   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00740   if((ret = flgr1d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00741 
00742   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_argument,datdest,data1,data2);
00743 
00744 }
00745 
00746 
00747 
00748 /*******************************************************************************
00749  * MODULE
00750  *******************************************************************************/
00751 
00752 void flgr1d_arith_module_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00753   flgr_no_define_type_function(FLGR_BIT);
00754 }
00755 void flgr1d_arith_module_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00756   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT8,fgUINT8,fgUINT8,flgr_defop_module_fgUINT8);
00757 }
00758 void flgr1d_arith_module_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00759   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT16,fgUINT16,fgUINT16,flgr_defop_module_fgUINT16);
00760 }
00761 void flgr1d_arith_module_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00762   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT32,fgUINT32,fgUINT32,flgr_defop_module_fgUINT32);
00763 }
00764 void flgr1d_arith_module_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00765   FLGR_MACRO_ARITH_1D_DIADIC(fgINT8,fgINT8,fgINT8,flgr_defop_module_fgINT8);
00766 }
00767 void flgr1d_arith_module_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00768   FLGR_MACRO_ARITH_1D_DIADIC(fgINT16,fgINT16,fgINT16,flgr_defop_module_fgINT16);
00769 }
00770 void flgr1d_arith_module_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00771   FLGR_MACRO_ARITH_1D_DIADIC(fgINT32,fgINT32,fgINT32,flgr_defop_module_fgINT32);
00772 }
00773 void flgr1d_arith_module_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00774   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT32,fgFLOAT32,fgFLOAT32,flgr_defop_module_fgFLOAT32);
00775 }
00776 void flgr1d_arith_module_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00777   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT64,fgFLOAT64,fgFLOAT64,flgr_defop_module_fgFLOAT64);
00778 }
00779 
00781 
00787 
00788 FLGR_Ret flgr1d_arith_module(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00789   FLGR_Ret ret;
00790   
00791 
00792   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
00793     POST_ERROR("Null objects!\n");
00794     return FLGR_RET_NULL_OBJECT;
00795   }
00796 
00797   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00798   if((ret = flgr1d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00799 
00800   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_module,datdest,data1,data2);
00801 
00802 }
00803 
00804 
00805 /*******************************************************************************
00806  * MULTSAT
00807  *******************************************************************************/
00808 
00809 void flgr1d_arith_multsat_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00810   flgr_no_define_type_function(FLGR_BIT);
00811 }
00812 void flgr1d_arith_multsat_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00813   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT8,fgUINT8,fgUINT8,flgr_defop_multsat_fgUINT8);
00814 }
00815 void flgr1d_arith_multsat_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00816   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT16,fgUINT16,fgUINT16,flgr_defop_multsat_fgUINT16);
00817 }
00818 void flgr1d_arith_multsat_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00819   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT32,fgUINT32,fgUINT32,flgr_defop_multsat_fgUINT32);
00820 }
00821 void flgr1d_arith_multsat_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00822   FLGR_MACRO_ARITH_1D_DIADIC(fgINT8,fgINT8,fgINT8,flgr_defop_multsat_fgINT8);
00823 }
00824 void flgr1d_arith_multsat_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00825   FLGR_MACRO_ARITH_1D_DIADIC(fgINT16,fgINT16,fgINT16,flgr_defop_multsat_fgINT16);
00826 }
00827 void flgr1d_arith_multsat_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00828   FLGR_MACRO_ARITH_1D_DIADIC(fgINT32,fgINT32,fgINT32,flgr_defop_multsat_fgINT32);
00829 }
00830 void flgr1d_arith_multsat_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00831   flgr_no_define_type_function(FLGR_FLOAT32);
00832 }
00833 void flgr1d_arith_multsat_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00834   flgr_no_define_type_function(FLGR_FLOAT64);
00835 }
00836 
00838 
00844 
00845 FLGR_Ret flgr1d_arith_multsat(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00846   FLGR_Ret ret;
00847   
00848 
00849   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
00850     POST_ERROR("Null objects!\n");
00851     return FLGR_RET_NULL_OBJECT;
00852   }
00853 
00854   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00855   if((ret = flgr1d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00856 
00857   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_multsat,datdest,data1,data2);
00858 
00859 }
00860 
00861 
00862 
00863 /*******************************************************************************
00864  * SUBSAT
00865  *******************************************************************************/
00866 
00867 void flgr1d_arith_subsat_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00868   flgr_no_define_type_function(FLGR_BIT);
00869 }
00870 void flgr1d_arith_subsat_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00871   #ifdef __SSE2__
00872      flgr1d_arith_subsat_SSE2_fgUINT8(datdest,data1,data2);
00873   #else
00874     #ifdef __SSE__
00875        flgr1d_arith_subsat_SSE_fgUINT8(datdest,data1,data2);
00876     #else
00877        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT8,fgUINT8,fgUINT8,flgr_defop_subsat_fgUINT8);
00878     #endif
00879   #endif
00880 }
00881 void flgr1d_arith_subsat_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00882   #ifdef __SSE2__
00883      flgr1d_arith_subsat_SSE2_fgUINT16(datdest,data1,data2);
00884   #else
00885     #ifdef __SSE__
00886        flgr1d_arith_subsat_SSE_fgUINT16(datdest,data1,data2);
00887     #else
00888        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT16,fgUINT16,fgUINT16,flgr_defop_subsat_fgUINT16);
00889     #endif
00890   #endif
00891 }
00892 void flgr1d_arith_subsat_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00893   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT32,fgUINT32,fgUINT32,flgr_defop_subsat_fgUINT32);
00894 }
00895 void flgr1d_arith_subsat_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00896   FLGR_MACRO_ARITH_1D_DIADIC(fgINT8,fgINT8,fgINT8,flgr_defop_subsat_fgINT8);
00897 }
00898 void flgr1d_arith_subsat_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00899   #ifdef __SSE2__
00900      flgr1d_arith_subsat_SSE2_fgINT16(datdest,data1,data2);
00901   #else
00902     #ifdef __SSE__
00903        flgr1d_arith_subsat_SSE_fgINT16(datdest,data1,data2);
00904     #else
00905        FLGR_MACRO_ARITH_1D_DIADIC(fgINT16,fgINT16,fgINT16,flgr_defop_subsat_fgINT16);
00906     #endif
00907   #endif
00908 }
00909 void flgr1d_arith_subsat_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00910   FLGR_MACRO_ARITH_1D_DIADIC(fgINT32,fgINT32,fgINT32,flgr_defop_subsat_fgINT32);
00911 }
00912 void flgr1d_arith_subsat_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00913   flgr_no_define_type_function(FLGR_FLOAT32);
00914 }
00915 void flgr1d_arith_subsat_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00916   flgr_no_define_type_function(FLGR_FLOAT64);
00917 }
00918 
00920 
00926 
00927 FLGR_Ret flgr1d_arith_subsat(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00928   FLGR_Ret ret;
00929   
00930 
00931   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
00932     POST_ERROR("Null objects!\n");
00933     return FLGR_RET_NULL_OBJECT;
00934   }
00935 
00936   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00937   if((ret = flgr1d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
00938 
00939   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_subsat,datdest,data1,data2);
00940 
00941 }
00942 
00943 
00944 
00945 /*******************************************************************************
00946  * ADDSAT
00947  *******************************************************************************/
00948 
00949 void flgr1d_arith_addsat_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00950   flgr_no_define_type_function(FLGR_BIT);
00951 }
00952 void flgr1d_arith_addsat_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00953   #ifdef __SSE2__
00954      flgr1d_arith_addsat_SSE2_fgUINT8(datdest,data1,data2);
00955   #else
00956     #ifdef __SSE__
00957        flgr1d_arith_addsat_SSE_fgUINT8(datdest,data1,data2);
00958     #else
00959        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT8,fgUINT8,fgUINT8,flgr_defop_addsat_fgUINT8);
00960     #endif
00961   #endif
00962 }
00963 void flgr1d_arith_addsat_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00964   #ifdef __SSE2__
00965      flgr1d_arith_addsat_SSE2_fgUINT16(datdest,data1,data2);
00966   #else
00967     #ifdef __SSE__
00968        flgr1d_arith_addsat_SSE_fgUINT16(datdest,data1,data2);
00969     #else
00970        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT16,fgUINT16,fgUINT16,flgr_defop_addsat_fgUINT16);
00971     #endif
00972   #endif
00973 }
00974 void flgr1d_arith_addsat_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00975   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT32,fgUINT32,fgUINT32,flgr_defop_addsat_fgUINT32);
00976 }
00977 void flgr1d_arith_addsat_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00978   FLGR_MACRO_ARITH_1D_DIADIC(fgINT8,fgINT8,fgINT8,flgr_defop_addsat_fgINT8);
00979 }
00980 void flgr1d_arith_addsat_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00981   #ifdef __SSE2__
00982      flgr1d_arith_addsat_SSE2_fgINT16(datdest,data1,data2);
00983   #else
00984     #ifdef __SSE__
00985        flgr1d_arith_addsat_SSE_fgINT16(datdest,data1,data2);
00986     #else
00987        FLGR_MACRO_ARITH_1D_DIADIC(fgINT16,fgINT16,fgINT16,flgr_defop_addsat_fgINT16);
00988     #endif
00989   #endif
00990 }
00991 void flgr1d_arith_addsat_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00992   FLGR_MACRO_ARITH_1D_DIADIC(fgINT32,fgINT32,fgINT32,flgr_defop_addsat_fgINT32);
00993 }
00994 void flgr1d_arith_addsat_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00995   flgr_no_define_type_function(FLGR_FLOAT32);
00996 }
00997 void flgr1d_arith_addsat_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
00998   flgr_no_define_type_function(FLGR_FLOAT64);
00999 }
01000 
01002 
01008 
01009 FLGR_Ret flgr1d_arith_addsat(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01010   FLGR_Ret ret;
01011   
01012 
01013   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
01014     POST_ERROR("Null objects!\n");
01015     return FLGR_RET_NULL_OBJECT;
01016   }
01017 
01018   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
01019   if((ret = flgr1d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
01020 
01021   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_addsat,datdest,data1,data2);
01022 
01023 }
01024 
01025 
01026 
01027 /*******************************************************************************
01028  * DIV
01029  *******************************************************************************/
01030 
01031 void flgr1d_arith_div_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01032   flgr_no_define_type_function(FLGR_BIT);
01033 }
01034 void flgr1d_arith_div_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01035   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT8,fgUINT8,fgUINT8,flgr_defop_div_fgUINT8);
01036 }
01037 void flgr1d_arith_div_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01038   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT16,fgUINT16,fgUINT16,flgr_defop_div_fgUINT16);
01039 }
01040 void flgr1d_arith_div_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01041   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT32,fgUINT32,fgUINT32,flgr_defop_div_fgUINT32);
01042 }
01043 void flgr1d_arith_div_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01044   FLGR_MACRO_ARITH_1D_DIADIC(fgINT8,fgINT8,fgINT8,flgr_defop_div_fgINT8);
01045 }
01046 void flgr1d_arith_div_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01047   FLGR_MACRO_ARITH_1D_DIADIC(fgINT16,fgINT16,fgINT16,flgr_defop_div_fgINT16);
01048 }
01049 void flgr1d_arith_div_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01050   FLGR_MACRO_ARITH_1D_DIADIC(fgINT32,fgINT32,fgINT32,flgr_defop_div_fgINT32);
01051 }
01052 void flgr1d_arith_div_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01053   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT32,fgFLOAT32,fgFLOAT32,flgr_defop_div_fgFLOAT32);
01054 }
01055 void flgr1d_arith_div_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01056   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT64,fgFLOAT64,fgFLOAT64,flgr_defop_div_fgFLOAT64);
01057 }
01058 
01060 
01066 
01067 FLGR_Ret flgr1d_arith_div(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01068   FLGR_Ret ret;
01069 
01070   
01071 
01072   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
01073     POST_ERROR("Null objects!\n");
01074     return FLGR_RET_NULL_OBJECT;
01075   }
01076 
01077   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
01078   if((ret = flgr1d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
01079 
01080   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_div,datdest,data1,data2);
01081 
01082 }
01083 
01084 
01085 
01086 /*******************************************************************************
01087  * MULT
01088  *******************************************************************************/
01089 
01090 void flgr1d_arith_mult_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01091   flgr_no_define_type_function(FLGR_BIT);
01092 }
01093 void flgr1d_arith_mult_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01094   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT8,fgUINT8,fgUINT8,flgr_defop_mult_fgUINT8);
01095 }
01096 void flgr1d_arith_mult_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01097   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT16,fgUINT16,fgUINT16,flgr_defop_mult_fgUINT16);
01098 }
01099 void flgr1d_arith_mult_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01100   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT32,fgUINT32,fgUINT32,flgr_defop_mult_fgUINT32);
01101 }
01102 void flgr1d_arith_mult_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01103   FLGR_MACRO_ARITH_1D_DIADIC(fgINT8,fgINT8,fgINT8,flgr_defop_mult_fgINT8);
01104 }
01105 void flgr1d_arith_mult_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01106   FLGR_MACRO_ARITH_1D_DIADIC(fgINT16,fgINT16,fgINT16,flgr_defop_mult_fgINT16);
01107 }
01108 void flgr1d_arith_mult_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01109   FLGR_MACRO_ARITH_1D_DIADIC(fgINT32,fgINT32,fgINT32,flgr_defop_mult_fgINT32);
01110 }
01111 void flgr1d_arith_mult_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01112   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT32,fgFLOAT32,fgFLOAT32,flgr_defop_mult_fgFLOAT32);
01113 }
01114 void flgr1d_arith_mult_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01115   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT64,fgFLOAT64,fgFLOAT64,flgr_defop_mult_fgFLOAT64);
01116 }
01117 
01119 
01125 
01126 FLGR_Ret flgr1d_arith_mult(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01127   FLGR_Ret ret;
01128 
01129   
01130 
01131   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
01132     POST_ERROR("Null objects!\n");
01133     return FLGR_RET_NULL_OBJECT;
01134   }
01135 
01136   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
01137   if((ret = flgr1d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
01138 
01139   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_mult,datdest,data1,data2);
01140 
01141 }
01142 
01143 
01144 /*******************************************************************************
01145  * SUB
01146  *******************************************************************************/
01147 
01148 void flgr1d_arith_sub_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01149   #ifdef __SSE2__
01150      flgr1d_arith_sub_SSE2_fgBIT(datdest,data1,data2);
01151   #else
01152     #ifdef __SSE__
01153        flgr1d_arith_sub_SSE_fgBIT(datdest,data1,data2);
01154     #else
01155        FLGR_MACRO_ARITH_1D_DIADIC(fgBIT,fgBIT,fgBIT,flgr_defop_xor_fgBIT);
01156     #endif
01157   #endif
01158 }
01159 void flgr1d_arith_sub_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01160   #ifdef __SSE2__
01161      flgr1d_arith_sub_SSE2_fgUINT8(datdest,data1,data2);
01162   #else
01163     #ifdef __SSE__
01164        flgr1d_arith_sub_SSE_fgUINT8(datdest,data1,data2);
01165     #else
01166        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT8,fgUINT8,fgUINT8,flgr_defop_sub_a_b_fgUINT8);
01167     #endif
01168   #endif
01169 }
01170 void flgr1d_arith_sub_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01171   #ifdef __SSE2__
01172      flgr1d_arith_sub_SSE2_fgUINT16(datdest,data1,data2);
01173   #else
01174     #ifdef __SSE__
01175        flgr1d_arith_sub_SSE_fgUINT16(datdest,data1,data2);
01176     #else
01177        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT16,fgUINT16,fgUINT16,flgr_defop_sub_a_b_fgUINT16);
01178     #endif
01179   #endif
01180 }
01181 void flgr1d_arith_sub_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01182   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT32,fgUINT32,fgUINT32,flgr_defop_sub_a_b_fgUINT32);
01183 }
01184 void flgr1d_arith_sub_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01185   #ifdef __SSE2__
01186      flgr1d_arith_sub_SSE2_fgINT8(datdest,data1,data2);
01187   #else
01188     #ifdef __SSE__
01189        flgr1d_arith_sub_SSE_fgINT8(datdest,data1,data2);
01190     #else
01191        FLGR_MACRO_ARITH_1D_DIADIC(fgINT8,fgINT8,fgINT8,flgr_defop_sub_a_b_fgINT8);
01192     #endif
01193   #endif
01194 }
01195 void flgr1d_arith_sub_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01196   #ifdef __SSE2__
01197      flgr1d_arith_sub_SSE2_fgINT16(datdest,data1,data2);
01198   #else
01199     #ifdef __SSE__
01200        flgr1d_arith_sub_SSE_fgINT16(datdest,data1,data2);
01201     #else
01202        FLGR_MACRO_ARITH_1D_DIADIC(fgINT16,fgINT16,fgINT16,flgr_defop_sub_a_b_fgINT16);
01203     #endif
01204   #endif
01205 }
01206 void flgr1d_arith_sub_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01207   FLGR_MACRO_ARITH_1D_DIADIC(fgINT32,fgINT32,fgINT32,flgr_defop_sub_a_b_fgINT32);
01208 }
01209 void flgr1d_arith_sub_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01210   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT32,fgFLOAT32,fgFLOAT32,flgr_defop_sub_a_b_fgFLOAT32);
01211 }
01212 void flgr1d_arith_sub_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01213   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT64,fgFLOAT64,fgFLOAT64,flgr_defop_sub_a_b_fgFLOAT64);
01214 }
01215 
01217 
01223 
01224 FLGR_Ret flgr1d_arith_sub(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01225   FLGR_Ret ret;
01226 
01227   
01228 
01229   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
01230     POST_ERROR("Null objects!\n");
01231     return FLGR_RET_NULL_OBJECT;
01232   }
01233 
01234   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
01235   if((ret = flgr1d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
01236 
01237   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_sub,datdest,data1,data2);
01238 
01239 }
01240 
01241 
01242 /*******************************************************************************
01243  * ADD
01244  *******************************************************************************/
01245 
01246 void flgr1d_arith_add_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01247   #ifdef __SSE2__
01248      flgr1d_arith_add_SSE2_fgBIT(datdest,data1,data2);
01249   #else
01250     #ifdef __SSE__
01251        flgr1d_arith_add_SSE_fgBIT(datdest,data1,data2);
01252     #else
01253        FLGR_MACRO_ARITH_1D_DIADIC(fgBIT,fgBIT,fgBIT,flgr_defop_xor_fgBIT);
01254     #endif
01255   #endif
01256 }
01257 void flgr1d_arith_add_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01258   #ifdef __SSE2__
01259      flgr1d_arith_add_SSE2_fgUINT8(datdest,data1,data2);
01260   #else
01261     #ifdef __SSE__
01262        flgr1d_arith_add_SSE_fgUINT8(datdest,data1,data2);
01263     #else
01264        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT8,fgUINT8,fgUINT8,flgr_defop_add_fgUINT8);
01265     #endif
01266   #endif
01267 }
01268 void flgr1d_arith_add_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01269   #ifdef __SSE2__
01270      flgr1d_arith_add_SSE2_fgUINT16(datdest,data1,data2);
01271   #else
01272     #ifdef __SSE__
01273        flgr1d_arith_add_SSE_fgUINT16(datdest,data1,data2);
01274     #else
01275        FLGR_MACRO_ARITH_1D_DIADIC(fgUINT16,fgUINT16,fgUINT16,flgr_defop_add_fgUINT16);
01276     #endif
01277   #endif
01278 }
01279 void flgr1d_arith_add_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01280   FLGR_MACRO_ARITH_1D_DIADIC(fgUINT32,fgUINT32,fgUINT32,flgr_defop_add_fgUINT32);
01281 }
01282 void flgr1d_arith_add_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01283   #ifdef __SSE2__
01284      flgr1d_arith_add_SSE2_fgINT8(datdest,data1,data2);
01285   #else
01286     #ifdef __SSE__
01287        flgr1d_arith_add_SSE_fgINT8(datdest,data1,data2);
01288     #else
01289        FLGR_MACRO_ARITH_1D_DIADIC(fgINT8,fgINT8,fgINT8,flgr_defop_add_fgINT8);
01290     #endif
01291   #endif
01292 }
01293 void flgr1d_arith_add_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01294   #ifdef __SSE2__
01295      flgr1d_arith_add_SSE2_fgINT16(datdest,data1,data2);
01296   #else
01297     #ifdef __SSE__
01298        flgr1d_arith_add_SSE_fgINT16(datdest,data1,data2);
01299     #else
01300        FLGR_MACRO_ARITH_1D_DIADIC(fgINT16,fgINT16,fgINT16,flgr_defop_add_fgINT16);
01301     #endif
01302   #endif
01303 }
01304 void flgr1d_arith_add_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01305   FLGR_MACRO_ARITH_1D_DIADIC(fgINT32,fgINT32,fgINT32,flgr_defop_add_fgINT32);
01306 }
01307 void flgr1d_arith_add_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01308   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT32,fgFLOAT32,fgFLOAT32,flgr_defop_add_fgFLOAT32);
01309 }
01310 void flgr1d_arith_add_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01311   FLGR_MACRO_ARITH_1D_DIADIC(fgFLOAT64,fgFLOAT64,fgFLOAT64,flgr_defop_add_fgFLOAT64);
01312 }
01313 
01315 
01321 
01322 FLGR_Ret flgr1d_arith_add(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Data1D *data2) {
01323   FLGR_Ret ret;
01324 
01325   
01326 
01327   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
01328     POST_ERROR("Null objects!\n");
01329     return FLGR_RET_NULL_OBJECT;
01330   }
01331 
01332   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
01333   if((ret = flgr1d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
01334 
01335   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_add,datdest,data1,data2);
01336 
01337 }
01338 
01339 
01340 
01341 
01342 
01343 /*******************************************************************************
01344  *******************************************************************************
01345  *******************************************************************************
01346  * DIADIC CONST OPERATIONS
01347  *******************************************************************************
01348  *******************************************************************************
01349  *******************************************************************************/
01350 
01351 
01352 /*******************************************************************************
01353  * INF CONST
01354  *******************************************************************************/
01355 
01356 void flgr1d_arith_const_inf_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01357   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgBIT,fgBIT,flgr_defop_inf_fgBIT);
01358 }
01359 void flgr1d_arith_const_inf_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01360   #ifdef __SSE2__
01361     if(datdest->spp==1) {
01362       flgr1d_arith_const_inf_spp1_SSE2_fgUINT8(datdest,data1,vec_const);
01363     }else {
01364       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_inf_fgUINT8);
01365     }
01366   #else
01367     #ifdef __SSE__
01368       if(datdest->spp==1) {
01369         flgr1d_arith_const_inf_spp1_SSE_fgUINT8(datdest,data1,vec_const);
01370       }else {
01371         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_inf_fgUINT8);
01372       }
01373     #else
01374        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_inf_fgUINT8);
01375     #endif
01376   #endif
01377 }
01378 void flgr1d_arith_const_inf_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01379   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_inf_fgUINT16);
01380 }
01381 void flgr1d_arith_const_inf_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01382   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_inf_fgUINT32);
01383 }
01384 void flgr1d_arith_const_inf_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01385   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_inf_fgINT8);
01386 }
01387 void flgr1d_arith_const_inf_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01388   #ifdef __SSE2__
01389     if(datdest->spp==1) {
01390       flgr1d_arith_const_inf_spp1_SSE2_fgINT16(datdest,data1,vec_const);
01391     }else {
01392       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_inf_fgINT16);
01393     }
01394   #else
01395     #ifdef __SSE__
01396       if(datdest->spp==1) {
01397         flgr1d_arith_const_inf_spp1_SSE_fgINT16(datdest,data1,vec_const);
01398       }else {
01399         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_inf_fgINT16);
01400       }
01401     #else
01402        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_inf_fgINT16);
01403     #endif
01404   #endif
01405 }
01406 void flgr1d_arith_const_inf_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01407   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_inf_fgINT32);
01408 }
01409 void flgr1d_arith_const_inf_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01410   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT32,fgFLOAT32,flgr_defop_inf_fgFLOAT32);
01411 }
01412 void flgr1d_arith_const_inf_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01413   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT64,fgFLOAT64,flgr_defop_inf_fgFLOAT64);
01414 }
01415 
01417 
01423 
01424 FLGR_Ret flgr1d_arith_const_inf_ptr(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01425   FLGR_Ret ret;
01426 
01427   
01428 
01429   if((datdest==NULL) || (data1==NULL)) {
01430     POST_ERROR("Null objects!\n");
01431     return FLGR_RET_NULL_OBJECT;
01432   }
01433 
01434   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
01435 
01436   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_const_inf,datdest,data1,vec_const);
01437 }
01438 
01440 
01446 
01447 FLGR_Ret flgr1d_arith_const_inf_str(FLGR_Data1D *datdest, FLGR_Data1D *data1, char *constant) {
01448   int ret;
01449   FLGR_Vector *vector_constant;
01450 
01451   if((data1==NULL) || (datdest==NULL))  {
01452     POST_ERROR("Null objects!\n");
01453     return FLGR_RET_NULL_OBJECT;
01454   }
01455 
01456   vector_constant = flgr_vector_create(data1->spp,data1->type);
01457 
01458   if((ret=flgr_vector_import_string(vector_constant, constant))
01459      != FLGR_RET_OK) {
01460 
01461     POST_ERROR("String is not valid ""%s""\n",constant);
01462     flgr_vector_destroy(vector_constant);
01463     return ret;
01464   }
01465 
01466 
01467   ret = flgr1d_arith_const_inf_ptr(datdest,data1,vector_constant);
01468 
01469   flgr_vector_destroy(vector_constant);
01470 
01471   return ret;
01472 
01473 }
01474 
01475 
01476 
01477 
01478 /*******************************************************************************
01479  * SUP CONST
01480  *******************************************************************************/
01481 
01482 void flgr1d_arith_const_sup_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01483   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgBIT,fgBIT,flgr_defop_sup_fgBIT);
01484 }
01485 void flgr1d_arith_const_sup_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01486   #ifdef __SSE2__
01487     if(datdest->spp==1) {
01488       flgr1d_arith_const_sup_spp1_SSE2_fgUINT8(datdest,data1,vec_const);
01489     }else {
01490       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_sup_fgUINT8);
01491     }
01492   #else
01493     #ifdef __SSE__
01494       if(datdest->spp==1) {
01495         flgr1d_arith_const_sup_spp1_SSE_fgUINT8(datdest,data1,vec_const);
01496       }else {
01497         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_sup_fgUINT8);
01498       }
01499     #else
01500        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_sup_fgUINT8);
01501     #endif
01502   #endif
01503 }
01504 void flgr1d_arith_const_sup_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01505   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_sup_fgUINT16);
01506 }
01507 void flgr1d_arith_const_sup_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01508   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_sup_fgUINT32);
01509 }
01510 void flgr1d_arith_const_sup_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01511   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_sup_fgINT8);
01512 }
01513 void flgr1d_arith_const_sup_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01514   #ifdef __SSE2__
01515     if(datdest->spp==1) {
01516       flgr1d_arith_const_sup_spp1_SSE2_fgINT16(datdest,data1,vec_const);
01517     }else {
01518       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_sup_fgINT16);
01519     }
01520   #else
01521     #ifdef __SSE__
01522       if(datdest->spp==1) {
01523         flgr1d_arith_const_sup_spp1_SSE_fgINT16(datdest,data1,vec_const);
01524       }else {
01525         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_sup_fgINT16);
01526       }
01527     #else
01528        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_sup_fgINT16);
01529     #endif
01530   #endif
01531 }
01532 void flgr1d_arith_const_sup_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01533   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_sup_fgINT32);
01534 }
01535 void flgr1d_arith_const_sup_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01536   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT32,fgFLOAT32,flgr_defop_sup_fgFLOAT32);
01537 }
01538 void flgr1d_arith_const_sup_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01539   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT64,fgFLOAT64,flgr_defop_sup_fgFLOAT64);
01540 }
01541 
01543 
01549 
01550 FLGR_Ret flgr1d_arith_const_sup_ptr(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01551   FLGR_Ret ret;
01552 
01553   
01554 
01555   if((datdest==NULL) || (data1==NULL)) {
01556     POST_ERROR("Null objects!\n");
01557     return FLGR_RET_NULL_OBJECT;
01558   }
01559 
01560   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
01561 
01562   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_const_sup,datdest,data1,vec_const);
01563 }
01564 
01566 
01572 
01573 FLGR_Ret flgr1d_arith_const_sup_str(FLGR_Data1D *datdest, FLGR_Data1D *data1, char *constant) {
01574   int ret;
01575   FLGR_Vector *vector_constant;
01576 
01577   if((data1==NULL) || (datdest==NULL))  {
01578     POST_ERROR("Null objects!\n");
01579     return FLGR_RET_NULL_OBJECT;
01580   }
01581 
01582   vector_constant = flgr_vector_create(data1->spp,data1->type);
01583 
01584   if((ret=flgr_vector_import_string(vector_constant, constant))
01585      != FLGR_RET_OK) {
01586 
01587     POST_ERROR("String is not valid ""%s""\n",constant);
01588     flgr_vector_destroy(vector_constant);
01589     return ret;
01590   }
01591 
01592   ret = flgr1d_arith_const_sup_ptr(datdest,data1,vector_constant);
01593 
01594   flgr_vector_destroy(vector_constant);
01595 
01596 
01597   return ret;
01598 
01599 }
01600 
01601 
01602 
01603 /*******************************************************************************
01604  * AND CONST
01605  *******************************************************************************/
01606 
01607 void flgr1d_arith_const_and_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01608   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgBIT,fgBIT,flgr_defop_and_fgBIT);
01609 }
01610 void flgr1d_arith_const_and_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01611   #ifdef __SSE2__
01612     if(datdest->spp==1) {
01613       flgr1d_arith_const_and_spp1_SSE2_fgUINT8(datdest,data1,vec_const);
01614     }else {
01615       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_and_fgUINT8);
01616     }
01617   #else
01618     #ifdef __SSE__
01619       if(datdest->spp==1) {
01620         flgr1d_arith_const_and_spp1_SSE_fgUINT8(datdest,data1,vec_const);
01621       }else {
01622         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_and_fgUINT8);
01623       }
01624     #else
01625        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_and_fgUINT8);
01626     #endif
01627   #endif
01628 }
01629 void flgr1d_arith_const_and_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01630   #ifdef __SSE2__
01631     if(datdest->spp==1) {
01632       flgr1d_arith_const_and_spp1_SSE2_fgUINT16(datdest,data1,vec_const);
01633     }else {
01634       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_and_fgUINT16);
01635     }
01636   #else
01637     #ifdef __SSE__
01638       if(datdest->spp==1) {
01639         flgr1d_arith_const_and_spp1_SSE_fgUINT16(datdest,data1,vec_const);
01640       }else {
01641         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_and_fgUINT16);
01642       }
01643     #else
01644        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_and_fgUINT16);
01645     #endif
01646   #endif
01647 }
01648 void flgr1d_arith_const_and_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01649   #ifdef __SSE2__
01650     if(datdest->spp==1) {
01651       flgr1d_arith_const_and_spp1_SSE2_fgUINT32(datdest,data1,vec_const);
01652     }else {
01653       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_and_fgUINT32);
01654     }
01655   #else
01656     #ifdef __SSE__
01657       if(datdest->spp==1) {
01658         flgr1d_arith_const_and_spp1_SSE_fgUINT32(datdest,data1,vec_const);
01659       }else {
01660         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_and_fgUINT32);
01661       }
01662     #else
01663        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_and_fgUINT32);
01664     #endif
01665   #endif
01666 }
01667 void flgr1d_arith_const_and_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01668   #ifdef __SSE2__
01669     if(datdest->spp==1) {
01670       flgr1d_arith_const_and_spp1_SSE2_fgINT8(datdest,data1,vec_const);
01671     }else {
01672       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_and_fgINT8);
01673     }
01674   #else
01675     #ifdef __SSE__
01676       if(datdest->spp==1) {
01677         flgr1d_arith_const_and_spp1_SSE_fgINT8(datdest,data1,vec_const);
01678       }else {
01679         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_and_fgINT8);
01680       }
01681     #else
01682        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_and_fgINT8);
01683     #endif
01684   #endif
01685 }
01686 void flgr1d_arith_const_and_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01687   #ifdef __SSE2__
01688     if(datdest->spp==1) {
01689       flgr1d_arith_const_and_spp1_SSE2_fgINT16(datdest,data1,vec_const);
01690     }else {
01691       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_and_fgINT16);
01692     }
01693   #else
01694     #ifdef __SSE__
01695       if(datdest->spp==1) {
01696         flgr1d_arith_const_and_spp1_SSE_fgINT16(datdest,data1,vec_const);
01697       }else {
01698         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_and_fgINT16);
01699       }
01700     #else
01701        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_and_fgINT16);
01702     #endif
01703   #endif
01704 }
01705 void flgr1d_arith_const_and_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01706   #ifdef __SSE2__
01707     if(datdest->spp==1) {
01708       flgr1d_arith_const_and_spp1_SSE2_fgINT32(datdest,data1,vec_const);
01709     }else {
01710       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_and_fgINT32);
01711     }
01712   #else
01713     #ifdef __SSE__
01714       if(datdest->spp==1) {
01715         flgr1d_arith_const_and_spp1_SSE_fgINT32(datdest,data1,vec_const);
01716       }else {
01717         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_and_fgINT32);
01718       }
01719     #else
01720        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_and_fgINT32);
01721     #endif
01722   #endif
01723 }
01724 void flgr1d_arith_const_and_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01725   flgr_no_define_type_function(FLGR_FLOAT32);
01726 }
01727 void flgr1d_arith_const_and_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01728   flgr_no_define_type_function(FLGR_FLOAT64);
01729 }
01730 
01732 
01738 
01739 FLGR_Ret flgr1d_arith_const_and_ptr(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01740   FLGR_Ret ret;
01741 
01742   
01743 
01744   if((datdest==NULL) || (data1==NULL)) {
01745     POST_ERROR("Null objects!\n");
01746     return FLGR_RET_NULL_OBJECT;
01747   }
01748 
01749   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
01750 
01751   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_const_and,datdest,data1,vec_const);
01752 }
01753 
01755 
01761 
01762 FLGR_Ret flgr1d_arith_const_and_str(FLGR_Data1D *datdest, FLGR_Data1D *data1, char *constant) {
01763   int ret;
01764   FLGR_Vector *vector_constant;
01765 
01766   if((data1==NULL) || (datdest==NULL))  {
01767     POST_ERROR("Null objects!\n");
01768     return FLGR_RET_NULL_OBJECT;
01769   }
01770 
01771   vector_constant = flgr_vector_create(data1->spp,data1->type);
01772 
01773   if((ret=flgr_vector_import_string(vector_constant, constant))
01774      != FLGR_RET_OK) {
01775 
01776     POST_ERROR("String is not valid ""%s""\n",constant);
01777     flgr_vector_destroy(vector_constant);
01778     return ret;
01779   }
01780 
01781 
01782 
01783   ret = flgr1d_arith_const_and_ptr(datdest,data1,vector_constant);
01784 
01785   flgr_vector_destroy(vector_constant);
01786 
01787 
01788   return ret;
01789 
01790 }
01791 
01792 
01793 
01794 /*******************************************************************************
01795  * OR CONST
01796  *******************************************************************************/
01797 
01798 void flgr1d_arith_const_or_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01799   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgBIT,fgBIT,flgr_defop_or_fgBIT);
01800 }
01801 void flgr1d_arith_const_or_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01802   #ifdef __SSE2__
01803     if(datdest->spp==1) {
01804       flgr1d_arith_const_or_spp1_SSE2_fgUINT8(datdest,data1,vec_const);
01805     }else {
01806       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_or_fgUINT8);
01807     }
01808   #else
01809     #ifdef __SSE__
01810       if(datdest->spp==1) {
01811         flgr1d_arith_const_or_spp1_SSE_fgUINT8(datdest,data1,vec_const);
01812       }else {
01813         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_or_fgUINT8);
01814       }
01815     #else
01816        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_or_fgUINT8);
01817     #endif
01818   #endif
01819 }
01820 void flgr1d_arith_const_or_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01821   #ifdef __SSE2__
01822     if(datdest->spp==1) {
01823       flgr1d_arith_const_or_spp1_SSE2_fgUINT16(datdest,data1,vec_const);
01824     }else {
01825       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_or_fgUINT16);
01826     }
01827   #else
01828     #ifdef __SSE__
01829       if(datdest->spp==1) {
01830         flgr1d_arith_const_or_spp1_SSE_fgUINT16(datdest,data1,vec_const);
01831       }else {
01832         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_or_fgUINT16);
01833       }
01834     #else
01835        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_or_fgUINT16);
01836     #endif
01837   #endif
01838 }
01839 void flgr1d_arith_const_or_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01840   #ifdef __SSE2__
01841     if(datdest->spp==1) {
01842       flgr1d_arith_const_or_spp1_SSE2_fgUINT32(datdest,data1,vec_const);
01843     }else {
01844       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_or_fgUINT32);
01845     }
01846   #else
01847     #ifdef __SSE__
01848       if(datdest->spp==1) {
01849         flgr1d_arith_const_or_spp1_SSE_fgUINT32(datdest,data1,vec_const);
01850       }else {
01851         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_or_fgUINT32);
01852       }
01853     #else
01854        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_or_fgUINT32);
01855     #endif
01856   #endif
01857 }
01858 void flgr1d_arith_const_or_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01859   #ifdef __SSE2__
01860     if(datdest->spp==1) {
01861       flgr1d_arith_const_or_spp1_SSE2_fgINT8(datdest,data1,vec_const);
01862     }else {
01863       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_or_fgINT8);
01864     }
01865   #else
01866     #ifdef __SSE__
01867       if(datdest->spp==1) {
01868         flgr1d_arith_const_or_spp1_SSE_fgINT8(datdest,data1,vec_const);
01869       }else {
01870         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_or_fgINT8);
01871       }
01872     #else
01873        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_or_fgINT8);
01874     #endif
01875   #endif
01876 }
01877 void flgr1d_arith_const_or_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01878   #ifdef __SSE2__
01879     if(datdest->spp==1) {
01880       flgr1d_arith_const_or_spp1_SSE2_fgINT16(datdest,data1,vec_const);
01881     }else {
01882       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_or_fgINT16);
01883     }
01884   #else
01885     #ifdef __SSE__
01886       if(datdest->spp==1) {
01887         flgr1d_arith_const_or_spp1_SSE_fgINT16(datdest,data1,vec_const);
01888       }else {
01889         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_or_fgINT16);
01890       }
01891     #else
01892        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_or_fgINT16);
01893     #endif
01894   #endif
01895 }
01896 void flgr1d_arith_const_or_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01897   #ifdef __SSE2__
01898     if(datdest->spp==1) {
01899       flgr1d_arith_const_or_spp1_SSE2_fgINT32(datdest,data1,vec_const);
01900     }else {
01901       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_or_fgINT32);
01902     }
01903   #else
01904     #ifdef __SSE__
01905       if(datdest->spp==1) {
01906         flgr1d_arith_const_or_spp1_SSE_fgINT32(datdest,data1,vec_const);
01907       }else {
01908         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_or_fgINT32);
01909       }
01910     #else
01911        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_or_fgINT32);
01912     #endif
01913   #endif
01914 }
01915 void flgr1d_arith_const_or_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01916   flgr_no_define_type_function(FLGR_FLOAT32);
01917 }
01918 void flgr1d_arith_const_or_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01919   flgr_no_define_type_function(FLGR_FLOAT64);
01920 }
01921 
01923 
01929 
01930 FLGR_Ret flgr1d_arith_const_or_ptr(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01931   FLGR_Ret ret;
01932 
01933   
01934 
01935   if((datdest==NULL) || (data1==NULL)) {
01936     POST_ERROR("Null objects!\n");
01937     return FLGR_RET_NULL_OBJECT;
01938   }
01939 
01940   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
01941 
01942   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_const_or,datdest,data1,vec_const);
01943 }
01944 
01946 
01952 
01953 FLGR_Ret flgr1d_arith_const_or_str(FLGR_Data1D *datdest, FLGR_Data1D *data1, char *constant) {
01954   int ret;
01955   FLGR_Vector *vector_constant;
01956 
01957   if((data1==NULL) || (datdest==NULL))  {
01958     POST_ERROR("Null objects!\n");
01959     return FLGR_RET_NULL_OBJECT;
01960   }
01961 
01962   vector_constant = flgr_vector_create(data1->spp,data1->type);
01963 
01964   if((ret=flgr_vector_import_string(vector_constant, constant))
01965      != FLGR_RET_OK) {
01966 
01967     POST_ERROR("String is not valid ""%s""\n",constant);
01968     flgr_vector_destroy(vector_constant);
01969     return ret;
01970   }
01971 
01972 
01973 
01974   ret = flgr1d_arith_const_or_ptr(datdest,data1,vector_constant);
01975 
01976   flgr_vector_destroy(vector_constant);
01977 
01978 
01979   return ret;
01980 
01981 }
01982 
01983 
01984 
01985 
01986 /*******************************************************************************
01987  * XOR CONST
01988  *******************************************************************************/
01989 
01990 void flgr1d_arith_const_xor_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01991   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgBIT,fgBIT,flgr_defop_xor_fgBIT);
01992 }
01993 void flgr1d_arith_const_xor_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
01994   #ifdef __SSE2__
01995     if(datdest->spp==1) {
01996       flgr1d_arith_const_xor_spp1_SSE2_fgUINT8(datdest,data1,vec_const);
01997     }else {
01998       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_xor_fgUINT8);
01999     }
02000   #else
02001     #ifdef __SSE__
02002       if(datdest->spp==1) {
02003         flgr1d_arith_const_xor_spp1_SSE_fgUINT8(datdest,data1,vec_const);
02004       }else {
02005         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_xor_fgUINT8);
02006       }
02007     #else
02008        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_xor_fgUINT8);
02009     #endif
02010   #endif
02011 }
02012 void flgr1d_arith_const_xor_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02013   #ifdef __SSE2__
02014     if(datdest->spp==1) {
02015       flgr1d_arith_const_xor_spp1_SSE2_fgUINT16(datdest,data1,vec_const);
02016     }else {
02017       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_xor_fgUINT16);
02018     }
02019   #else
02020     #ifdef __SSE__
02021       if(datdest->spp==1) {
02022         flgr1d_arith_const_xor_spp1_SSE_fgUINT16(datdest,data1,vec_const);
02023       }else {
02024         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_xor_fgUINT16);
02025       }
02026     #else
02027        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_xor_fgUINT16);
02028     #endif
02029   #endif
02030 }
02031 void flgr1d_arith_const_xor_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02032   #ifdef __SSE2__
02033     if(datdest->spp==1) {
02034       flgr1d_arith_const_xor_spp1_SSE2_fgUINT32(datdest,data1,vec_const);
02035     }else {
02036       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_xor_fgUINT32);
02037     }
02038   #else
02039     #ifdef __SSE__
02040       if(datdest->spp==1) {
02041         flgr1d_arith_const_xor_spp1_SSE_fgUINT32(datdest,data1,vec_const);
02042       }else {
02043         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_xor_fgUINT32);
02044       }
02045     #else
02046        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_xor_fgUINT32);
02047     #endif
02048   #endif
02049 }
02050 void flgr1d_arith_const_xor_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02051   #ifdef __SSE2__
02052     if(datdest->spp==1) {
02053       flgr1d_arith_const_xor_spp1_SSE2_fgINT8(datdest,data1,vec_const);
02054     }else {
02055       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_xor_fgINT8);
02056     }
02057   #else
02058     #ifdef __SSE__
02059       if(datdest->spp==1) {
02060         flgr1d_arith_const_xor_spp1_SSE_fgINT8(datdest,data1,vec_const);
02061       }else {
02062         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_xor_fgINT8);
02063       }
02064     #else
02065        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_xor_fgINT8);
02066     #endif
02067   #endif
02068 }
02069 void flgr1d_arith_const_xor_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02070   #ifdef __SSE2__
02071     if(datdest->spp==1) {
02072       flgr1d_arith_const_xor_spp1_SSE2_fgINT16(datdest,data1,vec_const);
02073     }else {
02074       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_xor_fgINT16);
02075     }
02076   #else
02077     #ifdef __SSE__
02078       if(datdest->spp==1) {
02079         flgr1d_arith_const_xor_spp1_SSE_fgINT16(datdest,data1,vec_const);
02080       }else {
02081         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_xor_fgINT16);
02082       }
02083     #else
02084        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_xor_fgINT16);
02085     #endif
02086   #endif
02087 }
02088 void flgr1d_arith_const_xor_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02089   #ifdef __SSE2__
02090     if(datdest->spp==1) {
02091       flgr1d_arith_const_xor_spp1_SSE2_fgINT32(datdest,data1,vec_const);
02092     }else {
02093       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_xor_fgINT32);
02094     }
02095   #else
02096     #ifdef __SSE__
02097       if(datdest->spp==1) {
02098         flgr1d_arith_const_xor_spp1_SSE_fgINT32(datdest,data1,vec_const);
02099       }else {
02100         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_xor_fgINT32);
02101       }
02102     #else
02103        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_xor_fgINT32);
02104     #endif
02105   #endif
02106 }
02107 void flgr1d_arith_const_xor_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02108   flgr_no_define_type_function(FLGR_FLOAT32);
02109 }
02110 void flgr1d_arith_const_xor_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02111   flgr_no_define_type_function(FLGR_FLOAT64);
02112 }
02113 
02115 
02121 
02122 FLGR_Ret flgr1d_arith_const_xor_ptr(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02123   FLGR_Ret ret;
02124 
02125   
02126 
02127   if((datdest==NULL) || (data1==NULL)) {
02128     POST_ERROR("Null objects!\n");
02129     return FLGR_RET_NULL_OBJECT;
02130   }
02131 
02132   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
02133 
02134   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_const_xor,datdest,data1,vec_const);
02135 }
02136 
02138 
02144 
02145 FLGR_Ret flgr1d_arith_const_xor_str(FLGR_Data1D *datdest, FLGR_Data1D *data1, char *constant) {
02146   int ret;
02147   FLGR_Vector *vector_constant;
02148 
02149   if((data1==NULL) || (datdest==NULL))  {
02150     POST_ERROR("Null objects!\n");
02151     return FLGR_RET_NULL_OBJECT;
02152   }
02153 
02154   vector_constant = flgr_vector_create(data1->spp,data1->type);
02155 
02156   if((ret=flgr_vector_import_string(vector_constant, constant))
02157      != FLGR_RET_OK) {
02158 
02159     POST_ERROR("String is not valid ""%s""\n",constant);
02160     flgr_vector_destroy(vector_constant);
02161     return ret;
02162   }
02163 
02164 
02165 
02166   ret = flgr1d_arith_const_xor_ptr(datdest,data1,vector_constant);
02167 
02168   flgr_vector_destroy(vector_constant);
02169 
02170 
02171   return ret;
02172 
02173 }
02174 
02175 
02176 
02177 
02178 
02179 /*******************************************************************************
02180  * ATAN2 CONST
02181  *******************************************************************************/
02182 
02183 void flgr1d_arith_const_atan2_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02184   flgr_no_define_type_function(FLGR_BIT);
02185 }
02186 void flgr1d_arith_const_atan2_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02187   flgr_no_define_type_function(FLGR_UINT8);
02188 }
02189 void flgr1d_arith_const_atan2_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02190   flgr_no_define_type_function(FLGR_UINT16);
02191 }
02192 void flgr1d_arith_const_atan2_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02193   flgr_no_define_type_function(FLGR_UINT32);
02194 }
02195 void flgr1d_arith_const_atan2_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02196   flgr_no_define_type_function(FLGR_INT8);
02197 }
02198 void flgr1d_arith_const_atan2_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02199   flgr_no_define_type_function(FLGR_INT16);
02200 }
02201 void flgr1d_arith_const_atan2_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02202   flgr_no_define_type_function(FLGR_INT32);
02203 }
02204 void flgr1d_arith_const_atan2_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02205   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT32,fgFLOAT32,flgr_defop_atan2_fgFLOAT32);
02206 }
02207 void flgr1d_arith_const_atan2_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02208   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT64,fgFLOAT64,flgr_defop_atan2_fgFLOAT64);
02209 }
02210 
02212 
02218 
02219 FLGR_Ret flgr1d_arith_const_atan2_ptr(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02220   FLGR_Ret ret;
02221 
02222   
02223 
02224   if((datdest==NULL) || (data1==NULL)) {
02225     POST_ERROR("Null objects!\n");
02226     return FLGR_RET_NULL_OBJECT;
02227   }
02228 
02229   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
02230 
02231   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_const_atan2,datdest,data1,vec_const);
02232 }
02233 
02235 
02241 
02242 FLGR_Ret flgr1d_arith_const_atan2_str(FLGR_Data1D *datdest, FLGR_Data1D *data1, char *constant) {
02243   int ret;
02244   FLGR_Vector *vector_constant;
02245 
02246   if((data1==NULL) || (datdest==NULL))  {
02247     POST_ERROR("Null objects!\n");
02248     return FLGR_RET_NULL_OBJECT;
02249   }
02250 
02251   vector_constant = flgr_vector_create(data1->spp,data1->type);
02252 
02253   if((ret=flgr_vector_import_string(vector_constant, constant))
02254      != FLGR_RET_OK) {
02255 
02256     POST_ERROR("String is not valid ""%s""\n",constant);
02257     flgr_vector_destroy(vector_constant);
02258     return ret;
02259   }
02260 
02261 
02262 
02263   ret = flgr1d_arith_const_atan2_ptr(datdest,data1,vector_constant);
02264 
02265   flgr_vector_destroy(vector_constant);
02266 
02267 
02268   return ret;
02269 
02270 }
02271 
02272 
02273 
02274 
02275 
02276 
02277 /*******************************************************************************
02278  * ARGUMENT CONST
02279  *******************************************************************************/
02280 
02281 void flgr1d_arith_const_argument_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02282   flgr_no_define_type_function(FLGR_BIT);
02283 }
02284 void flgr1d_arith_const_argument_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02285   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_argument_fgUINT8);
02286 }
02287 void flgr1d_arith_const_argument_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02288   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_argument_fgUINT16);
02289 }
02290 void flgr1d_arith_const_argument_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02291   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_argument_fgUINT32);
02292 }
02293 void flgr1d_arith_const_argument_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02294   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_argument_fgINT8);
02295 }
02296 void flgr1d_arith_const_argument_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02297   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_argument_fgINT16);
02298 }
02299 void flgr1d_arith_const_argument_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02300   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_argument_fgINT32);
02301 }
02302 void flgr1d_arith_const_argument_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02303   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT32,fgFLOAT32,flgr_defop_argument_fgFLOAT32);
02304 }
02305 void flgr1d_arith_const_argument_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02306   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT64,fgFLOAT64,flgr_defop_argument_fgFLOAT64);
02307 }
02308 
02310 
02316 
02317 FLGR_Ret flgr1d_arith_const_argument_ptr(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02318   FLGR_Ret ret;
02319 
02320   
02321 
02322   if((datdest==NULL) || (data1==NULL)) {
02323     POST_ERROR("Null objects!\n");
02324     return FLGR_RET_NULL_OBJECT;
02325   }
02326 
02327   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
02328 
02329   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_const_argument,datdest,data1,vec_const);
02330 }
02331 
02333 
02339 
02340 FLGR_Ret flgr1d_arith_const_argument_str(FLGR_Data1D *datdest, FLGR_Data1D *data1, char *constant) {
02341   int ret;
02342   FLGR_Vector *vector_constant;
02343 
02344   if((data1==NULL) || (datdest==NULL))  {
02345     POST_ERROR("Null objects!\n");
02346     return FLGR_RET_NULL_OBJECT;
02347   }
02348 
02349   vector_constant = flgr_vector_create(data1->spp,data1->type);
02350 
02351   if((ret=flgr_vector_import_string(vector_constant, constant))
02352      != FLGR_RET_OK) {
02353 
02354     POST_ERROR("String is not valid ""%s""\n",constant);
02355     flgr_vector_destroy(vector_constant);
02356     return ret;
02357   }
02358 
02359 
02360 
02361   ret = flgr1d_arith_const_argument_ptr(datdest,data1,vector_constant);
02362 
02363   flgr_vector_destroy(vector_constant);
02364 
02365 
02366   return ret;
02367 
02368 }
02369 
02370 
02371 
02372 
02373 
02374 
02375 
02376 /*******************************************************************************
02377  * MODULE CONST
02378  *******************************************************************************/
02379 
02380 void flgr1d_arith_const_module_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02381   flgr_no_define_type_function(FLGR_BIT);
02382 }
02383 void flgr1d_arith_const_module_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02384   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_module_fgUINT8);
02385 }
02386 void flgr1d_arith_const_module_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02387   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_module_fgUINT16);
02388 }
02389 void flgr1d_arith_const_module_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02390   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_module_fgUINT32);
02391 }
02392 void flgr1d_arith_const_module_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02393   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_module_fgINT8);
02394 }
02395 void flgr1d_arith_const_module_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02396   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_module_fgINT16);
02397 }
02398 void flgr1d_arith_const_module_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02399   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_module_fgINT32);
02400 }
02401 void flgr1d_arith_const_module_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02402   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT32,fgFLOAT32,flgr_defop_module_fgFLOAT32);
02403 }
02404 void flgr1d_arith_const_module_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02405   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT64,fgFLOAT64,flgr_defop_module_fgFLOAT64);
02406 }
02407 
02409 
02415 
02416 FLGR_Ret flgr1d_arith_const_module_ptr(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02417   FLGR_Ret ret;
02418 
02419   
02420 
02421   if((datdest==NULL) || (data1==NULL)) {
02422     POST_ERROR("Null objects!\n");
02423     return FLGR_RET_NULL_OBJECT;
02424   }
02425 
02426   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
02427 
02428   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_const_module,datdest,data1,vec_const);
02429 }
02430 
02432 
02438 
02439 FLGR_Ret flgr1d_arith_const_module_str(FLGR_Data1D *datdest, FLGR_Data1D *data1, char *constant) {
02440   int ret;
02441   FLGR_Vector *vector_constant;
02442 
02443   if((data1==NULL) || (datdest==NULL))  {
02444     POST_ERROR("Null objects!\n");
02445     return FLGR_RET_NULL_OBJECT;
02446   }
02447 
02448   vector_constant = flgr_vector_create(data1->spp,data1->type);
02449 
02450   if((ret=flgr_vector_import_string(vector_constant, constant))
02451      != FLGR_RET_OK) {
02452 
02453     POST_ERROR("String is not valid ""%s""\n",constant);
02454     flgr_vector_destroy(vector_constant);
02455     return ret;
02456   }
02457 
02458 
02459 
02460   ret = flgr1d_arith_const_module_ptr(datdest,data1,vector_constant);
02461 
02462   flgr_vector_destroy(vector_constant);
02463 
02464 
02465   return ret;
02466 
02467 }
02468 
02469 
02470 
02471 
02472 /*******************************************************************************
02473  * MULTSAT CONST
02474  *******************************************************************************/
02475 
02476 void flgr1d_arith_const_multsat_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02477   flgr_no_define_type_function(FLGR_BIT);
02478 }
02479 void flgr1d_arith_const_multsat_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02480   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_multsat_fgUINT8);
02481 }
02482 void flgr1d_arith_const_multsat_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02483   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_multsat_fgUINT16);
02484 }
02485 void flgr1d_arith_const_multsat_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02486   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_multsat_fgUINT32);
02487 }
02488 void flgr1d_arith_const_multsat_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02489   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_multsat_fgINT8);
02490 }
02491 void flgr1d_arith_const_multsat_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02492   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_multsat_fgINT16);
02493 }
02494 void flgr1d_arith_const_multsat_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02495   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_multsat_fgINT32);
02496 }
02497 void flgr1d_arith_const_multsat_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02498   flgr_no_define_type_function(FLGR_FLOAT32);
02499 }
02500 void flgr1d_arith_const_multsat_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02501   flgr_no_define_type_function(FLGR_FLOAT64);
02502 }
02503 
02505 
02511 
02512 FLGR_Ret flgr1d_arith_const_multsat_ptr(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02513   FLGR_Ret ret;
02514 
02515   
02516 
02517   if((datdest==NULL) || (data1==NULL)) {
02518     POST_ERROR("Null objects!\n");
02519     return FLGR_RET_NULL_OBJECT;
02520   }
02521 
02522   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
02523 
02524   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_const_multsat,datdest,data1,vec_const);
02525 }
02526 
02528 
02534 
02535 FLGR_Ret flgr1d_arith_const_multsat_str(FLGR_Data1D *datdest, FLGR_Data1D *data1, char *constant) {
02536   int ret;
02537   FLGR_Vector *vector_constant;
02538 
02539   if((data1==NULL) || (datdest==NULL))  {
02540     POST_ERROR("Null objects!\n");
02541     return FLGR_RET_NULL_OBJECT;
02542   }
02543 
02544   vector_constant = flgr_vector_create(data1->spp,data1->type);
02545 
02546   if((ret=flgr_vector_import_string(vector_constant, constant))
02547      != FLGR_RET_OK) {
02548 
02549     POST_ERROR("String is not valid ""%s""\n",constant);
02550     flgr_vector_destroy(vector_constant);
02551     return ret;
02552   }
02553 
02554   ret = flgr1d_arith_const_multsat_ptr(datdest,data1,vector_constant);
02555 
02556   flgr_vector_destroy(vector_constant);
02557 
02558 
02559   return ret;
02560 
02561 }
02562 
02563 
02564 
02565 
02566 /*******************************************************************************
02567  * SUBSAT CONST
02568  *******************************************************************************/
02569 
02570 void flgr1d_arith_const_subsat_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02571   flgr_no_define_type_function(FLGR_BIT);
02572 }
02573 void flgr1d_arith_const_subsat_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02574   #ifdef __SSE2__
02575     if(datdest->spp==1) {
02576       flgr1d_arith_const_subsat_spp1_SSE2_fgUINT8(datdest,data1,vec_const);
02577     }else {
02578       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_subsat_fgUINT8);
02579     }
02580   #else
02581     #ifdef __SSE__
02582       if(datdest->spp==1) {
02583         flgr1d_arith_const_subsat_spp1_SSE_fgUINT8(datdest,data1,vec_const);
02584       }else {
02585         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_subsat_fgUINT8);
02586       }
02587     #else
02588        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_subsat_fgUINT8);
02589     #endif
02590   #endif
02591 }
02592 void flgr1d_arith_const_subsat_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02593   #ifdef __SSE2__
02594     if(datdest->spp==1) {
02595       flgr1d_arith_const_subsat_spp1_SSE2_fgUINT16(datdest,data1,vec_const);
02596     }else {
02597       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_subsat_fgUINT16);
02598     }
02599   #else
02600     #ifdef __SSE__
02601       if(datdest->spp==1) {
02602         flgr1d_arith_const_subsat_spp1_SSE_fgUINT16(datdest,data1,vec_const);
02603       }else {
02604         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_subsat_fgUINT16);
02605       }
02606     #else
02607        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_subsat_fgUINT16);
02608     #endif
02609   #endif
02610 }
02611 void flgr1d_arith_const_subsat_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02612   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_subsat_fgUINT32);
02613 }
02614 void flgr1d_arith_const_subsat_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02615   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_subsat_fgINT8);
02616 }
02617 void flgr1d_arith_const_subsat_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02618   #ifdef __SSE2__
02619     if(datdest->spp==1) {
02620       flgr1d_arith_const_subsat_spp1_SSE2_fgINT16(datdest,data1,vec_const);
02621     }else {
02622       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_subsat_fgINT16);
02623     }
02624   #else
02625     #ifdef __SSE__
02626       if(datdest->spp==1) {
02627         flgr1d_arith_const_subsat_spp1_SSE_fgINT16(datdest,data1,vec_const);
02628       }else {
02629         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_subsat_fgINT16);
02630       }
02631     #else
02632        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_subsat_fgINT16);
02633     #endif
02634   #endif
02635 }
02636 void flgr1d_arith_const_subsat_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02637   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_subsat_fgINT32);
02638 }
02639 void flgr1d_arith_const_subsat_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02640   flgr_no_define_type_function(FLGR_FLOAT32);
02641 }
02642 void flgr1d_arith_const_subsat_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02643   flgr_no_define_type_function(FLGR_FLOAT64);
02644 }
02645 
02647 
02653 
02654 FLGR_Ret flgr1d_arith_const_subsat_ptr(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02655   FLGR_Ret ret;
02656 
02657   
02658 
02659   if((datdest==NULL) || (data1==NULL)) {
02660     POST_ERROR("Null objects!\n");
02661     return FLGR_RET_NULL_OBJECT;
02662   }
02663 
02664   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
02665 
02666   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_const_subsat,datdest,data1,vec_const);
02667 }
02668 
02670 
02676 
02677 FLGR_Ret flgr1d_arith_const_subsat_str(FLGR_Data1D *datdest, FLGR_Data1D *data1, char *constant) {
02678   int ret;
02679   FLGR_Vector *vector_constant;
02680 
02681   if((data1==NULL) || (datdest==NULL))  {
02682     POST_ERROR("Null objects!\n");
02683     return FLGR_RET_NULL_OBJECT;
02684   }
02685 
02686   vector_constant = flgr_vector_create(data1->spp,data1->type);
02687 
02688   if((ret=flgr_vector_import_string(vector_constant, constant))
02689      != FLGR_RET_OK) {
02690 
02691     POST_ERROR("String is not valid ""%s""\n",constant);
02692     flgr_vector_destroy(vector_constant);
02693     return ret;
02694   }
02695 
02696   ret = flgr1d_arith_const_subsat_ptr(datdest,data1,vector_constant);
02697 
02698   flgr_vector_destroy(vector_constant);
02699 
02700 
02701   return ret;
02702 
02703 }
02704 
02705 
02706 
02707 
02708 
02709 /*******************************************************************************
02710  * ADDSAT CONST
02711  *******************************************************************************/
02712 
02713 void flgr1d_arith_const_addsat_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02714   flgr_no_define_type_function(FLGR_BIT);
02715 }
02716 void flgr1d_arith_const_addsat_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02717   #ifdef __SSE2__
02718     if(datdest->spp==1) {
02719       flgr1d_arith_const_addsat_spp1_SSE2_fgUINT8(datdest,data1,vec_const);
02720     }else {
02721       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_addsat_fgUINT8);
02722     }
02723   #else
02724     #ifdef __SSE__
02725       if(datdest->spp==1) {
02726         flgr1d_arith_const_addsat_spp1_SSE_fgUINT8(datdest,data1,vec_const);
02727       }else {
02728         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_addsat_fgUINT8);
02729       }
02730     #else
02731        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_addsat_fgUINT8);
02732     #endif
02733   #endif
02734 }
02735 void flgr1d_arith_const_addsat_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02736   #ifdef __SSE2__
02737     if(datdest->spp==1) {
02738       flgr1d_arith_const_addsat_spp1_SSE2_fgUINT16(datdest,data1,vec_const);
02739     }else {
02740       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_addsat_fgUINT16);
02741     }
02742   #else
02743     #ifdef __SSE__
02744       if(datdest->spp==1) {
02745         flgr1d_arith_const_addsat_spp1_SSE_fgUINT16(datdest,data1,vec_const);
02746       }else {
02747         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_addsat_fgUINT16);
02748       }
02749     #else
02750        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_addsat_fgUINT16);
02751     #endif
02752   #endif
02753 }
02754 void flgr1d_arith_const_addsat_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02755   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_addsat_fgUINT32);
02756 }
02757 void flgr1d_arith_const_addsat_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02758   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_addsat_fgINT8);
02759 }
02760 void flgr1d_arith_const_addsat_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02761   #ifdef __SSE2__
02762     if(datdest->spp==1) {
02763       flgr1d_arith_const_addsat_spp1_SSE2_fgINT16(datdest,data1,vec_const);
02764     }else {
02765       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_addsat_fgINT16);
02766     }
02767   #else
02768     #ifdef __SSE__
02769       if(datdest->spp==1) {
02770         flgr1d_arith_const_addsat_spp1_SSE_fgINT16(datdest,data1,vec_const);
02771       }else {
02772         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_addsat_fgINT16);
02773       }
02774     #else
02775        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_addsat_fgINT16);
02776     #endif
02777   #endif
02778 }
02779 void flgr1d_arith_const_addsat_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02780   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_addsat_fgINT32);
02781 }
02782 void flgr1d_arith_const_addsat_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02783   flgr_no_define_type_function(FLGR_FLOAT32);
02784 }
02785 void flgr1d_arith_const_addsat_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02786   flgr_no_define_type_function(FLGR_FLOAT64);
02787 }
02788 
02790 
02796 
02797 FLGR_Ret flgr1d_arith_const_addsat_ptr(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02798   FLGR_Ret ret;
02799 
02800   
02801 
02802   if((datdest==NULL) || (data1==NULL)) {
02803     POST_ERROR("Null objects!\n");
02804     return FLGR_RET_NULL_OBJECT;
02805   }
02806 
02807   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
02808 
02809   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_const_addsat,datdest,data1,vec_const);
02810 }
02811 
02813 
02819 
02820 FLGR_Ret flgr1d_arith_const_addsat_str(FLGR_Data1D *datdest, FLGR_Data1D *data1, char *constant) {
02821   int ret;
02822   FLGR_Vector *vector_constant;
02823 
02824   if((data1==NULL) || (datdest==NULL))  {
02825     POST_ERROR("Null objects!\n");
02826     return FLGR_RET_NULL_OBJECT;
02827   }
02828 
02829   vector_constant = flgr_vector_create(data1->spp,data1->type);
02830 
02831   if((ret=flgr_vector_import_string(vector_constant, constant))
02832      != FLGR_RET_OK) {
02833 
02834     POST_ERROR("String is not valid ""%s""\n",constant);
02835     flgr_vector_destroy(vector_constant);
02836     return ret;
02837   }
02838 
02839   ret = flgr1d_arith_const_addsat_ptr(datdest,data1,vector_constant);
02840 
02841   flgr_vector_destroy(vector_constant);
02842 
02843 
02844   return ret;
02845 
02846 }
02847 
02848 
02849 
02850 
02851 /*******************************************************************************
02852  * DIV CONST
02853  *******************************************************************************/
02854 
02855 void flgr1d_arith_const_div_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02856   flgr_no_define_type_function(FLGR_BIT);
02857 }
02858 void flgr1d_arith_const_div_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02859   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_div_fgUINT8);
02860 }
02861 void flgr1d_arith_const_div_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02862   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_div_fgUINT16);
02863 }
02864 void flgr1d_arith_const_div_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02865   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_div_fgUINT32);
02866 }
02867 void flgr1d_arith_const_div_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02868   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_div_fgINT8);
02869 }
02870 void flgr1d_arith_const_div_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02871   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_div_fgINT16);
02872 }
02873 void flgr1d_arith_const_div_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02874   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_div_fgINT32);
02875 }
02876 void flgr1d_arith_const_div_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02877   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT32,fgFLOAT32,flgr_defop_div_fgFLOAT32);
02878 }
02879 void flgr1d_arith_const_div_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02880   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT64,fgFLOAT64,flgr_defop_div_fgFLOAT64);
02881 }
02882 
02884 
02890 
02891 FLGR_Ret flgr1d_arith_const_div_ptr(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02892   FLGR_Ret ret;
02893 
02894   
02895 
02896   if((datdest==NULL) || (data1==NULL)) {
02897     POST_ERROR("Null objects!\n");
02898     return FLGR_RET_NULL_OBJECT;
02899   }
02900 
02901   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
02902 
02903   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_const_div,datdest,data1,vec_const);
02904 }
02905 
02907 
02913 
02914 FLGR_Ret flgr1d_arith_const_div_str(FLGR_Data1D *datdest, FLGR_Data1D *data1, char *constant) {
02915   int ret;
02916   FLGR_Vector *vector_constant;
02917 
02918   if((data1==NULL) || (datdest==NULL))  {
02919     POST_ERROR("Null objects!\n");
02920     return FLGR_RET_NULL_OBJECT;
02921   }
02922 
02923   vector_constant = flgr_vector_create(data1->spp,data1->type);
02924 
02925   if((ret=flgr_vector_import_string(vector_constant, constant))
02926      != FLGR_RET_OK) {
02927 
02928     POST_ERROR("String is not valid ""%s""\n",constant);
02929     flgr_vector_destroy(vector_constant);
02930     return ret;
02931   }
02932 
02933 
02934 
02935   ret = flgr1d_arith_const_div_ptr(datdest,data1,vector_constant);
02936 
02937   flgr_vector_destroy(vector_constant);
02938 
02939 
02940   return ret;
02941 
02942 }
02943 
02944 
02945 
02946 
02947 
02948 
02949 /*******************************************************************************
02950  * MULT CONST
02951  *******************************************************************************/
02952 
02953 void flgr1d_arith_const_mult_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02954   flgr_no_define_type_function(FLGR_BIT);
02955 }
02956 void flgr1d_arith_const_mult_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02957   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_mult_fgUINT8);
02958 }
02959 void flgr1d_arith_const_mult_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02960   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_mult_fgUINT16);
02961 }
02962 void flgr1d_arith_const_mult_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02963   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_mult_fgUINT32);
02964 }
02965 void flgr1d_arith_const_mult_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02966   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_mult_fgINT8);
02967 }
02968 void flgr1d_arith_const_mult_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02969   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_mult_fgINT16);
02970 }
02971 void flgr1d_arith_const_mult_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02972   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_mult_fgINT32);
02973 }
02974 void flgr1d_arith_const_mult_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02975   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT32,fgFLOAT32,flgr_defop_mult_fgFLOAT32);
02976 }
02977 void flgr1d_arith_const_mult_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02978   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT64,fgFLOAT64,flgr_defop_mult_fgFLOAT64);
02979 }
02980 
02982 
02988 
02989 FLGR_Ret flgr1d_arith_const_mult_ptr(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
02990   FLGR_Ret ret;
02991 
02992   
02993 
02994   if((datdest==NULL) || (data1==NULL)) {
02995     POST_ERROR("Null objects!\n");
02996     return FLGR_RET_NULL_OBJECT;
02997   }
02998 
02999   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
03000 
03001   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_const_mult,datdest,data1,vec_const);
03002 }
03003 
03005 
03011 
03012 FLGR_Ret flgr1d_arith_const_mult_str(FLGR_Data1D *datdest, FLGR_Data1D *data1, char *constant) {
03013   int ret;
03014   FLGR_Vector *vector_constant;
03015 
03016   if((data1==NULL) || (datdest==NULL))  {
03017     POST_ERROR("Null objects!\n");
03018     return FLGR_RET_NULL_OBJECT;
03019   }
03020 
03021   vector_constant = flgr_vector_create(data1->spp,data1->type);
03022 
03023   if((ret=flgr_vector_import_string(vector_constant, constant))
03024      != FLGR_RET_OK) {
03025 
03026     POST_ERROR("String is not valid ""%s""\n",constant);
03027     flgr_vector_destroy(vector_constant);
03028     return ret;
03029   }
03030 
03031 
03032 
03033   ret = flgr1d_arith_const_mult_ptr(datdest,data1,vector_constant);
03034 
03035   flgr_vector_destroy(vector_constant);
03036 
03037 
03038   return ret;
03039 
03040 }
03041 
03042 
03043 
03044 
03045 
03046 /*******************************************************************************
03047  * SUB CONST
03048  *******************************************************************************/
03049 
03050 void flgr1d_arith_const_sub_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03051   flgr_no_define_type_function(FLGR_BIT);
03052 }
03053 void flgr1d_arith_const_sub_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03054   #ifdef __SSE2__
03055     if(datdest->spp==1) {
03056       flgr1d_arith_const_sub_spp1_SSE2_fgUINT8(datdest,data1,vec_const);
03057     }else {
03058       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_sub_a_b_fgUINT8);
03059     }
03060   #else
03061     #ifdef __SSE__
03062       if(datdest->spp==1) {
03063         flgr1d_arith_const_sub_spp1_SSE_fgUINT8(datdest,data1,vec_const);
03064       }else {
03065         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_sub_a_b_fgUINT8);
03066       }
03067     #else
03068        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_sub_a_b_fgUINT8);
03069     #endif
03070   #endif
03071 }
03072 void flgr1d_arith_const_sub_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03073   #ifdef __SSE2__
03074     if(datdest->spp==1) {
03075       flgr1d_arith_const_sub_spp1_SSE2_fgUINT16(datdest,data1,vec_const);
03076     }else {
03077       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_sub_a_b_fgUINT16);
03078     }
03079   #else
03080     #ifdef __SSE__
03081       if(datdest->spp==1) {
03082         flgr1d_arith_const_sub_spp1_SSE_fgUINT16(datdest,data1,vec_const);
03083       }else {
03084         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_sub_a_b_fgUINT16);
03085       }
03086     #else
03087        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_sub_a_b_fgUINT16);
03088     #endif
03089   #endif
03090 }
03091 void flgr1d_arith_const_sub_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03092   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_sub_a_b_fgUINT32);
03093 }
03094 void flgr1d_arith_const_sub_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03095   #ifdef __SSE2__
03096     if(datdest->spp==1) {
03097       flgr1d_arith_const_sub_spp1_SSE2_fgINT8(datdest,data1,vec_const);
03098     }else {
03099       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_sub_a_b_fgINT8);
03100     }
03101   #else
03102     #ifdef __SSE__
03103       if(datdest->spp==1) {
03104         flgr1d_arith_const_sub_spp1_SSE_fgINT8(datdest,data1,vec_const);
03105       }else {
03106         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_sub_a_b_fgINT8);
03107       }
03108     #else
03109        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_sub_a_b_fgINT8);
03110     #endif
03111   #endif
03112 }
03113 void flgr1d_arith_const_sub_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03114   #ifdef __SSE2__
03115     if(datdest->spp==1) {
03116       flgr1d_arith_const_sub_spp1_SSE2_fgINT16(datdest,data1,vec_const);
03117     }else {
03118       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_sub_a_b_fgINT16);
03119     }
03120   #else
03121     #ifdef __SSE__
03122       if(datdest->spp==1) {
03123         flgr1d_arith_const_sub_spp1_SSE_fgINT16(datdest,data1,vec_const);
03124       }else {
03125         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_sub_a_b_fgINT16);
03126       }
03127     #else
03128        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_sub_a_b_fgINT16);
03129     #endif
03130   #endif
03131 }
03132 void flgr1d_arith_const_sub_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03133   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_sub_a_b_fgINT32);
03134 }
03135 void flgr1d_arith_const_sub_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03136   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT32,fgFLOAT32,flgr_defop_sub_a_b_fgFLOAT32);
03137 }
03138 void flgr1d_arith_const_sub_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03139   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT64,fgFLOAT64,flgr_defop_sub_a_b_fgFLOAT64);
03140 }
03141 
03143 
03149 
03150 FLGR_Ret flgr1d_arith_const_sub_ptr(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03151   FLGR_Ret ret;
03152 
03153   
03154 
03155   if((datdest==NULL) || (data1==NULL)) {
03156     POST_ERROR("Null objects!\n");
03157     return FLGR_RET_NULL_OBJECT;
03158   }
03159 
03160   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
03161 
03162   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_const_sub,datdest,data1,vec_const);
03163 }
03164 
03166 
03172 
03173 FLGR_Ret flgr1d_arith_const_sub_str(FLGR_Data1D *datdest, FLGR_Data1D *data1, char *constant) {
03174   int ret;
03175   FLGR_Vector *vector_constant;
03176 
03177   if((data1==NULL) || (datdest==NULL))  {
03178     POST_ERROR("Null objects!\n");
03179     return FLGR_RET_NULL_OBJECT;
03180   }
03181 
03182   vector_constant = flgr_vector_create(data1->spp,data1->type);
03183 
03184   if((ret=flgr_vector_import_string(vector_constant, constant))
03185      != FLGR_RET_OK) {
03186 
03187     POST_ERROR("String is not valid ""%s""\n",constant);
03188     flgr_vector_destroy(vector_constant);
03189     return ret;
03190   }
03191 
03192 
03193   ret = flgr1d_arith_const_sub_ptr(datdest,data1,vector_constant);
03194 
03195   flgr_vector_destroy(vector_constant);
03196 
03197 
03198   return ret;
03199 
03200 }
03201 
03202 
03203 
03204 
03205 
03206 
03207 
03208 /*******************************************************************************
03209  * ADD CONST
03210  *******************************************************************************/
03211 
03212 void flgr1d_arith_const_add_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03213   flgr_no_define_type_function(FLGR_BIT);
03214 }
03215 void flgr1d_arith_const_add_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03216   #ifdef __SSE2__
03217     if(datdest->spp==1) {
03218       flgr1d_arith_const_add_spp1_SSE2_fgUINT8(datdest,data1,vec_const);
03219     }else {
03220       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_add_fgUINT8);
03221     }
03222   #else
03223     #ifdef __SSE__
03224       if(datdest->spp==1) {
03225         flgr1d_arith_const_add_spp1_SSE_fgUINT8(datdest,data1,vec_const);
03226       }else {
03227         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_add_fgUINT8);
03228       }
03229     #else
03230        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_add_fgUINT8);
03231     #endif
03232   #endif
03233 }
03234 void flgr1d_arith_const_add_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03235   #ifdef __SSE2__
03236     if(datdest->spp==1) {
03237       flgr1d_arith_const_add_spp1_SSE2_fgUINT16(datdest,data1,vec_const);
03238     }else {
03239       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_add_fgUINT16);
03240     }
03241   #else
03242     #ifdef __SSE__
03243       if(datdest->spp==1) {
03244         flgr1d_arith_const_add_spp1_SSE_fgUINT16(datdest,data1,vec_const);
03245       }else {
03246         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_add_fgUINT16);
03247       }
03248     #else
03249        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_add_fgUINT16);
03250     #endif
03251   #endif
03252 }
03253 void flgr1d_arith_const_add_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03254   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_add_fgUINT32);
03255 }
03256 void flgr1d_arith_const_add_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03257   #ifdef __SSE2__
03258     if(datdest->spp==1) {
03259       flgr1d_arith_const_add_spp1_SSE2_fgINT8(datdest,data1,vec_const);
03260     }else {
03261       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_add_fgINT8);
03262     }
03263   #else
03264     #ifdef __SSE__
03265       if(datdest->spp==1) {
03266         flgr1d_arith_const_add_spp1_SSE_fgINT8(datdest,data1,vec_const);
03267       }else {
03268         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_add_fgINT8);
03269       }
03270     #else
03271        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_add_fgINT8);
03272     #endif
03273   #endif
03274 }
03275 void flgr1d_arith_const_add_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03276   #ifdef __SSE2__
03277     if(datdest->spp==1) {
03278       flgr1d_arith_const_add_spp1_SSE2_fgINT16(datdest,data1,vec_const);
03279     }else {
03280       FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_add_fgINT16);
03281     }
03282   #else
03283     #ifdef __SSE__
03284       if(datdest->spp==1) {
03285         flgr1d_arith_const_add_spp1_SSE_fgINT16(datdest,data1,vec_const);
03286       }else {
03287         FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_add_fgINT16);
03288       }
03289     #else
03290        FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_add_fgINT16);
03291     #endif
03292   #endif
03293 }
03294 void flgr1d_arith_const_add_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03295   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_add_fgINT32);
03296 }
03297 void flgr1d_arith_const_add_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03298   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT32,fgFLOAT32,flgr_defop_add_fgFLOAT32);
03299 }
03300 void flgr1d_arith_const_add_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03301   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT64,fgFLOAT64,flgr_defop_add_fgFLOAT64);
03302 }
03303 
03305 
03311 
03312 FLGR_Ret flgr1d_arith_const_add_ptr(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03313   FLGR_Ret ret;
03314 
03315   
03316 
03317   if((datdest==NULL) || (data1==NULL)) {
03318     POST_ERROR("Null objects!\n");
03319     return FLGR_RET_NULL_OBJECT;
03320   }
03321 
03322   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
03323 
03324   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_const_add,datdest,data1,vec_const);
03325 }
03326 
03328 
03334 
03335 FLGR_Ret flgr1d_arith_const_add_str(FLGR_Data1D *datdest, FLGR_Data1D *data1, char *constant) {
03336   int ret;
03337   FLGR_Vector *vector_constant;
03338 
03339   if((data1==NULL) || (datdest==NULL))  {
03340     POST_ERROR("Null objects!\n");
03341     return FLGR_RET_NULL_OBJECT;
03342   }
03343 
03344   vector_constant = flgr_vector_create(data1->spp,data1->type);
03345 
03346   if((ret=flgr_vector_import_string(vector_constant, constant))
03347      != FLGR_RET_OK) {
03348 
03349     POST_ERROR("String is not valid ""%s""\n",constant);
03350     flgr_vector_destroy(vector_constant);
03351     return ret;
03352   }
03353 
03354 
03355   ret = flgr1d_arith_const_add_ptr(datdest,data1,vector_constant);
03356 
03357   flgr_vector_destroy(vector_constant);
03358 
03359 
03360   return ret;
03361 
03362 }
03363 
03365 
03373 /*******************************************************************************
03374  * Log base b
03375  *******************************************************************************/
03376 
03377 void flgr1d_arith_logb_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03378   flgr_no_define_type_function(FLGR_BIT);
03379 }
03380 void flgr1d_arith_logb_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03381   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_logb_fgUINT8);
03382 }
03383 
03384 void flgr1d_arith_logb_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03385   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_logb_fgUINT16);
03386 }
03387 
03388 void flgr1d_arith_logb_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03389   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_logb_fgUINT32);
03390 }
03391 
03392 void flgr1d_arith_logb_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03393   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_logb_fgINT8);
03394 }
03395 
03396 void flgr1d_arith_logb_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03397   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_logb_fgINT16);
03398 }
03399 
03400 void flgr1d_arith_logb_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03401   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_logb_fgINT32) ;
03402 }
03403 
03404 void flgr1d_arith_logb_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03405   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT32,fgFLOAT32,flgr_defop_logb_fgFLOAT32) ;
03406 }
03407 
03408 void flgr1d_arith_logb_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03409   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT64,fgFLOAT64,flgr_defop_logb_fgFLOAT64) ;
03410 }
03411 
03413 
03419 
03420 FLGR_Ret flgr1d_arith_logb(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *base) {
03421   FLGR_Ret ret;
03422 
03423   
03424 
03425   if((datdest==NULL) || (data1==NULL)) {
03426     POST_ERROR("Null objects!\n");
03427     return FLGR_RET_NULL_OBJECT;
03428   }
03429 
03430   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
03431 
03432   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_logb,datdest,data1,base);
03433 }
03434 
03435 
03436 
03437 
03438 
03439 /*******************************************************************************
03440  * Pow base b
03441  *******************************************************************************/
03442 
03443 void flgr1d_arith_powb_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03444   flgr_no_define_type_function(FLGR_BIT);
03445 }
03446 void flgr1d_arith_powb_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03447   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT8,fgUINT8,flgr_defop_powb_fgUINT8);
03448 }
03449 
03450 void flgr1d_arith_powb_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03451   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT16,fgUINT16,flgr_defop_powb_fgUINT16);
03452 }
03453 
03454 void flgr1d_arith_powb_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03455   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgUINT32,fgUINT32,flgr_defop_powb_fgUINT32);
03456 }
03457 
03458 void flgr1d_arith_powb_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03459   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT8,fgINT8,flgr_defop_powb_fgINT8);
03460 }
03461 
03462 void flgr1d_arith_powb_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03463   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT16,fgINT16,flgr_defop_powb_fgINT16);
03464 }
03465 
03466 void flgr1d_arith_powb_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03467   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgINT32,fgINT32,flgr_defop_powb_fgINT32) ;
03468 }
03469 
03470 void flgr1d_arith_powb_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03471   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT32,fgFLOAT32,flgr_defop_powb_fgFLOAT32) ;
03472 }
03473 
03474 void flgr1d_arith_powb_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *vec_const) {
03475   FLGR_MACRO_ARITH_1D_DIADIC_CONST(fgFLOAT64,fgFLOAT64,flgr_defop_powb_fgFLOAT64) ;
03476 }
03477 
03479 
03485 
03486 FLGR_Ret flgr1d_arith_powb(FLGR_Data1D *datdest, FLGR_Data1D *data1, FLGR_Vector *base) {
03487   FLGR_Ret ret;
03488 
03489   
03490 
03491   if((datdest==NULL) || (data1==NULL)) {
03492     POST_ERROR("Null objects!\n");
03493     return FLGR_RET_NULL_OBJECT;
03494   }
03495 
03496   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
03497 
03498   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_powb,datdest,data1,base);
03499 }
03500 
03501 
03502 
03503 
03504 /*******************************************************************************
03505  *******************************************************************************
03506  *******************************************************************************
03507  * MONO OPERATIONS
03508  *******************************************************************************
03509  *******************************************************************************
03510  *******************************************************************************/
03511 
03512 
03513 
03514 /*******************************************************************************
03515  * INVERT
03516  *******************************************************************************/
03517 
03518 void flgr1d_arith_invert_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03519   flgr_no_define_type_function(FLGR_BIT);
03520 }
03521 void flgr1d_arith_invert_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03522   FLGR_MACRO_ARITH_1D_MONOADIC(fgUINT8,fgUINT8,flgr_defop_invert_fgUINT8);
03523 }
03524 
03525 void flgr1d_arith_invert_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03526   FLGR_MACRO_ARITH_1D_MONOADIC(fgUINT16,fgUINT16,flgr_defop_invert_fgUINT16);
03527 }
03528 
03529 void flgr1d_arith_invert_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03530   FLGR_MACRO_ARITH_1D_MONOADIC(fgUINT32,fgUINT32,flgr_defop_invert_fgUINT32);
03531 }
03532 
03533 void flgr1d_arith_invert_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03534   FLGR_MACRO_ARITH_1D_MONOADIC(fgINT8,fgINT8,flgr_defop_invert_fgINT8);
03535 }
03536 
03537 void flgr1d_arith_invert_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03538   FLGR_MACRO_ARITH_1D_MONOADIC(fgINT16,fgINT16,flgr_defop_invert_fgINT16);
03539 }
03540 
03541 void flgr1d_arith_invert_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03542   FLGR_MACRO_ARITH_1D_MONOADIC(fgINT32,fgINT32,flgr_defop_invert_fgINT32);
03543 }
03544 
03545 void flgr1d_arith_invert_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03546   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT32,fgFLOAT32,flgr_defop_invert_fgFLOAT32);
03547 }
03548 
03549 void flgr1d_arith_invert_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03550   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT64,fgFLOAT64,flgr_defop_invert_fgFLOAT64);
03551 }
03552 
03554 
03559 
03560 FLGR_Ret flgr1d_arith_invert(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03561   FLGR_Ret ret;
03562 
03563   
03564 
03565   if((datdest==NULL) || (data1==NULL)) {
03566     POST_ERROR("Null objects!\n");
03567     return FLGR_RET_NULL_OBJECT;
03568   }
03569 
03570   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
03571 
03572   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_invert,datdest,data1);
03573 
03574 }
03575 
03576 
03577 
03578 /*******************************************************************************
03579  * ABS
03580  *******************************************************************************/
03581 
03582 void flgr1d_arith_abs_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03583   flgr_no_define_type_function(FLGR_BIT);
03584 }
03585 void flgr1d_arith_abs_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03586   flgr_no_define_type_function(FLGR_UINT8);
03587 }
03588 
03589 void flgr1d_arith_abs_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03590   flgr_no_define_type_function(FLGR_UINT16);
03591 }
03592 
03593 void flgr1d_arith_abs_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03594   flgr_no_define_type_function(FLGR_UINT32);
03595 }
03596 
03597 void flgr1d_arith_abs_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03598   FLGR_MACRO_ARITH_1D_MONOADIC(fgINT8,fgINT8,flgr_defop_abs_fgINT8);
03599 }
03600 
03601 void flgr1d_arith_abs_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03602   FLGR_MACRO_ARITH_1D_MONOADIC(fgINT16,fgINT16,flgr_defop_abs_fgINT16);
03603 }
03604 
03605 void flgr1d_arith_abs_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03606   FLGR_MACRO_ARITH_1D_MONOADIC(fgINT32,fgINT32,flgr_defop_abs_fgINT32);
03607 }
03608 
03609 void flgr1d_arith_abs_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03610   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT32,fgFLOAT32,flgr_defop_abs_fgFLOAT32);
03611 }
03612 
03613 void flgr1d_arith_abs_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03614   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT64,fgFLOAT64,flgr_defop_abs_fgFLOAT64);
03615 }
03616 
03618 
03623 
03624 FLGR_Ret flgr1d_arith_abs(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03625   FLGR_Ret ret;
03626 
03627   
03628 
03629   if((datdest==NULL) || (data1==NULL)) {
03630     POST_ERROR("Null objects!\n");
03631     return FLGR_RET_NULL_OBJECT;
03632   }
03633 
03634   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
03635 
03636   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_abs,datdest,data1);
03637 
03638 }
03639 
03640 
03641 
03642 /*******************************************************************************
03643  * COS
03644  *******************************************************************************/
03645 
03646 void flgr1d_arith_cos_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03647   flgr_no_define_type_function(FLGR_BIT);
03648 }
03649 void flgr1d_arith_cos_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03650   flgr_no_define_type_function(FLGR_UINT8);
03651 }
03652 
03653 void flgr1d_arith_cos_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03654   flgr_no_define_type_function(FLGR_UINT16);
03655 }
03656 
03657 void flgr1d_arith_cos_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03658   flgr_no_define_type_function(FLGR_UINT32);
03659 }
03660 
03661 void flgr1d_arith_cos_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03662   flgr_no_define_type_function(FLGR_INT8);
03663 }
03664 
03665 void flgr1d_arith_cos_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03666   flgr_no_define_type_function(FLGR_INT16);
03667 }
03668 
03669 void flgr1d_arith_cos_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03670   flgr_no_define_type_function(FLGR_INT32);
03671 }
03672 
03673 void flgr1d_arith_cos_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03674   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT32,fgFLOAT32,flgr_defop_cos_fgFLOAT32);
03675 }
03676 
03677 void flgr1d_arith_cos_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03678   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT64,fgFLOAT64,flgr_defop_cos_fgFLOAT64);
03679 }
03680 
03682 
03687 
03688 FLGR_Ret flgr1d_arith_cos(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03689   FLGR_Ret ret;
03690 
03691   
03692 
03693   if((datdest==NULL) || (data1==NULL)) {
03694     POST_ERROR("Null objects!\n");
03695     return FLGR_RET_NULL_OBJECT;
03696   }
03697 
03698   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
03699 
03700   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_cos,datdest,data1);
03701 
03702 }
03703 
03704 /*******************************************************************************
03705  * SIN
03706  *******************************************************************************/
03707 
03708 void flgr1d_arith_sin_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03709   flgr_no_define_type_function(FLGR_BIT);
03710 }
03711 void flgr1d_arith_sin_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03712   flgr_no_define_type_function(FLGR_UINT8);
03713 }
03714 
03715 void flgr1d_arith_sin_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03716   flgr_no_define_type_function(FLGR_UINT16);
03717 }
03718 
03719 void flgr1d_arith_sin_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03720   flgr_no_define_type_function(FLGR_UINT32);
03721 }
03722 
03723 void flgr1d_arith_sin_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03724   flgr_no_define_type_function(FLGR_INT8);
03725 }
03726 
03727 void flgr1d_arith_sin_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03728   flgr_no_define_type_function(FLGR_INT16);
03729 }
03730 
03731 void flgr1d_arith_sin_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03732   flgr_no_define_type_function(FLGR_INT32);
03733 }
03734 
03735 void flgr1d_arith_sin_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03736   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT32,fgFLOAT32,flgr_defop_sin_fgFLOAT32);
03737 }
03738 
03739 void flgr1d_arith_sin_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03740   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT64,fgFLOAT64,flgr_defop_sin_fgFLOAT64);
03741 }
03742 
03744 
03749 
03750 FLGR_Ret flgr1d_arith_sin(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03751   FLGR_Ret ret;
03752 
03753   
03754 
03755   if((datdest==NULL) || (data1==NULL)) {
03756     POST_ERROR("Null objects!\n");
03757     return FLGR_RET_NULL_OBJECT;
03758   }
03759 
03760   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
03761 
03762   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_sin,datdest,data1);
03763 
03764 }
03765 
03766 /*******************************************************************************
03767  * TAN
03768  *******************************************************************************/
03769 
03770 void flgr1d_arith_tan_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03771   flgr_no_define_type_function(FLGR_BIT);
03772 }
03773 void flgr1d_arith_tan_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03774   flgr_no_define_type_function(FLGR_UINT8);
03775 }
03776 
03777 void flgr1d_arith_tan_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03778   flgr_no_define_type_function(FLGR_UINT16);
03779 }
03780 
03781 void flgr1d_arith_tan_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03782   flgr_no_define_type_function(FLGR_UINT32);
03783 }
03784 
03785 void flgr1d_arith_tan_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03786   flgr_no_define_type_function(FLGR_INT8);
03787 }
03788 
03789 void flgr1d_arith_tan_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03790   flgr_no_define_type_function(FLGR_INT16);
03791 }
03792 
03793 void flgr1d_arith_tan_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03794   flgr_no_define_type_function(FLGR_INT32);
03795 }
03796 
03797 void flgr1d_arith_tan_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03798   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT32,fgFLOAT32,flgr_defop_tan_fgFLOAT32);
03799 }
03800 
03801 void flgr1d_arith_tan_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03802   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT64,fgFLOAT64,flgr_defop_tan_fgFLOAT64);
03803 }
03804 
03806 
03811 
03812 FLGR_Ret flgr1d_arith_tan(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03813   FLGR_Ret ret;
03814 
03815   
03816 
03817   if((datdest==NULL) || (data1==NULL)) {
03818     POST_ERROR("Null objects!\n");
03819     return FLGR_RET_NULL_OBJECT;
03820   }
03821 
03822   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
03823 
03824   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_tan,datdest,data1);
03825 
03826 }
03827 
03828 /*******************************************************************************
03829  * ACOS
03830  *******************************************************************************/
03831 
03832 void flgr1d_arith_acos_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03833   flgr_no_define_type_function(FLGR_BIT);
03834 }
03835 void flgr1d_arith_acos_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03836   flgr_no_define_type_function(FLGR_UINT8);
03837 }
03838 
03839 void flgr1d_arith_acos_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03840   flgr_no_define_type_function(FLGR_UINT16);
03841 }
03842 
03843 void flgr1d_arith_acos_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03844   flgr_no_define_type_function(FLGR_UINT32);
03845 }
03846 
03847 void flgr1d_arith_acos_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03848   flgr_no_define_type_function(FLGR_INT8);
03849 }
03850 
03851 void flgr1d_arith_acos_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03852   flgr_no_define_type_function(FLGR_INT16);
03853 }
03854 
03855 void flgr1d_arith_acos_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03856   flgr_no_define_type_function(FLGR_INT32);
03857 }
03858 
03859 void flgr1d_arith_acos_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03860   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT32,fgFLOAT32,flgr_defop_acos_fgFLOAT32);
03861 }
03862 
03863 void flgr1d_arith_acos_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03864   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT64,fgFLOAT64,flgr_defop_acos_fgFLOAT64);
03865 }
03866 
03868 
03873 
03874 FLGR_Ret flgr1d_arith_acos(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03875   FLGR_Ret ret;
03876 
03877   
03878 
03879   if((datdest==NULL) || (data1==NULL)) {
03880     POST_ERROR("Null objects!\n");
03881     return FLGR_RET_NULL_OBJECT;
03882   }
03883 
03884   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
03885 
03886   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_acos,datdest,data1);
03887 
03888 }
03889 
03890 /*******************************************************************************
03891  * ASIN
03892  *******************************************************************************/
03893 
03894 void flgr1d_arith_asin_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03895   flgr_no_define_type_function(FLGR_BIT);
03896 }
03897 void flgr1d_arith_asin_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03898   flgr_no_define_type_function(FLGR_UINT8);
03899 }
03900 
03901 void flgr1d_arith_asin_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03902   flgr_no_define_type_function(FLGR_UINT16);
03903 }
03904 
03905 void flgr1d_arith_asin_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03906   flgr_no_define_type_function(FLGR_UINT32);
03907 }
03908 
03909 void flgr1d_arith_asin_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03910   flgr_no_define_type_function(FLGR_INT8);
03911 }
03912 
03913 void flgr1d_arith_asin_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03914   flgr_no_define_type_function(FLGR_INT16);
03915 }
03916 
03917 void flgr1d_arith_asin_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03918   flgr_no_define_type_function(FLGR_INT32);
03919 }
03920 
03921 void flgr1d_arith_asin_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03922   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT32,fgFLOAT32,flgr_defop_asin_fgFLOAT32);
03923 }
03924 
03925 void flgr1d_arith_asin_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03926   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT64,fgFLOAT64,flgr_defop_asin_fgFLOAT64);
03927 }
03928 
03930 
03935 
03936 FLGR_Ret flgr1d_arith_asin(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03937   FLGR_Ret ret;
03938 
03939   
03940 
03941   if((datdest==NULL) || (data1==NULL)) {
03942     POST_ERROR("Null objects!\n");
03943     return FLGR_RET_NULL_OBJECT;
03944   }
03945 
03946   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
03947 
03948   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_asin,datdest,data1);
03949 
03950 }
03951 
03952 /*******************************************************************************
03953  * ATAN
03954  *******************************************************************************/
03955 
03956 void flgr1d_arith_atan_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03957   flgr_no_define_type_function(FLGR_BIT);
03958 }
03959 void flgr1d_arith_atan_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03960   flgr_no_define_type_function(FLGR_UINT8);
03961 }
03962 
03963 void flgr1d_arith_atan_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03964   flgr_no_define_type_function(FLGR_UINT16);
03965 }
03966 
03967 void flgr1d_arith_atan_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03968   flgr_no_define_type_function(FLGR_UINT32);
03969 }
03970 
03971 void flgr1d_arith_atan_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03972   flgr_no_define_type_function(FLGR_INT8);
03973 }
03974 
03975 void flgr1d_arith_atan_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03976   flgr_no_define_type_function(FLGR_INT16);
03977 }
03978 
03979 void flgr1d_arith_atan_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03980   flgr_no_define_type_function(FLGR_INT32);
03981 }
03982 
03983 void flgr1d_arith_atan_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03984   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT32,fgFLOAT32,flgr_defop_atan_fgFLOAT32);
03985 }
03986 
03987 void flgr1d_arith_atan_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03988   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT64,fgFLOAT64,flgr_defop_atan_fgFLOAT64);
03989 }
03990 
03992 
03997 
03998 FLGR_Ret flgr1d_arith_atan(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
03999   FLGR_Ret ret;
04000 
04001   
04002 
04003   if((datdest==NULL) || (data1==NULL)) {
04004     POST_ERROR("Null objects!\n");
04005     return FLGR_RET_NULL_OBJECT;
04006   }
04007 
04008   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04009 
04010   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_atan,datdest,data1);
04011 
04012 }
04013 
04014 
04015 
04016 
04017 /*******************************************************************************
04018  * FLOOR
04019  *******************************************************************************/
04020 
04021 void flgr1d_arith_floor_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04022   flgr_no_define_type_function(FLGR_BIT);
04023 }
04024 void flgr1d_arith_floor_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04025   flgr_no_define_type_function(FLGR_UINT8);
04026 }
04027 
04028 void flgr1d_arith_floor_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04029   flgr_no_define_type_function(FLGR_UINT16);
04030 }
04031 
04032 void flgr1d_arith_floor_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04033   flgr_no_define_type_function(FLGR_UINT32);
04034 }
04035 
04036 void flgr1d_arith_floor_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04037   flgr_no_define_type_function(FLGR_INT8);
04038 }
04039 
04040 void flgr1d_arith_floor_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04041   flgr_no_define_type_function(FLGR_INT16);
04042 }
04043 
04044 void flgr1d_arith_floor_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04045   flgr_no_define_type_function(FLGR_INT32);
04046 }
04047 
04048 void flgr1d_arith_floor_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04049   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT32,fgFLOAT32,flgr_defop_floor_fgFLOAT32);
04050 }
04051 
04052 void flgr1d_arith_floor_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04053   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT64,fgFLOAT64,flgr_defop_floor_fgFLOAT64);
04054 }
04055 
04057 
04062 
04063 FLGR_Ret flgr1d_arith_floor(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04064   FLGR_Ret ret;
04065 
04066   
04067 
04068   if((datdest==NULL) || (data1==NULL)) {
04069     POST_ERROR("Null objects!\n");
04070     return FLGR_RET_NULL_OBJECT;
04071   }
04072 
04073   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04074 
04075   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_floor,datdest,data1);
04076 
04077 }
04078 
04079 
04080 
04081 
04082 /*******************************************************************************
04083  * CEIL
04084  *******************************************************************************/
04085 
04086 void flgr1d_arith_ceil_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04087   flgr_no_define_type_function(FLGR_BIT);
04088 }
04089 void flgr1d_arith_ceil_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04090   flgr_no_define_type_function(FLGR_UINT8);
04091 }
04092 
04093 void flgr1d_arith_ceil_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04094   flgr_no_define_type_function(FLGR_UINT16);
04095 }
04096 
04097 void flgr1d_arith_ceil_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04098   flgr_no_define_type_function(FLGR_UINT32);
04099 }
04100 
04101 void flgr1d_arith_ceil_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04102   flgr_no_define_type_function(FLGR_INT8);
04103 }
04104 
04105 void flgr1d_arith_ceil_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04106   flgr_no_define_type_function(FLGR_INT16);
04107 }
04108 
04109 void flgr1d_arith_ceil_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04110   flgr_no_define_type_function(FLGR_INT32);
04111 }
04112 
04113 void flgr1d_arith_ceil_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04114   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT32,fgFLOAT32,flgr_defop_ceil_fgFLOAT32);
04115 }
04116 
04117 void flgr1d_arith_ceil_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04118   FLGR_MACRO_ARITH_1D_MONOADIC(fgFLOAT64,fgFLOAT64,flgr_defop_ceil_fgFLOAT64);
04119 }
04120 
04122 
04127 
04128 FLGR_Ret flgr1d_arith_ceil(FLGR_Data1D *datdest, FLGR_Data1D *data1) {
04129   FLGR_Ret ret;
04130 
04131   
04132 
04133   if((datdest==NULL) || (data1==NULL)) {
04134     POST_ERROR("Null objects!\n");
04135     return FLGR_RET_NULL_OBJECT;
04136   }
04137 
04138   if((ret = flgr1d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04139 
04140   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_arith_ceil,datdest,data1);
04141 
04142 }
04143 
04144 
04145 
04146 
04147 
04148 
04149 
04150 
04151 
04152 
04153 
04154 
04155 
04156 /****************************************************************************************************/
04157 /****************************************************************************************************/
04158 /****************************************************************************************************/
04159 /****************************************** 2D Functions ********************************************/
04160 /****************************************************************************************************/
04161 /****************************************************************************************************/
04162 /****************************************************************************************************/
04163 
04164 
04165 
04166 /*******************************************************************************
04167  *******************************************************************************
04168  *******************************************************************************
04169  * MACRO
04170  *******************************************************************************
04171  *******************************************************************************
04172  *******************************************************************************/
04173 
04174 #define FLGR_MACRO_ARITH_2D_DIADIC(fct,dtype)               \
04175   FLGR_Data1D **pdest = datdest->row;                   \
04176   FLGR_Data1D **p1 = data1->row;                    \
04177   FLGR_Data1D **p2 = data2->row;                    \
04178   int i;                                \
04179                                     \
04180                         \
04181                                     \
04182   for(i=0 ; i<data1->size_y ; i++,pdest++,p1++,p2++) {          \
04183     fct##_##dtype(*pdest,*p1,*p2);                  \
04184   }                                 \
04185   return
04186 
04187 #define FLGR_MACRO_ARITH_2D_DIADIC_CONST(fct,dtype)         \
04188   FLGR_Data1D **pdest = datdest->row;                   \
04189   FLGR_Data1D **p1 = data1->row;                    \
04190   int i;                                \
04191                                     \
04192                         \
04193                                     \
04194   for(i=0 ; i<data1->size_y ; i++,pdest++,p1++) {           \
04195     fct##_##dtype(*pdest,*p1,vec_const);                \
04196   }                                 \
04197   return
04198 
04199 #define FLGR_MACRO_ARITH_2D_MONOADIC(fct,dtype)             \
04200   FLGR_Data1D **pdest = datdest->row;                   \
04201   FLGR_Data1D **p1 = data1->row;                    \
04202   int i;                                \
04203                                     \
04204                         \
04205                                     \
04206   for(i=0 ; i<data1->size_y ; i++,pdest++,p1++) {           \
04207     fct##_##dtype(*pdest,*p1);                      \
04208   }                                 \
04209   return
04210 
04211 #define FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(fct,dtype,param)     \
04212   FLGR_Data1D **pdest = datdest->row;                   \
04213   FLGR_Data1D **p1 = data1->row;                    \
04214   int i;                                \
04215                                     \
04216                         \
04217                                     \
04218   for(i=0 ; i<data1->size_y ; i++,pdest++,p1++) {           \
04219     fct##_##dtype(*pdest,*p1,param);                    \
04220   }                                 \
04221   return
04222 
04223 /*******************************************************************************
04224  *******************************************************************************
04225  *******************************************************************************
04226  * DIADIC OPERATIONS
04227  *******************************************************************************
04228  *******************************************************************************
04229  *******************************************************************************/
04230 
04232 
04240 /*******************************************************************************
04241  * INF
04242  *******************************************************************************/
04243 
04244 void flgr2d_arith_inf_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04245   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_inf,fgBIT);
04246 }
04247 void flgr2d_arith_inf_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04248   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_inf,fgUINT8);
04249 }
04250 void flgr2d_arith_inf_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04251   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_inf,fgUINT16);
04252 }
04253 void flgr2d_arith_inf_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04254   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_inf,fgUINT32);
04255 }
04256 void flgr2d_arith_inf_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04257   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_inf,fgINT8);
04258 }
04259 void flgr2d_arith_inf_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04260   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_inf,fgINT16);
04261 }
04262 void flgr2d_arith_inf_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04263   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_inf,fgINT32);
04264 }
04265 void flgr2d_arith_inf_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04266   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_inf,fgFLOAT32);
04267 }
04268 void flgr2d_arith_inf_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04269   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_inf,fgFLOAT64);
04270 }
04271 
04273 
04279 
04280 FLGR_Ret flgr2d_arith_inf(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04281   FLGR_Ret ret;
04282 
04283   
04284 
04285   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
04286     POST_ERROR("Null objects!\n");
04287     return FLGR_RET_NULL_OBJECT;
04288   }
04289 
04290   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04291   if((ret = flgr2d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04292 
04293   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_inf,datdest,data1,data2);
04294 
04295 }
04296 
04297 
04298 /*******************************************************************************
04299  * SUP
04300  *******************************************************************************/
04301 
04302 void flgr2d_arith_sup_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04303   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sup,fgBIT);
04304 }
04305 void flgr2d_arith_sup_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04306   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sup,fgUINT8);
04307 }
04308 void flgr2d_arith_sup_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04309   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sup,fgUINT16);
04310 }
04311 void flgr2d_arith_sup_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04312   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sup,fgUINT32);
04313 }
04314 void flgr2d_arith_sup_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04315   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sup,fgINT8);
04316 }
04317 void flgr2d_arith_sup_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04318   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sup,fgINT16);
04319 }
04320 void flgr2d_arith_sup_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04321   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sup,fgINT32);
04322 }
04323 void flgr2d_arith_sup_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04324   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sup,fgFLOAT32);
04325 }
04326 void flgr2d_arith_sup_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04327   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sup,fgFLOAT64);
04328 }
04329 
04331 
04337 
04338 FLGR_Ret flgr2d_arith_sup(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04339   FLGR_Ret ret;
04340 
04341   
04342 
04343   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
04344     POST_ERROR("Null objects!\n");
04345     return FLGR_RET_NULL_OBJECT;
04346   }
04347 
04348   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04349   if((ret = flgr2d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04350 
04351   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_sup,datdest,data1,data2);
04352 
04353 }
04354 
04355 /*******************************************************************************
04356  * AND
04357  *******************************************************************************/
04358 
04359 void flgr2d_arith_and_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04360   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_and,fgBIT);
04361 }
04362 void flgr2d_arith_and_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04363   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_and,fgUINT8);
04364 }
04365 void flgr2d_arith_and_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04366   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_and,fgUINT16);
04367 }
04368 void flgr2d_arith_and_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04369   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_and,fgUINT32);
04370 }
04371 void flgr2d_arith_and_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04372   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_and,fgINT8);
04373 }
04374 void flgr2d_arith_and_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04375   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_and,fgINT16);
04376 }
04377 void flgr2d_arith_and_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04378   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_and,fgINT32);
04379 }
04380 void flgr2d_arith_and_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04381   flgr_no_define_type_function(FLGR_FLOAT32);
04382 }
04383 void flgr2d_arith_and_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04384   flgr_no_define_type_function(FLGR_FLOAT64);
04385 }
04386 
04388 
04394 
04395 FLGR_Ret flgr2d_arith_and(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04396   FLGR_Ret ret;
04397 
04398   
04399 
04400   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
04401     POST_ERROR("Null objects!\n");
04402     return FLGR_RET_NULL_OBJECT;
04403   }
04404 
04405   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04406   if((ret = flgr2d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04407 
04408   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_and,datdest,data1,data2);
04409 
04410 }
04411 
04412 
04413 /*******************************************************************************
04414  * OR
04415  *******************************************************************************/
04416 
04417 void flgr2d_arith_or_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04418   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_or,fgBIT);
04419 }
04420 void flgr2d_arith_or_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04421   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_or,fgUINT8);
04422 }
04423 void flgr2d_arith_or_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04424   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_or,fgUINT16);
04425 }
04426 void flgr2d_arith_or_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04427   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_or,fgUINT32);
04428 }
04429 void flgr2d_arith_or_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04430   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_or,fgINT8);
04431 }
04432 void flgr2d_arith_or_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04433   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_or,fgINT16);
04434 }
04435 void flgr2d_arith_or_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04436   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_or,fgINT32);
04437 }
04438 void flgr2d_arith_or_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04439   flgr_no_define_type_function(FLGR_FLOAT32);
04440 }
04441 void flgr2d_arith_or_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04442   flgr_no_define_type_function(FLGR_FLOAT64);
04443 }
04444 
04446 
04452 
04453 FLGR_Ret flgr2d_arith_or(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04454   FLGR_Ret ret;
04455 
04456   
04457 
04458   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
04459     POST_ERROR("Null objects!\n");
04460     return FLGR_RET_NULL_OBJECT;
04461   }
04462 
04463   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04464   if((ret = flgr2d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04465 
04466   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_or,datdest,data1,data2);
04467 
04468 }
04469 
04470 
04471 /*******************************************************************************
04472  * XOR
04473  *******************************************************************************/
04474 
04475 void flgr2d_arith_xor_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04476   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_xor,fgBIT);
04477 }
04478 void flgr2d_arith_xor_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04479   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_xor,fgUINT8);
04480 }
04481 void flgr2d_arith_xor_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04482   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_xor,fgUINT16);
04483 }
04484 void flgr2d_arith_xor_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04485   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_xor,fgUINT32);
04486 }
04487 void flgr2d_arith_xor_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04488   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_xor,fgINT8);
04489 }
04490 void flgr2d_arith_xor_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04491   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_xor,fgINT16);
04492 }
04493 void flgr2d_arith_xor_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04494   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_xor,fgINT32);
04495 }
04496 void flgr2d_arith_xor_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04497   flgr_no_define_type_function(FLGR_FLOAT32);
04498 }
04499 void flgr2d_arith_xor_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04500   flgr_no_define_type_function(FLGR_FLOAT64);
04501 }
04502 
04504 
04510 
04511 FLGR_Ret flgr2d_arith_xor(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04512   FLGR_Ret ret;
04513 
04514   
04515 
04516   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
04517     POST_ERROR("Null objects!\n");
04518     return FLGR_RET_NULL_OBJECT;
04519   }
04520 
04521   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04522   if((ret = flgr2d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04523 
04524   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_xor,datdest,data1,data2);
04525 
04526 }
04527 
04528 
04529 /*******************************************************************************
04530  * ATAN2
04531  *******************************************************************************/
04532 
04533 void flgr2d_arith_atan2_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04534   flgr_no_define_type_function(FLGR_BIT);
04535 }
04536 void flgr2d_arith_atan2_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04537   flgr_no_define_type_function(FLGR_UINT8);
04538 }
04539 void flgr2d_arith_atan2_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04540   flgr_no_define_type_function(FLGR_UINT16);
04541 }
04542 void flgr2d_arith_atan2_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04543   flgr_no_define_type_function(FLGR_UINT32);
04544 }
04545 void flgr2d_arith_atan2_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04546   flgr_no_define_type_function(FLGR_INT8);
04547 }
04548 void flgr2d_arith_atan2_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04549   flgr_no_define_type_function(FLGR_INT16);
04550 }
04551 void flgr2d_arith_atan2_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04552   flgr_no_define_type_function(FLGR_INT32);
04553 }
04554 void flgr2d_arith_atan2_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04555   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_atan2,fgFLOAT32);
04556 }
04557 void flgr2d_arith_atan2_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04558   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_atan2,fgFLOAT64);
04559 }
04560 
04562 
04568 
04569 FLGR_Ret flgr2d_arith_atan2(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04570   FLGR_Ret ret;
04571 
04572   
04573 
04574   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
04575     POST_ERROR("Null objects!\n");
04576     return FLGR_RET_NULL_OBJECT;
04577   }
04578 
04579   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04580   if((ret = flgr2d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04581 
04582   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_atan2,datdest,data1,data2);
04583 
04584 }
04585 
04586 
04587 /*******************************************************************************
04588  * ARGUMENT
04589  *******************************************************************************/
04590 
04591 void flgr2d_arith_argument_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04592   flgr_no_define_type_function(FLGR_BIT);
04593 }
04594 void flgr2d_arith_argument_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04595   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_argument,fgUINT8);
04596 }
04597 void flgr2d_arith_argument_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04598   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_argument,fgUINT16);
04599 }
04600 void flgr2d_arith_argument_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04601   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_argument,fgUINT32);
04602 }
04603 void flgr2d_arith_argument_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04604   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_argument,fgINT8);
04605 }
04606 void flgr2d_arith_argument_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04607   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_argument,fgINT16);
04608 }
04609 void flgr2d_arith_argument_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04610   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_argument,fgINT32);
04611 }
04612 void flgr2d_arith_argument_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04613   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_argument,fgFLOAT32);
04614 }
04615 void flgr2d_arith_argument_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04616   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_argument,fgFLOAT64);
04617 }
04618 
04620 
04626 
04627 FLGR_Ret flgr2d_arith_argument(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04628   FLGR_Ret ret;
04629 
04630   
04631 
04632   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
04633     POST_ERROR("Null objects!\n");
04634     return FLGR_RET_NULL_OBJECT;
04635   }
04636 
04637   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04638   if((ret = flgr2d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04639 
04640   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_argument,datdest,data1,data2);
04641 
04642 }
04643 
04644 
04645 
04646 /*******************************************************************************
04647  * MODULE
04648  *******************************************************************************/
04649 
04650 void flgr2d_arith_module_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04651   flgr_no_define_type_function(FLGR_BIT);
04652 }
04653 void flgr2d_arith_module_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04654   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_module,fgUINT8);
04655 }
04656 void flgr2d_arith_module_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04657   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_module,fgUINT16);
04658 }
04659 void flgr2d_arith_module_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04660   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_module,fgUINT32);
04661 }
04662 void flgr2d_arith_module_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04663   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_module,fgINT8);
04664 }
04665 void flgr2d_arith_module_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04666   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_module,fgINT16);
04667 }
04668 void flgr2d_arith_module_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04669   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_module,fgINT32);
04670 }
04671 void flgr2d_arith_module_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04672   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_module,fgFLOAT32);
04673 }
04674 void flgr2d_arith_module_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04675   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_module,fgFLOAT64);
04676 }
04677 
04679 
04685 
04686 FLGR_Ret flgr2d_arith_module(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04687   FLGR_Ret ret;
04688 
04689   
04690 
04691   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
04692     POST_ERROR("Null objects!\n");
04693     return FLGR_RET_NULL_OBJECT;
04694   }
04695 
04696   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04697   if((ret = flgr2d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04698 
04699   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_module,datdest,data1,data2);
04700 
04701 }
04702 
04703 
04704 /*******************************************************************************
04705  * MULTSAT
04706  *******************************************************************************/
04707 
04708 void flgr2d_arith_multsat_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04709   flgr_no_define_type_function(FLGR_BIT);
04710 }
04711 void flgr2d_arith_multsat_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04712   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_multsat,fgUINT8);
04713 }
04714 void flgr2d_arith_multsat_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04715   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_multsat,fgUINT16);
04716 }
04717 void flgr2d_arith_multsat_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04718   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_multsat,fgUINT32);
04719 }
04720 void flgr2d_arith_multsat_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04721   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_multsat,fgINT8);
04722 }
04723 void flgr2d_arith_multsat_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04724   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_multsat,fgINT16);
04725 }
04726 void flgr2d_arith_multsat_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04727   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_multsat,fgINT32);
04728 }
04729 void flgr2d_arith_multsat_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04730   flgr_no_define_type_function(FLGR_FLOAT32);
04731 }
04732 void flgr2d_arith_multsat_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04733   flgr_no_define_type_function(FLGR_FLOAT64);
04734 }
04735 
04737 
04743 
04744 FLGR_Ret flgr2d_arith_multsat(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04745   FLGR_Ret ret;
04746 
04747   
04748 
04749   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
04750     POST_ERROR("Null objects!\n");
04751     return FLGR_RET_NULL_OBJECT;
04752   }
04753 
04754   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04755   if((ret = flgr2d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04756 
04757   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_multsat,datdest,data1,data2);
04758 
04759 }
04760 
04761 
04762 
04763 /*******************************************************************************
04764  * SUBSAT
04765  *******************************************************************************/
04766 
04767 void flgr2d_arith_subsat_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04768   flgr_no_define_type_function(FLGR_BIT);
04769 }
04770 void flgr2d_arith_subsat_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04771   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_subsat,fgUINT8);
04772 }
04773 void flgr2d_arith_subsat_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04774   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_subsat,fgUINT16);
04775 }
04776 void flgr2d_arith_subsat_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04777   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_subsat,fgUINT32);
04778 }
04779 void flgr2d_arith_subsat_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04780   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_subsat,fgINT8);
04781 }
04782 void flgr2d_arith_subsat_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04783   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_subsat,fgINT16);
04784 }
04785 void flgr2d_arith_subsat_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04786   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_subsat,fgINT32);
04787 }
04788 void flgr2d_arith_subsat_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04789   flgr_no_define_type_function(FLGR_FLOAT32);
04790 }
04791 void flgr2d_arith_subsat_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04792   flgr_no_define_type_function(FLGR_FLOAT64);
04793 }
04794 
04796 
04802 
04803 FLGR_Ret flgr2d_arith_subsat(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04804   FLGR_Ret ret;
04805 
04806   
04807 
04808   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
04809     POST_ERROR("Null objects!\n");
04810     return FLGR_RET_NULL_OBJECT;
04811   }
04812 
04813   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04814   if((ret = flgr2d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04815 
04816   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_subsat,datdest,data1,data2);
04817 
04818 }
04819 
04820 
04821 
04822 /*******************************************************************************
04823  * ADDSAT
04824  *******************************************************************************/
04825 
04826 void flgr2d_arith_addsat_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04827   flgr_no_define_type_function(FLGR_BIT);
04828 }
04829 void flgr2d_arith_addsat_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04830   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_addsat,fgUINT8);
04831 }
04832 void flgr2d_arith_addsat_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04833   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_addsat,fgUINT16);
04834 }
04835 void flgr2d_arith_addsat_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04836   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_addsat,fgUINT32);
04837 }
04838 void flgr2d_arith_addsat_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04839   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_addsat,fgINT8);
04840 }
04841 void flgr2d_arith_addsat_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04842   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_addsat,fgINT16);
04843 }
04844 void flgr2d_arith_addsat_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04845   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_addsat,fgINT32);
04846 }
04847 void flgr2d_arith_addsat_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04848   flgr_no_define_type_function(FLGR_FLOAT32);
04849 }
04850 void flgr2d_arith_addsat_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04851   flgr_no_define_type_function(FLGR_FLOAT64);
04852 }
04853 
04855 
04861 
04862 FLGR_Ret flgr2d_arith_addsat(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04863   FLGR_Ret ret;
04864 
04865   
04866 
04867   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
04868     POST_ERROR("Null objects!\n");
04869     return FLGR_RET_NULL_OBJECT;
04870   }
04871 
04872   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04873   if((ret = flgr2d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04874 
04875   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_addsat,datdest,data1,data2);
04876 
04877 }
04878 
04879 
04880 
04881 /*******************************************************************************
04882  * DIV
04883  *******************************************************************************/
04884 
04885 void flgr2d_arith_div_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04886   flgr_no_define_type_function(FLGR_BIT);
04887 }
04888 void flgr2d_arith_div_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04889   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_div,fgUINT8);
04890 }
04891 void flgr2d_arith_div_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04892   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_div,fgUINT16);
04893 }
04894 void flgr2d_arith_div_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04895   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_div,fgUINT32);
04896 }
04897 void flgr2d_arith_div_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04898   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_div,fgINT8);
04899 }
04900 void flgr2d_arith_div_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04901   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_div,fgINT16);
04902 }
04903 void flgr2d_arith_div_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04904   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_div,fgINT32);
04905 }
04906 void flgr2d_arith_div_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04907   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_div,fgFLOAT32);
04908 }
04909 void flgr2d_arith_div_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04910   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_div,fgFLOAT64);
04911 }
04912 
04914 
04920 
04921 FLGR_Ret flgr2d_arith_div(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04922   FLGR_Ret ret;
04923 
04924   
04925 
04926   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
04927     POST_ERROR("Null objects!\n");
04928     return FLGR_RET_NULL_OBJECT;
04929   }
04930 
04931   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04932   if((ret = flgr2d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04933 
04934   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_div,datdest,data1,data2);
04935 
04936 }
04937 
04938 
04939 
04940 /*******************************************************************************
04941  * MULT
04942  *******************************************************************************/
04943 
04944 void flgr2d_arith_mult_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04945   flgr_no_define_type_function(FLGR_BIT);
04946 }
04947 void flgr2d_arith_mult_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04948   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_mult,fgUINT8);
04949 }
04950 void flgr2d_arith_mult_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04951   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_mult,fgUINT16);
04952 }
04953 void flgr2d_arith_mult_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04954   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_mult,fgUINT32);
04955 }
04956 void flgr2d_arith_mult_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04957   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_mult,fgINT8);
04958 }
04959 void flgr2d_arith_mult_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04960   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_mult,fgINT16);
04961 }
04962 void flgr2d_arith_mult_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04963   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_mult,fgINT32);
04964 }
04965 void flgr2d_arith_mult_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04966   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_mult,fgFLOAT32);
04967 }
04968 void flgr2d_arith_mult_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04969   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_mult,fgFLOAT64);
04970 }
04971 
04973 
04979 
04980 FLGR_Ret flgr2d_arith_mult(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
04981   FLGR_Ret ret;
04982 
04983   
04984 
04985   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
04986     POST_ERROR("Null objects!\n");
04987     return FLGR_RET_NULL_OBJECT;
04988   }
04989 
04990   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04991   if((ret = flgr2d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
04992 
04993   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_mult,datdest,data1,data2);
04994 
04995 }
04996 
04997 
04998 /*******************************************************************************
04999  * SUB
05000  *******************************************************************************/
05001 
05002 void flgr2d_arith_sub_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05003   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sub,fgBIT);
05004 }
05005 void flgr2d_arith_sub_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05006   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sub,fgUINT8);
05007 }
05008 void flgr2d_arith_sub_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05009   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sub,fgUINT16);
05010 }
05011 void flgr2d_arith_sub_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05012   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sub,fgUINT32);
05013 }
05014 void flgr2d_arith_sub_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05015   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sub,fgINT8);
05016 }
05017 void flgr2d_arith_sub_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05018   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sub,fgINT16);
05019 }
05020 void flgr2d_arith_sub_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05021   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sub,fgINT32);
05022 }
05023 void flgr2d_arith_sub_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05024   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sub,fgFLOAT32);
05025 }
05026 void flgr2d_arith_sub_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05027   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_sub,fgFLOAT64);
05028 }
05029 
05031 
05037 
05038 FLGR_Ret flgr2d_arith_sub(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05039   FLGR_Ret ret;
05040 
05041   
05042 
05043   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
05044     POST_ERROR("Null objects!\n");
05045     return FLGR_RET_NULL_OBJECT;
05046   }
05047 
05048   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
05049   if((ret = flgr2d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
05050 
05051   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_sub,datdest,data1,data2);
05052 
05053 }
05054 
05055 
05056 /*******************************************************************************
05057  * ADD
05058  *******************************************************************************/
05059 
05060 void flgr2d_arith_add_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05061   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_add,fgBIT);
05062 }
05063 void flgr2d_arith_add_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05064   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_add,fgUINT8);
05065 }
05066 void flgr2d_arith_add_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05067   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_add,fgUINT16);
05068 }
05069 void flgr2d_arith_add_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05070   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_add,fgUINT32);
05071 }
05072 void flgr2d_arith_add_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05073   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_add,fgINT8);
05074 }
05075 void flgr2d_arith_add_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05076   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_add,fgINT16);
05077 }
05078 void flgr2d_arith_add_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05079   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_add,fgINT32);
05080 }
05081 void flgr2d_arith_add_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05082   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_add,fgFLOAT32);
05083 }
05084 void flgr2d_arith_add_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05085   FLGR_MACRO_ARITH_2D_DIADIC(flgr1d_arith_add,fgFLOAT64);
05086 }
05087 
05089 
05095 
05096 FLGR_Ret flgr2d_arith_add(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Data2D *data2) {
05097   FLGR_Ret ret;
05098 
05099   
05100 
05101   if((datdest==NULL) || (data1==NULL) || (data2==NULL)) {
05102     POST_ERROR("Null objects!\n");
05103     return FLGR_RET_NULL_OBJECT;
05104   }
05105 
05106   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
05107   if((ret = flgr2d_is_data_same_attributes(data2,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
05108 
05109   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_add,datdest,data1,data2);
05110 
05111 }
05112 
05113 
05114 
05115 
05116 
05117 /*******************************************************************************
05118  *******************************************************************************
05119  *******************************************************************************
05120  * DIADIC CONST OPERATIONS
05121  *******************************************************************************
05122  *******************************************************************************
05123  *******************************************************************************/
05124 
05125 
05126 /*******************************************************************************
05127  * INF CONST
05128  *******************************************************************************/
05129 
05130 void flgr2d_arith_const_inf_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05131   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_inf,fgBIT);
05132 }
05133 void flgr2d_arith_const_inf_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05134   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_inf,fgUINT8);
05135 }
05136 void flgr2d_arith_const_inf_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05137   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_inf,fgUINT16);
05138 }
05139 void flgr2d_arith_const_inf_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05140   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_inf,fgUINT32);
05141 }
05142 void flgr2d_arith_const_inf_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05143   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_inf,fgINT8);
05144 }
05145 void flgr2d_arith_const_inf_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05146   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_inf,fgINT16);
05147 }
05148 void flgr2d_arith_const_inf_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05149   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_inf,fgINT32);
05150 }
05151 void flgr2d_arith_const_inf_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05152   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_inf,fgFLOAT32);
05153 }
05154 void flgr2d_arith_const_inf_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05155   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_inf,fgFLOAT64);
05156 }
05157 
05159 
05165 
05166 FLGR_Ret flgr2d_arith_const_inf_ptr(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05167   FLGR_Ret ret;
05168 
05169   
05170 
05171   if((datdest==NULL) || (data1==NULL)) {
05172     POST_ERROR("Null objects!\n");
05173     return FLGR_RET_NULL_OBJECT;
05174   }
05175 
05176   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
05177 
05178   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_const_inf,datdest,data1,vec_const);
05179 }
05180 
05182 
05188 
05189 FLGR_Ret flgr2d_arith_const_inf_str(FLGR_Data2D *datdest, FLGR_Data2D *data1, char *constant) {
05190   int ret;
05191   FLGR_Vector *vector_constant;
05192 
05193   if((data1==NULL) || (datdest==NULL))  {
05194     POST_ERROR("Null objects!\n");
05195     return FLGR_RET_NULL_OBJECT;
05196   }
05197 
05198   vector_constant = flgr_vector_create(data1->spp,data1->type);
05199 
05200   if((ret=flgr_vector_import_string(vector_constant, constant))
05201      != FLGR_RET_OK) {
05202 
05203     POST_ERROR("String is not valid ""%s""\n",constant);
05204     flgr_vector_destroy(vector_constant);
05205     return ret;
05206   }
05207 
05208   ret = flgr2d_arith_const_inf_ptr(datdest,data1,vector_constant);
05209 
05210   flgr_vector_destroy(vector_constant);
05211 
05212   return ret;
05213 
05214 }
05215 
05216 
05217 
05218 
05219 /*******************************************************************************
05220  * SUP CONST
05221  *******************************************************************************/
05222 
05223 void flgr2d_arith_const_sup_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05224   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sup,fgBIT);
05225 }
05226 void flgr2d_arith_const_sup_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05227   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sup,fgUINT8);
05228 }
05229 void flgr2d_arith_const_sup_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05230   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sup,fgUINT16);
05231 }
05232 void flgr2d_arith_const_sup_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05233   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sup,fgUINT32);
05234 }
05235 void flgr2d_arith_const_sup_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05236   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sup,fgINT8);
05237 }
05238 void flgr2d_arith_const_sup_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05239   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sup,fgINT16);
05240 }
05241 void flgr2d_arith_const_sup_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05242   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sup,fgINT32);
05243 }
05244 void flgr2d_arith_const_sup_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05245   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sup,fgFLOAT32);
05246 }
05247 void flgr2d_arith_const_sup_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05248   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sup,fgFLOAT64);
05249 }
05250 
05252 
05258 
05259 FLGR_Ret flgr2d_arith_const_sup_ptr(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05260   FLGR_Ret ret;
05261 
05262   
05263 
05264   if((datdest==NULL) || (data1==NULL)) {
05265     POST_ERROR("Null objects!\n");
05266     return FLGR_RET_NULL_OBJECT;
05267   }
05268 
05269   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
05270 
05271   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_const_sup,datdest,data1,vec_const);
05272 }
05273 
05275 
05281 
05282 FLGR_Ret flgr2d_arith_const_sup_str(FLGR_Data2D *datdest, FLGR_Data2D *data1, char *constant) {
05283   int ret;
05284   FLGR_Vector *vector_constant;
05285 
05286   if((data1==NULL) || (datdest==NULL))  {
05287     POST_ERROR("Null objects!\n");
05288     return FLGR_RET_NULL_OBJECT;
05289   }
05290 
05291   vector_constant = flgr_vector_create(data1->spp,data1->type);
05292 
05293   if((ret=flgr_vector_import_string(vector_constant, constant))
05294      != FLGR_RET_OK) {
05295 
05296     POST_ERROR("String is not valid ""%s""\n",constant);
05297     flgr_vector_destroy(vector_constant);
05298     return ret;
05299   }
05300 
05301   ret = flgr2d_arith_const_sup_ptr(datdest,data1,vector_constant);
05302 
05303 
05304   flgr_vector_destroy(vector_constant);
05305 
05306   return ret;
05307 
05308 }
05309 
05310 
05311 
05312 /*******************************************************************************
05313  * AND CONST
05314  *******************************************************************************/
05315 
05316 void flgr2d_arith_const_and_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05317   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_and,fgBIT);
05318 }
05319 void flgr2d_arith_const_and_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05320   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_and,fgUINT8);
05321 }
05322 void flgr2d_arith_const_and_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05323   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_and,fgUINT16);
05324 }
05325 void flgr2d_arith_const_and_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05326   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_and,fgUINT32);
05327 }
05328 void flgr2d_arith_const_and_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05329   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_and,fgINT8);
05330 }
05331 void flgr2d_arith_const_and_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05332   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_and,fgINT16);
05333 }
05334 void flgr2d_arith_const_and_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05335   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_and,fgINT32);
05336 }
05337 void flgr2d_arith_const_and_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05338   flgr_no_define_type_function(FLGR_FLOAT32);
05339 }
05340 void flgr2d_arith_const_and_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05341   flgr_no_define_type_function(FLGR_FLOAT64);
05342 }
05343 
05345 
05351 
05352 FLGR_Ret flgr2d_arith_const_and_ptr(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05353   FLGR_Ret ret;
05354 
05355   
05356 
05357   if((datdest==NULL) || (data1==NULL)) {
05358     POST_ERROR("Null objects!\n");
05359     return FLGR_RET_NULL_OBJECT;
05360   }
05361 
05362   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
05363 
05364   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_const_and,datdest,data1,vec_const);
05365 }
05366 
05368 
05374 
05375 FLGR_Ret flgr2d_arith_const_and_str(FLGR_Data2D *datdest, FLGR_Data2D *data1, char *constant) {
05376   int ret;
05377   FLGR_Vector *vector_constant;
05378 
05379   if((data1==NULL) || (datdest==NULL))  {
05380     POST_ERROR("Null objects!\n");
05381     return FLGR_RET_NULL_OBJECT;
05382   }
05383 
05384   vector_constant = flgr_vector_create(data1->spp,data1->type);
05385 
05386   if((ret=flgr_vector_import_string(vector_constant, constant))
05387      != FLGR_RET_OK) {
05388 
05389     POST_ERROR("String is not valid ""%s""\n",constant);
05390     flgr_vector_destroy(vector_constant);
05391     return ret;
05392   }
05393 
05394   ret = flgr2d_arith_const_and_ptr(datdest,data1,vector_constant);
05395 
05396 
05397   flgr_vector_destroy(vector_constant);
05398 
05399   return ret;
05400 
05401 }
05402 
05403 
05404 
05405 /*******************************************************************************
05406  * OR CONST
05407  *******************************************************************************/
05408 
05409 void flgr2d_arith_const_or_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05410   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_or,fgBIT);
05411 }
05412 void flgr2d_arith_const_or_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05413   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_or,fgUINT8);
05414 }
05415 void flgr2d_arith_const_or_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05416   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_or,fgUINT16);
05417 }
05418 void flgr2d_arith_const_or_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05419   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_or,fgUINT32);
05420 }
05421 void flgr2d_arith_const_or_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05422   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_or,fgINT8);
05423 }
05424 void flgr2d_arith_const_or_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05425   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_or,fgINT16);
05426 }
05427 void flgr2d_arith_const_or_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05428   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_or,fgINT32);
05429 }
05430 void flgr2d_arith_const_or_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05431   flgr_no_define_type_function(FLGR_FLOAT32);
05432 }
05433 void flgr2d_arith_const_or_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05434   flgr_no_define_type_function(FLGR_FLOAT64);
05435 }
05436 
05438 
05444 
05445 FLGR_Ret flgr2d_arith_const_or_ptr(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05446   FLGR_Ret ret;
05447 
05448   
05449 
05450   if((datdest==NULL) || (data1==NULL)) {
05451     POST_ERROR("Null objects!\n");
05452     return FLGR_RET_NULL_OBJECT;
05453   }
05454 
05455   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
05456 
05457   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_const_or,datdest,data1,vec_const);
05458 }
05459 
05461 
05467 
05468 FLGR_Ret flgr2d_arith_const_or_str(FLGR_Data2D *datdest, FLGR_Data2D *data1, char *constant) {
05469   int ret;
05470   FLGR_Vector *vector_constant;
05471 
05472   if((data1==NULL) || (datdest==NULL))  {
05473     POST_ERROR("Null objects!\n");
05474     return FLGR_RET_NULL_OBJECT;
05475   }
05476 
05477   vector_constant = flgr_vector_create(data1->spp,data1->type);
05478 
05479   if((ret=flgr_vector_import_string(vector_constant, constant))
05480      != FLGR_RET_OK) {
05481 
05482     POST_ERROR("String is not valid ""%s""\n",constant);
05483     flgr_vector_destroy(vector_constant);
05484     return ret;
05485   }
05486 
05487   ret = flgr2d_arith_const_or_ptr(datdest,data1,vector_constant);
05488 
05489 
05490   flgr_vector_destroy(vector_constant);
05491 
05492   return ret;
05493 
05494 }
05495 
05496 
05497 
05498 
05499 /*******************************************************************************
05500  * XOR CONST
05501  *******************************************************************************/
05502 
05503 void flgr2d_arith_const_xor_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05504   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_xor,fgBIT);
05505 }
05506 void flgr2d_arith_const_xor_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05507   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_xor,fgUINT8);
05508 }
05509 void flgr2d_arith_const_xor_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05510   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_xor,fgUINT16);
05511 }
05512 void flgr2d_arith_const_xor_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05513   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_xor,fgUINT32);
05514 }
05515 void flgr2d_arith_const_xor_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05516   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_xor,fgINT8);
05517 }
05518 void flgr2d_arith_const_xor_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05519   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_xor,fgINT16);
05520 }
05521 void flgr2d_arith_const_xor_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05522   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_xor,fgINT32);
05523 }
05524 void flgr2d_arith_const_xor_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05525   flgr_no_define_type_function(FLGR_FLOAT32);
05526 }
05527 void flgr2d_arith_const_xor_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05528   flgr_no_define_type_function(FLGR_FLOAT64);
05529 }
05530 
05532 
05538 
05539 FLGR_Ret flgr2d_arith_const_xor_ptr(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05540   FLGR_Ret ret;
05541 
05542   
05543 
05544   if((datdest==NULL) || (data1==NULL)) {
05545     POST_ERROR("Null objects!\n");
05546     return FLGR_RET_NULL_OBJECT;
05547   }
05548 
05549   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
05550 
05551   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_const_xor,datdest,data1,vec_const);
05552 }
05553 
05555 
05561 
05562 FLGR_Ret flgr2d_arith_const_xor_str(FLGR_Data2D *datdest, FLGR_Data2D *data1, char *constant) {
05563   int ret;
05564   FLGR_Vector *vector_constant;
05565 
05566   if((data1==NULL) || (datdest==NULL))  {
05567     POST_ERROR("Null objects!\n");
05568     return FLGR_RET_NULL_OBJECT;
05569   }
05570 
05571   vector_constant = flgr_vector_create(data1->spp,data1->type);
05572 
05573   if((ret=flgr_vector_import_string(vector_constant, constant))
05574      != FLGR_RET_OK) {
05575 
05576     POST_ERROR("String is not valid ""%s""\n",constant);
05577     flgr_vector_destroy(vector_constant);
05578     return ret;
05579   }
05580 
05581   ret = flgr2d_arith_const_xor_ptr(datdest,data1,vector_constant);
05582 
05583   flgr_vector_destroy(vector_constant);
05584 
05585 
05586   return ret;
05587 
05588 }
05589 
05590 
05591 
05592 
05593 
05594 /*******************************************************************************
05595  * ATAN2 CONST
05596  *******************************************************************************/
05597 
05598 void flgr2d_arith_const_atan2_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05599   flgr_no_define_type_function(FLGR_BIT);
05600 }
05601 void flgr2d_arith_const_atan2_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05602   flgr_no_define_type_function(FLGR_UINT8);
05603 }
05604 void flgr2d_arith_const_atan2_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05605   flgr_no_define_type_function(FLGR_UINT16);
05606 }
05607 void flgr2d_arith_const_atan2_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05608   flgr_no_define_type_function(FLGR_UINT32);
05609 }
05610 void flgr2d_arith_const_atan2_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05611   flgr_no_define_type_function(FLGR_INT8);
05612 }
05613 void flgr2d_arith_const_atan2_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05614   flgr_no_define_type_function(FLGR_INT16);
05615 }
05616 void flgr2d_arith_const_atan2_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05617   flgr_no_define_type_function(FLGR_INT32);
05618 }
05619 void flgr2d_arith_const_atan2_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05620   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_atan2,fgFLOAT32);
05621 }
05622 void flgr2d_arith_const_atan2_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05623   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_atan2,fgFLOAT64);
05624 }
05625 
05627 
05633 
05634 FLGR_Ret flgr2d_arith_const_atan2_ptr(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05635   FLGR_Ret ret;
05636 
05637   
05638 
05639   if((datdest==NULL) || (data1==NULL)) {
05640     POST_ERROR("Null objects!\n");
05641     return FLGR_RET_NULL_OBJECT;
05642   }
05643 
05644   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
05645 
05646   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_const_atan2,datdest,data1,vec_const);
05647 }
05648 
05650 
05656 
05657 FLGR_Ret flgr2d_arith_const_atan2_str(FLGR_Data2D *datdest, FLGR_Data2D *data1, char *constant) {
05658   int ret;
05659   FLGR_Vector *vector_constant;
05660 
05661   if((data1==NULL) || (datdest==NULL))  {
05662     POST_ERROR("Null objects!\n");
05663     return FLGR_RET_NULL_OBJECT;
05664   }
05665 
05666   vector_constant = flgr_vector_create(data1->spp,data1->type);
05667 
05668   if((ret=flgr_vector_import_string(vector_constant, constant))
05669      != FLGR_RET_OK) {
05670 
05671     POST_ERROR("String is not valid ""%s""\n",constant);
05672     flgr_vector_destroy(vector_constant);
05673     return ret;
05674   }
05675 
05676   ret = flgr2d_arith_const_atan2_ptr(datdest,data1,vector_constant);
05677 
05678 
05679   flgr_vector_destroy(vector_constant);
05680 
05681   return ret;
05682 
05683 }
05684 
05685 
05686 
05687 
05688 
05689 
05690 /*******************************************************************************
05691  * ARGUMENT CONST
05692  *******************************************************************************/
05693 
05694 void flgr2d_arith_const_argument_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05695   flgr_no_define_type_function(FLGR_BIT);
05696 }
05697 void flgr2d_arith_const_argument_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05698   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_argument,fgUINT8);
05699 }
05700 void flgr2d_arith_const_argument_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05701   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_argument,fgUINT16);
05702 }
05703 void flgr2d_arith_const_argument_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05704   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_argument,fgUINT32);
05705 }
05706 void flgr2d_arith_const_argument_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05707   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_argument,fgINT8);
05708 }
05709 void flgr2d_arith_const_argument_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05710   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_argument,fgINT16);
05711 }
05712 void flgr2d_arith_const_argument_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05713   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_argument,fgINT32);
05714 }
05715 void flgr2d_arith_const_argument_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05716   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_argument,fgFLOAT32);
05717 }
05718 void flgr2d_arith_const_argument_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05719   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_argument,fgFLOAT64);
05720 }
05721 
05723 
05729 
05730 FLGR_Ret flgr2d_arith_const_argument_ptr(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05731   FLGR_Ret ret;
05732 
05733   
05734 
05735   if((datdest==NULL) || (data1==NULL)) {
05736     POST_ERROR("Null objects!\n");
05737     return FLGR_RET_NULL_OBJECT;
05738   }
05739 
05740   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
05741 
05742   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_const_argument,datdest,data1,vec_const);
05743 }
05744 
05746 
05752 
05753 FLGR_Ret flgr2d_arith_const_argument_str(FLGR_Data2D *datdest, FLGR_Data2D *data1, char *constant) {
05754   int ret;
05755   FLGR_Vector *vector_constant;
05756 
05757   if((data1==NULL) || (datdest==NULL))  {
05758     POST_ERROR("Null objects!\n");
05759     return FLGR_RET_NULL_OBJECT;
05760   }
05761 
05762   vector_constant = flgr_vector_create(data1->spp,data1->type);
05763 
05764   if((ret=flgr_vector_import_string(vector_constant, constant))
05765      != FLGR_RET_OK) {
05766 
05767     POST_ERROR("String is not valid ""%s""\n",constant);
05768     flgr_vector_destroy(vector_constant);
05769     return ret;
05770   }
05771 
05772 
05773   ret = flgr2d_arith_const_argument_ptr(datdest,data1,vector_constant);
05774 
05775   flgr_vector_destroy(vector_constant);
05776 
05777 
05778   return ret;
05779 
05780 }
05781 
05782 
05783 
05784 
05785 
05786 
05787 
05788 /*******************************************************************************
05789  * MODULE CONST
05790  *******************************************************************************/
05791 
05792 void flgr2d_arith_const_module_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05793   flgr_no_define_type_function(FLGR_BIT);
05794 }
05795 void flgr2d_arith_const_module_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05796   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_module,fgUINT8);
05797 }
05798 void flgr2d_arith_const_module_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05799   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_module,fgUINT16);
05800 }
05801 void flgr2d_arith_const_module_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05802   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_module,fgUINT32);
05803 }
05804 void flgr2d_arith_const_module_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05805   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_module,fgINT8);
05806 }
05807 void flgr2d_arith_const_module_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05808   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_module,fgINT16);
05809 }
05810 void flgr2d_arith_const_module_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05811   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_module,fgINT32);
05812 }
05813 void flgr2d_arith_const_module_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05814   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_module,fgFLOAT32);
05815 }
05816 void flgr2d_arith_const_module_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05817   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_module,fgFLOAT64);
05818 }
05819 
05821 
05827 
05828 FLGR_Ret flgr2d_arith_const_module_ptr(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05829   FLGR_Ret ret;
05830 
05831   
05832 
05833   if((datdest==NULL) || (data1==NULL)) {
05834     POST_ERROR("Null objects!\n");
05835     return FLGR_RET_NULL_OBJECT;
05836   }
05837 
05838   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
05839 
05840   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_const_module,datdest,data1,vec_const);
05841 }
05842 
05844 
05850 
05851 FLGR_Ret flgr2d_arith_const_module_str(FLGR_Data2D *datdest, FLGR_Data2D *data1, char *constant) {
05852   int ret;
05853   FLGR_Vector *vector_constant;
05854 
05855   if((data1==NULL) || (datdest==NULL))  {
05856     POST_ERROR("Null objects!\n");
05857     return FLGR_RET_NULL_OBJECT;
05858   }
05859 
05860   vector_constant = flgr_vector_create(data1->spp,data1->type);
05861 
05862   if((ret=flgr_vector_import_string(vector_constant, constant))
05863      != FLGR_RET_OK) {
05864 
05865     POST_ERROR("String is not valid ""%s""\n",constant);
05866     flgr_vector_destroy(vector_constant);
05867     return ret;
05868   }
05869 
05870   ret = flgr2d_arith_const_module_ptr(datdest,data1,vector_constant);
05871 
05872   flgr_vector_destroy(vector_constant);
05873 
05874 
05875   return ret;
05876 
05877 }
05878 
05879 
05880 
05881 
05882 /*******************************************************************************
05883  * MULTSAT CONST
05884  *******************************************************************************/
05885 
05886 void flgr2d_arith_const_multsat_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05887   flgr_no_define_type_function(FLGR_BIT);
05888 }
05889 void flgr2d_arith_const_multsat_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05890   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_multsat,fgUINT8);
05891 }
05892 void flgr2d_arith_const_multsat_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05893   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_multsat,fgUINT16);
05894 }
05895 void flgr2d_arith_const_multsat_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05896   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_multsat,fgUINT32);
05897 }
05898 void flgr2d_arith_const_multsat_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05899   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_multsat,fgINT8);
05900 }
05901 void flgr2d_arith_const_multsat_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05902   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_multsat,fgINT16);
05903 }
05904 void flgr2d_arith_const_multsat_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05905   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_multsat,fgINT32);
05906 }
05907 void flgr2d_arith_const_multsat_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05908   flgr_no_define_type_function(FLGR_FLOAT32);
05909 }
05910 void flgr2d_arith_const_multsat_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05911   flgr_no_define_type_function(FLGR_FLOAT64);
05912 }
05913 
05915 
05921 
05922 FLGR_Ret flgr2d_arith_const_multsat_ptr(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05923   FLGR_Ret ret;
05924 
05925   
05926 
05927   if((datdest==NULL) || (data1==NULL)) {
05928     POST_ERROR("Null objects!\n");
05929     return FLGR_RET_NULL_OBJECT;
05930   }
05931 
05932   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
05933 
05934   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_const_multsat,datdest,data1,vec_const);
05935 }
05936 
05938 
05944 
05945 FLGR_Ret flgr2d_arith_const_multsat_str(FLGR_Data2D *datdest, FLGR_Data2D *data1, char *constant) {
05946   int ret;
05947   FLGR_Vector *vector_constant;
05948 
05949   if((data1==NULL) || (datdest==NULL))  {
05950     POST_ERROR("Null objects!\n");
05951     return FLGR_RET_NULL_OBJECT;
05952   }
05953 
05954   vector_constant = flgr_vector_create(data1->spp,data1->type);
05955 
05956   if((ret=flgr_vector_import_string(vector_constant, constant))
05957      != FLGR_RET_OK) {
05958 
05959     POST_ERROR("String is not valid ""%s""\n",constant);
05960     flgr_vector_destroy(vector_constant);
05961     return ret;
05962   }
05963 
05964   ret = flgr2d_arith_const_multsat_ptr(datdest,data1,vector_constant);
05965 
05966   flgr_vector_destroy(vector_constant);
05967 
05968 
05969   return ret;
05970 
05971 }
05972 
05973 
05974 
05975 
05976 /*******************************************************************************
05977  * SUBSAT CONST
05978  *******************************************************************************/
05979 
05980 void flgr2d_arith_const_subsat_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05981   flgr_no_define_type_function(FLGR_BIT);
05982 }
05983 void flgr2d_arith_const_subsat_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05984   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_subsat,fgUINT8);
05985 }
05986 void flgr2d_arith_const_subsat_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05987   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_subsat,fgUINT16);
05988 }
05989 void flgr2d_arith_const_subsat_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05990   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_subsat,fgUINT32);
05991 }
05992 void flgr2d_arith_const_subsat_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05993   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_subsat,fgINT8);
05994 }
05995 void flgr2d_arith_const_subsat_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05996   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_subsat,fgINT16);
05997 }
05998 void flgr2d_arith_const_subsat_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
05999   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_subsat,fgINT32);
06000 }
06001 void flgr2d_arith_const_subsat_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06002   flgr_no_define_type_function(FLGR_FLOAT32);
06003 }
06004 void flgr2d_arith_const_subsat_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06005   flgr_no_define_type_function(FLGR_FLOAT64);
06006 }
06007 
06009 
06015 
06016 FLGR_Ret flgr2d_arith_const_subsat_ptr(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06017   FLGR_Ret ret;
06018 
06019   
06020 
06021   if((datdest==NULL) || (data1==NULL)) {
06022     POST_ERROR("Null objects!\n");
06023     return FLGR_RET_NULL_OBJECT;
06024   }
06025 
06026   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
06027 
06028   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_const_subsat,datdest,data1,vec_const);
06029 }
06030 
06032 
06038 
06039 FLGR_Ret flgr2d_arith_const_subsat_str(FLGR_Data2D *datdest, FLGR_Data2D *data1, char *constant) {
06040   int ret;
06041   FLGR_Vector *vector_constant;
06042 
06043   if((data1==NULL) || (datdest==NULL))  {
06044     POST_ERROR("Null objects!\n");
06045     return FLGR_RET_NULL_OBJECT;
06046   }
06047 
06048   vector_constant = flgr_vector_create(data1->spp,data1->type);
06049 
06050   if((ret=flgr_vector_import_string(vector_constant, constant))
06051      != FLGR_RET_OK) {
06052 
06053     POST_ERROR("String is not valid ""%s""\n",constant);
06054     flgr_vector_destroy(vector_constant);
06055     return ret;
06056   }
06057 
06058   ret = flgr2d_arith_const_subsat_ptr(datdest,data1,vector_constant);
06059 
06060   flgr_vector_destroy(vector_constant);
06061 
06062 
06063   return ret;
06064 
06065 }
06066 
06067 
06068 
06069 
06070 
06071 /*******************************************************************************
06072  * ADDSAT CONST
06073  *******************************************************************************/
06074 
06075 void flgr2d_arith_const_addsat_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06076   flgr_no_define_type_function(FLGR_BIT);
06077 }
06078 void flgr2d_arith_const_addsat_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06079   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_addsat,fgUINT8);
06080 }
06081 void flgr2d_arith_const_addsat_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06082   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_addsat,fgUINT16);
06083 }
06084 void flgr2d_arith_const_addsat_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06085   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_addsat,fgUINT32);
06086 }
06087 void flgr2d_arith_const_addsat_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06088   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_addsat,fgINT8);
06089 }
06090 void flgr2d_arith_const_addsat_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06091   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_addsat,fgINT16);
06092 }
06093 void flgr2d_arith_const_addsat_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06094   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_addsat,fgINT32);
06095 }
06096 void flgr2d_arith_const_addsat_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06097   flgr_no_define_type_function(FLGR_FLOAT32);
06098 }
06099 void flgr2d_arith_const_addsat_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06100   flgr_no_define_type_function(FLGR_FLOAT64);
06101 }
06102 
06104 
06110 
06111 FLGR_Ret flgr2d_arith_const_addsat_ptr(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06112   FLGR_Ret ret;
06113 
06114   
06115 
06116   if((datdest==NULL) || (data1==NULL)) {
06117     POST_ERROR("Null objects!\n");
06118     return FLGR_RET_NULL_OBJECT;
06119   }
06120 
06121   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
06122 
06123   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_const_addsat,datdest,data1,vec_const);
06124 }
06125 
06127 
06133 
06134 FLGR_Ret flgr2d_arith_const_addsat_str(FLGR_Data2D *datdest, FLGR_Data2D *data1, char *constant) {
06135   int ret;
06136   FLGR_Vector *vector_constant;
06137 
06138   if((data1==NULL) || (datdest==NULL))  {
06139     POST_ERROR("Null objects!\n");
06140     return FLGR_RET_NULL_OBJECT;
06141   }
06142 
06143   vector_constant = flgr_vector_create(data1->spp,data1->type);
06144 
06145   if((ret=flgr_vector_import_string(vector_constant, constant))
06146      != FLGR_RET_OK) {
06147 
06148     POST_ERROR("String is not valid ""%s""\n",constant);
06149     flgr_vector_destroy(vector_constant);
06150     return ret;
06151   }
06152 
06153   ret = flgr2d_arith_const_addsat_ptr(datdest,data1,vector_constant);
06154 
06155   flgr_vector_destroy(vector_constant);
06156 
06157 
06158   return ret;
06159 
06160 }
06161 
06162 
06163 
06164 
06165 /*******************************************************************************
06166  * DIV CONST
06167  *******************************************************************************/
06168 
06169 void flgr2d_arith_const_div_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06170   flgr_no_define_type_function(FLGR_BIT);
06171 }
06172 void flgr2d_arith_const_div_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06173   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_div,fgUINT8);
06174 }
06175 void flgr2d_arith_const_div_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06176   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_div,fgUINT16);
06177 }
06178 void flgr2d_arith_const_div_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06179   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_div,fgUINT32);
06180 }
06181 void flgr2d_arith_const_div_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06182   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_div,fgINT8);
06183 }
06184 void flgr2d_arith_const_div_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06185   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_div,fgINT16);
06186 }
06187 void flgr2d_arith_const_div_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06188   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_div,fgINT32);
06189 }
06190 void flgr2d_arith_const_div_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06191   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_div,fgFLOAT32);
06192 }
06193 void flgr2d_arith_const_div_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06194   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_div,fgFLOAT64);
06195 }
06196 
06198 
06204 
06205 FLGR_Ret flgr2d_arith_const_div_ptr(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06206   FLGR_Ret ret;
06207 
06208   
06209 
06210   if((datdest==NULL) || (data1==NULL)) {
06211     POST_ERROR("Null objects!\n");
06212     return FLGR_RET_NULL_OBJECT;
06213   }
06214 
06215   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
06216 
06217   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_const_div,datdest,data1,vec_const);
06218 }
06219 
06221 
06227 
06228 FLGR_Ret flgr2d_arith_const_div_str(FLGR_Data2D *datdest, FLGR_Data2D *data1, char *constant) {
06229   int ret;
06230   FLGR_Vector *vector_constant;
06231 
06232   if((data1==NULL) || (datdest==NULL))  {
06233     POST_ERROR("Null objects!\n");
06234     return FLGR_RET_NULL_OBJECT;
06235   }
06236 
06237   vector_constant = flgr_vector_create(data1->spp,data1->type);
06238 
06239   if((ret=flgr_vector_import_string(vector_constant, constant))
06240      != FLGR_RET_OK) {
06241 
06242     POST_ERROR("String is not valid ""%s""\n",constant);
06243     flgr_vector_destroy(vector_constant);
06244     return ret;
06245   }
06246 
06247   ret = flgr2d_arith_const_div_ptr(datdest,data1,vector_constant);
06248 
06249   flgr_vector_destroy(vector_constant);
06250 
06251 
06252   return ret;
06253 
06254 }
06255 
06256 
06257 
06258 
06259 
06260 
06261 /*******************************************************************************
06262  * MULT CONST
06263  *******************************************************************************/
06264 
06265 void flgr2d_arith_const_mult_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06266   flgr_no_define_type_function(FLGR_BIT);
06267 }
06268 void flgr2d_arith_const_mult_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06269   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_mult,fgUINT8);
06270 }
06271 void flgr2d_arith_const_mult_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06272   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_mult,fgUINT16);
06273 }
06274 void flgr2d_arith_const_mult_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06275   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_mult,fgUINT32);
06276 }
06277 void flgr2d_arith_const_mult_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06278   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_mult,fgINT8);
06279 }
06280 void flgr2d_arith_const_mult_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06281   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_mult,fgINT16);
06282 }
06283 void flgr2d_arith_const_mult_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06284   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_mult,fgINT32);
06285 }
06286 void flgr2d_arith_const_mult_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06287   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_mult,fgFLOAT32);
06288 }
06289 void flgr2d_arith_const_mult_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06290   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_mult,fgFLOAT64);
06291 }
06292 
06294 
06300 
06301 FLGR_Ret flgr2d_arith_const_mult_ptr(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06302   FLGR_Ret ret;
06303 
06304   
06305 
06306   if((datdest==NULL) || (data1==NULL)) {
06307     POST_ERROR("Null objects!\n");
06308     return FLGR_RET_NULL_OBJECT;
06309   }
06310 
06311   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
06312 
06313   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_const_mult,datdest,data1,vec_const);
06314 }
06315 
06317 
06323 
06324 FLGR_Ret flgr2d_arith_const_mult_str(FLGR_Data2D *datdest, FLGR_Data2D *data1, char *constant) {
06325   int ret;
06326   FLGR_Vector *vector_constant;
06327 
06328   if((data1==NULL) || (datdest==NULL))  {
06329     POST_ERROR("Null objects!\n");
06330     return FLGR_RET_NULL_OBJECT;
06331   }
06332 
06333   vector_constant = flgr_vector_create(data1->spp,data1->type);
06334 
06335   if((ret=flgr_vector_import_string(vector_constant, constant))
06336      != FLGR_RET_OK) {
06337 
06338     POST_ERROR("String is not valid ""%s""\n",constant);
06339     flgr_vector_destroy(vector_constant);
06340     return ret;
06341   }
06342 
06343   ret = flgr2d_arith_const_mult_ptr(datdest,data1,vector_constant);
06344 
06345   flgr_vector_destroy(vector_constant);
06346 
06347 
06348   return ret;
06349 
06350 }
06351 
06352 
06353 
06354 
06355 
06356 /*******************************************************************************
06357  * SUB CONST
06358  *******************************************************************************/
06359 
06360 void flgr2d_arith_const_sub_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06361   flgr_no_define_type_function(FLGR_BIT);
06362 }
06363 void flgr2d_arith_const_sub_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06364   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sub,fgUINT8);
06365 }
06366 void flgr2d_arith_const_sub_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06367   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sub,fgUINT16);
06368 }
06369 void flgr2d_arith_const_sub_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06370   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sub,fgUINT32);
06371 }
06372 void flgr2d_arith_const_sub_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06373   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sub,fgINT8);
06374 }
06375 void flgr2d_arith_const_sub_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06376   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sub,fgINT16);
06377 }
06378 void flgr2d_arith_const_sub_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06379   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sub,fgINT32);
06380 }
06381 void flgr2d_arith_const_sub_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06382   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sub,fgFLOAT32);
06383 }
06384 void flgr2d_arith_const_sub_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06385   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_sub,fgFLOAT64);
06386 }
06387 
06389 
06395 
06396 FLGR_Ret flgr2d_arith_const_sub_ptr(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06397   FLGR_Ret ret;
06398 
06399   
06400 
06401   if((datdest==NULL) || (data1==NULL)) {
06402     POST_ERROR("Null objects!\n");
06403     return FLGR_RET_NULL_OBJECT;
06404   }
06405 
06406   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
06407 
06408   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_const_sub,datdest,data1,vec_const);
06409 }
06410 
06412 
06418 
06419 FLGR_Ret flgr2d_arith_const_sub_str(FLGR_Data2D *datdest, FLGR_Data2D *data1, char *constant) {
06420   int ret;
06421   FLGR_Vector *vector_constant;
06422 
06423   if((data1==NULL) || (datdest==NULL))  {
06424     POST_ERROR("Null objects!\n");
06425     return FLGR_RET_NULL_OBJECT;
06426   }
06427 
06428   vector_constant = flgr_vector_create(data1->spp,data1->type);
06429 
06430   if((ret=flgr_vector_import_string(vector_constant, constant))
06431      != FLGR_RET_OK) {
06432 
06433     POST_ERROR("String is not valid ""%s""\n",constant);
06434     flgr_vector_destroy(vector_constant);
06435     return ret;
06436   }
06437 
06438   ret = flgr2d_arith_const_sub_ptr(datdest,data1,vector_constant);
06439 
06440   flgr_vector_destroy(vector_constant);
06441 
06442 
06443   return ret;
06444 
06445 }
06446 
06447 
06448 
06449 
06450 
06451 
06452 
06453 /*******************************************************************************
06454  * ADD CONST
06455  *******************************************************************************/
06456 
06457 void flgr2d_arith_const_add_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06458   flgr_no_define_type_function(FLGR_BIT);
06459 }
06460 void flgr2d_arith_const_add_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06461   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_add,fgUINT8);
06462 }
06463 void flgr2d_arith_const_add_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06464   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_add,fgUINT16);
06465 }
06466 void flgr2d_arith_const_add_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06467   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_add,fgUINT32);
06468 }
06469 void flgr2d_arith_const_add_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06470   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_add,fgINT8);
06471 }
06472 void flgr2d_arith_const_add_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06473   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_add,fgINT16);
06474 }
06475 void flgr2d_arith_const_add_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06476   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_add,fgINT32);
06477 }
06478 void flgr2d_arith_const_add_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06479   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_add,fgFLOAT32);
06480 }
06481 void flgr2d_arith_const_add_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06482   FLGR_MACRO_ARITH_2D_DIADIC_CONST(flgr1d_arith_const_add,fgFLOAT64);
06483 }
06484 
06486 
06492 
06493 FLGR_Ret flgr2d_arith_const_add_ptr(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_const) {
06494   FLGR_Ret ret;
06495 
06496   
06497 
06498   if((datdest==NULL) || (data1==NULL)) {
06499     POST_ERROR("Null objects!\n");
06500     return FLGR_RET_NULL_OBJECT;
06501   }
06502 
06503   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
06504 
06505   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_const_add,datdest,data1,vec_const);
06506 }
06507 
06509 
06515 
06516 FLGR_Ret flgr2d_arith_const_add_str(FLGR_Data2D *datdest, FLGR_Data2D *data1, char *constant) {
06517   int ret;
06518   FLGR_Vector *vector_constant;
06519 
06520   if((data1==NULL) || (datdest==NULL))  {
06521     POST_ERROR("Null objects!\n");
06522     return FLGR_RET_NULL_OBJECT;
06523   }
06524 
06525   vector_constant = flgr_vector_create(data1->spp,data1->type);
06526 
06527   if((ret=flgr_vector_import_string(vector_constant, constant))
06528      != FLGR_RET_OK) {
06529 
06530     POST_ERROR("String is not valid ""%s""\n",constant);
06531     flgr_vector_destroy(vector_constant);
06532     return ret;
06533   }
06534 
06535   ret = flgr2d_arith_const_add_ptr(datdest,data1,vector_constant);
06536 
06537   flgr_vector_destroy(vector_constant);
06538 
06539 
06540   return ret;
06541 
06542 }
06543 
06545 
06553 /*******************************************************************************
06554  * Log base b
06555  *******************************************************************************/
06556 
06557 void flgr2d_arith_logb_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_base) {
06558   flgr_no_define_type_function(FLGR_BIT);
06559 }
06560 void flgr2d_arith_logb_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_base) {
06561   FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(flgr1d_arith_logb,fgUINT8,vec_base);
06562 }
06563 void flgr2d_arith_logb_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_base) {
06564   FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(flgr1d_arith_logb,fgUINT16,vec_base);
06565 }
06566 void flgr2d_arith_logb_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_base) {
06567   FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(flgr1d_arith_logb,fgUINT32,vec_base);
06568 }
06569 void flgr2d_arith_logb_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_base) {
06570   FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(flgr1d_arith_logb,fgINT8,vec_base);
06571 }
06572 void flgr2d_arith_logb_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_base) {
06573   FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(flgr1d_arith_logb,fgINT16,vec_base);
06574 }
06575 void flgr2d_arith_logb_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_base) {
06576   FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(flgr1d_arith_logb,fgINT32,vec_base);
06577 }
06578 void flgr2d_arith_logb_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_base) {
06579   FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(flgr1d_arith_logb,fgFLOAT32,vec_base);
06580 }
06581 void flgr2d_arith_logb_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_base) {
06582   FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(flgr1d_arith_logb,fgFLOAT64,vec_base);
06583 }
06584 
06586 
06592 
06593 FLGR_Ret flgr2d_arith_logb(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *base) {
06594   FLGR_Ret ret;
06595 
06596   
06597 
06598   if((datdest==NULL) || (data1==NULL)) {
06599     POST_ERROR("Null objects!\n");
06600     return FLGR_RET_NULL_OBJECT;
06601   }
06602 
06603   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
06604 
06605   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_logb,datdest,data1,base);
06606 }
06607 
06608 
06609 
06610 
06611 
06612 /*******************************************************************************
06613  * Pow base b
06614  *******************************************************************************/
06615 
06616 void flgr2d_arith_powb_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_power) {
06617   flgr_no_define_type_function(FLGR_BIT);
06618 }
06619 void flgr2d_arith_powb_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_power) {
06620   FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(flgr1d_arith_powb,fgUINT8,vec_power);
06621 }
06622 void flgr2d_arith_powb_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_power) {
06623   FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(flgr1d_arith_powb,fgUINT16,vec_power);
06624 }
06625 void flgr2d_arith_powb_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_power) {
06626   FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(flgr1d_arith_powb,fgUINT32,vec_power);
06627 }
06628 void flgr2d_arith_powb_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_power) {
06629   FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(flgr1d_arith_powb,fgINT8,vec_power);
06630 }
06631 void flgr2d_arith_powb_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_power) {
06632   FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(flgr1d_arith_powb,fgINT16,vec_power);
06633 }
06634 void flgr2d_arith_powb_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_power) {
06635   FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(flgr1d_arith_powb,fgINT32,vec_power);
06636 }
06637 void flgr2d_arith_powb_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_power) {
06638   FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(flgr1d_arith_powb,fgFLOAT32,vec_power);
06639 }
06640 void flgr2d_arith_powb_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *vec_power) {
06641   FLGR_MACRO_ARITH_2D_MONOADIC_PARAM(flgr1d_arith_powb,fgFLOAT64,vec_power);
06642 }
06643 
06645 
06651 
06652 FLGR_Ret flgr2d_arith_powb(FLGR_Data2D *datdest, FLGR_Data2D *data1, FLGR_Vector *base) {
06653   FLGR_Ret ret;
06654 
06655   
06656 
06657   if((datdest==NULL) || (data1==NULL)) {
06658     POST_ERROR("Null objects!\n");
06659     return FLGR_RET_NULL_OBJECT;
06660   }
06661 
06662   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
06663 
06664   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_powb,datdest,data1,base);
06665 }
06666 
06667 
06668 
06669 
06670 /*******************************************************************************
06671  *******************************************************************************
06672  *******************************************************************************
06673  * MONO OPERATIONS
06674  *******************************************************************************
06675  *******************************************************************************
06676  *******************************************************************************/
06677 
06678 
06679 
06680 /*******************************************************************************
06681  * INVERT
06682  *******************************************************************************/
06683 
06684 void flgr2d_arith_invert_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06685   flgr_no_define_type_function(FLGR_BIT);
06686 }
06687 void flgr2d_arith_invert_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06688   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_invert,fgUINT8);
06689 }
06690 
06691 void flgr2d_arith_invert_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06692   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_invert,fgUINT16);
06693 }
06694 
06695 void flgr2d_arith_invert_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06696   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_invert,fgUINT32);
06697 }
06698 
06699 void flgr2d_arith_invert_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06700   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_invert,fgINT8);
06701 }
06702 
06703 void flgr2d_arith_invert_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06704   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_invert,fgINT16);
06705 }
06706 
06707 void flgr2d_arith_invert_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06708   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_invert,fgINT32);
06709 }
06710 
06711 void flgr2d_arith_invert_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06712   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_invert,fgFLOAT32);
06713 }
06714 
06715 void flgr2d_arith_invert_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06716   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_invert,fgFLOAT64);
06717 }
06718 
06720 
06725 
06726 FLGR_Ret flgr2d_arith_invert(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06727   FLGR_Ret ret;
06728 
06729   
06730 
06731   if((datdest==NULL) || (data1==NULL)) {
06732     POST_ERROR("Null objects!\n");
06733     return FLGR_RET_NULL_OBJECT;
06734   }
06735 
06736   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
06737 
06738   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_invert,datdest,data1);
06739 
06740 }
06741 
06742 
06743 
06744 /*******************************************************************************
06745  * ABS
06746  *******************************************************************************/
06747 
06748 void flgr2d_arith_abs_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06749   flgr_no_define_type_function(FLGR_BIT);
06750 }
06751 void flgr2d_arith_abs_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06752   flgr_no_define_type_function(FLGR_UINT8);
06753 }
06754 
06755 void flgr2d_arith_abs_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06756   flgr_no_define_type_function(FLGR_UINT16);
06757 }
06758 
06759 void flgr2d_arith_abs_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06760   flgr_no_define_type_function(FLGR_UINT32);
06761 }
06762 
06763 void flgr2d_arith_abs_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06764   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_abs,fgINT8);
06765 }
06766 
06767 void flgr2d_arith_abs_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06768   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_abs,fgINT16);
06769 }
06770 
06771 void flgr2d_arith_abs_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06772   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_abs,fgINT32);
06773 }
06774 
06775 void flgr2d_arith_abs_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06776   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_abs,fgFLOAT32);
06777 }
06778 
06779 void flgr2d_arith_abs_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06780   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_abs,fgFLOAT64);
06781 }
06782 
06784 
06789 
06790 FLGR_Ret flgr2d_arith_abs(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06791   FLGR_Ret ret;
06792 
06793   
06794 
06795   if((datdest==NULL) || (data1==NULL)) {
06796     POST_ERROR("Null objects!\n");
06797     return FLGR_RET_NULL_OBJECT;
06798   }
06799 
06800   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
06801 
06802   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_abs,datdest,data1);
06803 
06804 }
06805 
06806 
06807 
06808 /*******************************************************************************
06809  * COS
06810  *******************************************************************************/
06811 
06812 void flgr2d_arith_cos_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06813   flgr_no_define_type_function(FLGR_BIT);
06814 }
06815 void flgr2d_arith_cos_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06816   flgr_no_define_type_function(FLGR_UINT8);
06817 }
06818 
06819 void flgr2d_arith_cos_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06820   flgr_no_define_type_function(FLGR_UINT16);
06821 }
06822 
06823 void flgr2d_arith_cos_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06824   flgr_no_define_type_function(FLGR_UINT32);
06825 }
06826 
06827 void flgr2d_arith_cos_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06828   flgr_no_define_type_function(FLGR_INT8);
06829 }
06830 
06831 void flgr2d_arith_cos_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06832   flgr_no_define_type_function(FLGR_INT16);
06833 }
06834 
06835 void flgr2d_arith_cos_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06836   flgr_no_define_type_function(FLGR_INT32);
06837 }
06838 
06839 void flgr2d_arith_cos_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06840   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_cos,fgFLOAT32);
06841 }
06842 
06843 void flgr2d_arith_cos_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06844   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_cos,fgFLOAT64);
06845 }
06846 
06848 
06853 
06854 FLGR_Ret flgr2d_arith_cos(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06855   FLGR_Ret ret;
06856 
06857   
06858 
06859   if((datdest==NULL) || (data1==NULL)) {
06860     POST_ERROR("Null objects!\n");
06861     return FLGR_RET_NULL_OBJECT;
06862   }
06863 
06864   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
06865 
06866   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_cos,datdest,data1);
06867 
06868 }
06869 
06870 /*******************************************************************************
06871  * SIN
06872  *******************************************************************************/
06873 
06874 void flgr2d_arith_sin_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06875   flgr_no_define_type_function(FLGR_BIT);
06876 }
06877 void flgr2d_arith_sin_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06878   flgr_no_define_type_function(FLGR_UINT8);
06879 }
06880 
06881 void flgr2d_arith_sin_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06882   flgr_no_define_type_function(FLGR_UINT16);
06883 }
06884 
06885 void flgr2d_arith_sin_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06886   flgr_no_define_type_function(FLGR_UINT32);
06887 }
06888 
06889 void flgr2d_arith_sin_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06890   flgr_no_define_type_function(FLGR_INT8);
06891 }
06892 
06893 void flgr2d_arith_sin_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06894   flgr_no_define_type_function(FLGR_INT16);
06895 }
06896 
06897 void flgr2d_arith_sin_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06898   flgr_no_define_type_function(FLGR_INT32);
06899 }
06900 
06901 void flgr2d_arith_sin_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06902   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_sin,fgFLOAT32);
06903 }
06904 
06905 void flgr2d_arith_sin_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06906   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_sin,fgFLOAT64);
06907 }
06908 
06910 
06915 
06916 FLGR_Ret flgr2d_arith_sin(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06917   FLGR_Ret ret;
06918 
06919   
06920 
06921   if((datdest==NULL) || (data1==NULL)) {
06922     POST_ERROR("Null objects!\n");
06923     return FLGR_RET_NULL_OBJECT;
06924   }
06925 
06926   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
06927 
06928   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_sin,datdest,data1);
06929 
06930 }
06931 
06932 /*******************************************************************************
06933  * TAN
06934  *******************************************************************************/
06935 
06936 void flgr2d_arith_tan_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06937   flgr_no_define_type_function(FLGR_BIT);
06938 }
06939 void flgr2d_arith_tan_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06940   flgr_no_define_type_function(FLGR_UINT8);
06941 }
06942 
06943 void flgr2d_arith_tan_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06944   flgr_no_define_type_function(FLGR_UINT16);
06945 }
06946 
06947 void flgr2d_arith_tan_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06948   flgr_no_define_type_function(FLGR_UINT32);
06949 }
06950 
06951 void flgr2d_arith_tan_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06952   flgr_no_define_type_function(FLGR_INT8);
06953 }
06954 
06955 void flgr2d_arith_tan_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06956   flgr_no_define_type_function(FLGR_INT16);
06957 }
06958 
06959 void flgr2d_arith_tan_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06960   flgr_no_define_type_function(FLGR_INT32);
06961 }
06962 
06963 void flgr2d_arith_tan_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06964   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_tan,fgFLOAT32);
06965 }
06966 
06967 void flgr2d_arith_tan_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06968   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_tan,fgFLOAT64);
06969 }
06970 
06972 
06977 
06978 FLGR_Ret flgr2d_arith_tan(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06979   FLGR_Ret ret;
06980 
06981   
06982 
06983   if((datdest==NULL) || (data1==NULL)) {
06984     POST_ERROR("Null objects!\n");
06985     return FLGR_RET_NULL_OBJECT;
06986   }
06987 
06988   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
06989 
06990   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_tan,datdest,data1);
06991 
06992 }
06993 
06994 /*******************************************************************************
06995  * ACOS
06996  *******************************************************************************/
06997 
06998 void flgr2d_arith_acos_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
06999   flgr_no_define_type_function(FLGR_BIT);
07000 }
07001 void flgr2d_arith_acos_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07002   flgr_no_define_type_function(FLGR_UINT8);
07003 }
07004 
07005 void flgr2d_arith_acos_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07006   flgr_no_define_type_function(FLGR_UINT16);
07007 }
07008 
07009 void flgr2d_arith_acos_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07010   flgr_no_define_type_function(FLGR_UINT32);
07011 }
07012 
07013 void flgr2d_arith_acos_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07014   flgr_no_define_type_function(FLGR_INT8);
07015 }
07016 
07017 void flgr2d_arith_acos_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07018   flgr_no_define_type_function(FLGR_INT16);
07019 }
07020 
07021 void flgr2d_arith_acos_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07022   flgr_no_define_type_function(FLGR_INT32);
07023 }
07024 
07025 void flgr2d_arith_acos_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07026   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_acos,fgFLOAT32);
07027 }
07028 
07029 void flgr2d_arith_acos_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07030   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_acos,fgFLOAT64);
07031 }
07032 
07034 
07039 
07040 FLGR_Ret flgr2d_arith_acos(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07041   FLGR_Ret ret;
07042 
07043   
07044 
07045   if((datdest==NULL) || (data1==NULL)) {
07046     POST_ERROR("Null objects!\n");
07047     return FLGR_RET_NULL_OBJECT;
07048   }
07049 
07050   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
07051 
07052   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_acos,datdest,data1);
07053 
07054 }
07055 
07056 /*******************************************************************************
07057  * ASIN
07058  *******************************************************************************/
07059 
07060 void flgr2d_arith_asin_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07061   flgr_no_define_type_function(FLGR_BIT);
07062 }
07063 void flgr2d_arith_asin_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07064   flgr_no_define_type_function(FLGR_UINT8);
07065 }
07066 
07067 void flgr2d_arith_asin_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07068   flgr_no_define_type_function(FLGR_UINT16);
07069 }
07070 
07071 void flgr2d_arith_asin_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07072   flgr_no_define_type_function(FLGR_UINT32);
07073 }
07074 
07075 void flgr2d_arith_asin_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07076   flgr_no_define_type_function(FLGR_INT8);
07077 }
07078 
07079 void flgr2d_arith_asin_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07080   flgr_no_define_type_function(FLGR_INT16);
07081 }
07082 
07083 void flgr2d_arith_asin_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07084   flgr_no_define_type_function(FLGR_INT32);
07085 }
07086 
07087 void flgr2d_arith_asin_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07088   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_asin,fgFLOAT32);
07089 }
07090 
07091 void flgr2d_arith_asin_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07092   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_asin,fgFLOAT64);
07093 }
07094 
07096 
07101 
07102 FLGR_Ret flgr2d_arith_asin(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07103   FLGR_Ret ret;
07104 
07105   
07106 
07107   if((datdest==NULL) || (data1==NULL)) {
07108     POST_ERROR("Null objects!\n");
07109     return FLGR_RET_NULL_OBJECT;
07110   }
07111 
07112   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
07113 
07114   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_asin,datdest,data1);
07115 
07116 }
07117 
07118 /*******************************************************************************
07119  * ATAN
07120  *******************************************************************************/
07121 
07122 void flgr2d_arith_atan_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07123   flgr_no_define_type_function(FLGR_BIT);
07124 }
07125 void flgr2d_arith_atan_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07126   flgr_no_define_type_function(FLGR_UINT8);
07127 }
07128 
07129 void flgr2d_arith_atan_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07130   flgr_no_define_type_function(FLGR_UINT16);
07131 }
07132 
07133 void flgr2d_arith_atan_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07134   flgr_no_define_type_function(FLGR_UINT32);
07135 }
07136 
07137 void flgr2d_arith_atan_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07138   flgr_no_define_type_function(FLGR_INT8);
07139 }
07140 
07141 void flgr2d_arith_atan_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07142   flgr_no_define_type_function(FLGR_INT16);
07143 }
07144 
07145 void flgr2d_arith_atan_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07146   flgr_no_define_type_function(FLGR_INT32);
07147 }
07148 
07149 void flgr2d_arith_atan_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07150   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_atan,fgFLOAT32);
07151 }
07152 
07153 void flgr2d_arith_atan_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07154   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_atan,fgFLOAT64);
07155 }
07156 
07158 
07163 
07164 FLGR_Ret flgr2d_arith_atan(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07165   FLGR_Ret ret;
07166 
07167   
07168 
07169   if((datdest==NULL) || (data1==NULL)) {
07170     POST_ERROR("Null objects!\n");
07171     return FLGR_RET_NULL_OBJECT;
07172   }
07173 
07174   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
07175 
07176   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_atan,datdest,data1);
07177 
07178 }
07179 
07180 
07181 
07182 
07183 
07184 /*******************************************************************************
07185  * FLOOR
07186  *******************************************************************************/
07187 
07188 void flgr2d_arith_floor_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07189   flgr_no_define_type_function(FLGR_BIT);
07190 }
07191 void flgr2d_arith_floor_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07192   flgr_no_define_type_function(FLGR_UINT8);
07193 }
07194 
07195 void flgr2d_arith_floor_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07196   flgr_no_define_type_function(FLGR_UINT16);
07197 }
07198 
07199 void flgr2d_arith_floor_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07200   flgr_no_define_type_function(FLGR_UINT32);
07201 }
07202 
07203 void flgr2d_arith_floor_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07204   flgr_no_define_type_function(FLGR_INT8);
07205 }
07206 
07207 void flgr2d_arith_floor_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07208   flgr_no_define_type_function(FLGR_INT16);
07209 }
07210 
07211 void flgr2d_arith_floor_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07212   flgr_no_define_type_function(FLGR_INT32);
07213 }
07214 
07215 void flgr2d_arith_floor_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07216   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_floor,fgFLOAT32);
07217 }
07218 
07219 void flgr2d_arith_floor_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07220   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_floor,fgFLOAT64);
07221 }
07222 
07224 
07229 
07230 FLGR_Ret flgr2d_arith_floor(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07231   FLGR_Ret ret;
07232 
07233   
07234 
07235   if((datdest==NULL) || (data1==NULL)) {
07236     POST_ERROR("Null objects!\n");
07237     return FLGR_RET_NULL_OBJECT;
07238   }
07239 
07240   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
07241 
07242   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_floor,datdest,data1);
07243 
07244 }
07245 
07246 
07247 
07248 
07249 /*******************************************************************************
07250  * CEIL
07251  *******************************************************************************/
07252 
07253 void flgr2d_arith_ceil_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07254   flgr_no_define_type_function(FLGR_BIT);
07255 }
07256 void flgr2d_arith_ceil_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07257   flgr_no_define_type_function(FLGR_UINT8);
07258 }
07259 
07260 void flgr2d_arith_ceil_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07261   flgr_no_define_type_function(FLGR_UINT16);
07262 }
07263 
07264 void flgr2d_arith_ceil_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07265   flgr_no_define_type_function(FLGR_UINT32);
07266 }
07267 
07268 void flgr2d_arith_ceil_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07269   flgr_no_define_type_function(FLGR_INT8);
07270 }
07271 
07272 void flgr2d_arith_ceil_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07273   flgr_no_define_type_function(FLGR_INT16);
07274 }
07275 
07276 void flgr2d_arith_ceil_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07277   flgr_no_define_type_function(FLGR_INT32);
07278 }
07279 
07280 void flgr2d_arith_ceil_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07281   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_ceil,fgFLOAT32);
07282 }
07283 
07284 void flgr2d_arith_ceil_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07285   FLGR_MACRO_ARITH_2D_MONOADIC(flgr1d_arith_ceil,fgFLOAT64);
07286 }
07287 
07289 
07294 
07295 FLGR_Ret flgr2d_arith_ceil(FLGR_Data2D *datdest, FLGR_Data2D *data1) {
07296   FLGR_Ret ret;
07297 
07298   
07299 
07300   if((datdest==NULL) || (data1==NULL)) {
07301     POST_ERROR("Null objects!\n");
07302     return FLGR_RET_NULL_OBJECT;
07303   }
07304 
07305   if((ret = flgr2d_is_data_same_attributes(datdest,data1,__FUNCTION__)) != FLGR_RET_OK) return ret;
07306 
07307   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_arith_ceil,datdest,data1);
07308 
07309 }
07310 
07311 
07312 
07313