Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members | Search for 

VarOp< T > Class Template Reference

#include <VarOp.hh>

List of all members.

Public Member Functions

 VarOp ()
var_sct * var_var_op (var_sct *var1, var_sct *var2, int op)
var_sct * var_op (var_sct *var1, int op)

Detailed Description

template<class T>
class VarOp< T >

Definition at line 6 of file VarOp.hh.

Constructor & Destructor Documentation

template<class T>
VarOp< T >::VarOp (   )  [inline]
 

Definition at line 12 of file VarOp.hh.

00012 {;}

Member Function Documentation

template<class T>
var_sct * VarOp< T >::var_op (  var_sct *  var1,
int  op
) 
 

Definition at line 204 of file VarOp.hh.

References var_sct_tag::has_mss_val, var_sct_tag::mss_val, var_sct_tag::sz, var_sct_tag::val, and ptr_unn::vp.

Referenced by ncap_var_var_op().

00204                                                 {
00205     bool bmss=false;
00206     long idx;
00207     long sz;
00208     T tmss=T(0);
00209     T* tp1;
00210 
00211     sz=var1->sz;
00212     
00213     tp1=(T*)(var1->val.vp);
00214 
00215 
00216 
00217     if(var1->has_mss_val) {
00218       bmss=true;
00219       tmss=((T*)(var1->mss_val.vp))[0];
00220     }  
00221 
00222     switch(op) {
00223 
00224 
00225       case PLUS:
00226       // Do nothing
00227         break;
00228       
00229       case MINUS:
00230         if(!bmss) {
00231           for(idx=0 ; idx<sz ; idx++) tp1[idx]*=-1;
00232         }else{
00233           for(idx=0 ; idx<sz ; idx++)
00234             if( tp1[idx] != tmss ) tp1[idx]*=-1;
00235             
00236         }
00237         break;
00238        
00239     case LNOT:  
00240         if(!bmss) {
00241           for(idx=0 ; idx<sz ; idx++) tp1[idx]=!tp1[idx];
00242         }else{
00243           for(idx=0 ; idx<sz ; idx++){
00244             if( tp1[idx] != tmss ) tp1[idx]=!tp1[idx];
00245           }  
00246         }
00247         break;
00248 
00249       default: break;   
00250 
00251     } // end switch     
00252 
00253     return var1;
00254   } // end var_op

template<class T>
var_sct * VarOp< T >::var_var_op (  var_sct *  var1,
var_sct *  var2,
int  op
) 
 

Definition at line 23 of file VarOp.hh.

References var_sct_tag::has_mss_val, var_sct_tag::mss_val, nco_mss_val_cnf(), var_sct_tag::sz, var_sct_tag::val, and ptr_unn::vp.

Referenced by ncap_var_var_op().

00023                                                                   {
00024 
00025     bool bmss=false;
00026     long idx;
00027     long sz;
00028     T tmss=T(0);
00029     T* tp1;
00030     T* tp2;
00031 
00032     sz=var1->sz;
00033     
00034     tp1=(T*)(var1->val.vp);
00035     tp2=(T*)(var2->val.vp);  
00036 
00037 
00038     if(var1->has_mss_val) {
00039       tmss=((T*)(var1->mss_val.vp))[0];
00040       bmss=true;
00041     }else if(var2->has_mss_val) {
00042         
00043       tmss=((T*)(var2->mss_val.vp))[0];
00044       bmss=true;
00045       // Now copy missing value to var1 as on return var2 will be freed 
00046       (void)nco_mss_val_cnf(var2,var1);
00047     }  
00048  
00049     switch(op) {
00050 
00051       case PLUS:
00052         if(!bmss) {
00053           for(idx=0 ; idx<sz ; idx++) tp1[idx]+=tp2[idx];
00054         }else{
00055           for(idx=0 ; idx<sz ; idx++){
00056             if( tp1[idx] != tmss && tp2[idx] != tmss)
00057               tp1[idx]+=tp2[idx];
00058           }
00059         }  
00060         break;
00061       
00062       case MINUS:
00063         if(!bmss) {
00064           for(idx=0 ; idx<sz ; idx++) tp1[idx]-=tp2[idx];
00065         }else{
00066           for(idx=0 ; idx<sz ; idx++){
00067             if( tp1[idx] != tmss &&  tp2[idx] != tmss)
00068               tp1[idx]-=tp2[idx];
00069           }
00070         }  
00071 
00072         break;
00073       
00074       case TIMES:
00075         if(!bmss) {
00076           for(idx=0 ; idx<sz ; idx++) tp1[idx]*=tp2[idx];
00077         }else{
00078           for(idx=0 ; idx<sz ; idx++){
00079             if( tp1[idx] != tmss && tp2[idx] != tmss)
00080               tp1[idx]*=tp2[idx];
00081           }
00082         }  
00083 
00084         break;
00085 
00086       case DIVIDE:
00087         if(!bmss) {
00088           for(idx=0 ; idx<sz ; idx++) tp1[idx] /= tp2[idx];
00089         }else{
00090           for(idx=0 ; idx<sz ; idx++){
00091             if( tp1[idx] != tmss && tp2[idx] != tmss)
00092               tp1[idx] /= tp2[idx];
00093           }
00094         }  
00095 
00096 
00097         break;
00098 
00099       case MOD:
00100         // deal with else-where - can't template this function
00101         break;
00102 
00103       case CARET:
00104         // deal with else-where - can't template this function
00105         break;
00106 
00107         // Logical & Comparison Operators
00108 
00109       case LAND:
00110         if(!bmss) {
00111           for(idx=0 ; idx<sz ; idx++) tp1[idx]=tp1[idx] &&  tp2[idx];
00112         }else{
00113           for(idx=0 ; idx<sz ; idx++){
00114             if( tp1[idx] != tmss && tp2[idx] != tmss)
00115               tp1[idx]=tp1[idx] &&  tp2[idx];
00116           }
00117         }  
00118         break;
00119 
00120       case LOR:
00121         if(!bmss) {
00122           for(idx=0 ; idx<sz ; idx++) tp1[idx]=tp1[idx] ||  tp2[idx];
00123         }else{
00124           for(idx=0 ; idx<sz ; idx++){
00125             if( tp1[idx] != tmss && tp2[idx] != tmss)
00126               tp1[idx]=tp1[idx] ||  tp2[idx];
00127           }
00128         }  
00129         break;
00130 
00131       case LTHAN:
00132         if(!bmss) {
00133           for(idx=0 ; idx<sz ; idx++) tp1[idx]=tp1[idx] < tp2[idx];
00134         }else{
00135           for(idx=0 ; idx<sz ; idx++){
00136             if( tp1[idx] != tmss && tp2[idx] != tmss)
00137               tp1[idx]=tp1[idx] < tp2[idx];
00138           }
00139         }  
00140         break;
00141 
00142       case GTHAN:
00143         if(!bmss) {
00144           for(idx=0 ; idx<sz ; idx++) tp1[idx]=tp1[idx] > tp2[idx];
00145         }else{
00146           for(idx=0 ; idx<sz ; idx++){
00147             if( tp1[idx] != tmss && tp2[idx] != tmss)
00148               tp1[idx]=tp1[idx] >  tp2[idx];
00149           }
00150         }  
00151         break;
00152 
00153       case GEQ:
00154         if(!bmss) {
00155           for(idx=0 ; idx<sz ; idx++) tp1[idx]=tp1[idx] >= tp2[idx];
00156         }else{
00157           for(idx=0 ; idx<sz ; idx++){
00158             if( tp1[idx] != tmss && tp2[idx] != tmss)
00159               tp1[idx]=tp1[idx] >= tp2[idx];
00160           }
00161         }  
00162         break;
00163 
00164       case LEQ:
00165         if(!bmss) {
00166           for(idx=0 ; idx<sz ; idx++) tp1[idx]=tp1[idx] <= tp2[idx];
00167         }else{
00168           for(idx=0 ; idx<sz ; idx++){
00169             if( tp1[idx] != tmss && tp2[idx] != tmss)
00170               tp1[idx]=tp1[idx] <= tp2[idx];
00171           }
00172         }  
00173         break;
00174 
00175       case EQ:
00176         if(!bmss) {
00177           for(idx=0 ; idx<sz ; idx++) tp1[idx]=tp1[idx] == tp2[idx];
00178         }else{
00179           for(idx=0 ; idx<sz ; idx++){
00180             if( tp1[idx] != tmss && tp2[idx] != tmss)
00181               tp1[idx]=tp1[idx] == tp2[idx];
00182           }
00183         }  
00184         break;
00185 
00186       case NEQ:
00187         if(!bmss) {
00188           for(idx=0 ; idx<sz ; idx++) tp1[idx]=tp1[idx] != tp2[idx];
00189         }else{
00190           for(idx=0 ; idx<sz ; idx++){
00191             if( tp1[idx] != tmss && tp2[idx] != tmss)
00192               tp1[idx]=tp1[idx] != tp2[idx];
00193           }
00194         }  
00195         break;
00196 
00197     } // end switch
00198     
00199     return var1;
00200   } // end var_var_op

The documentation for this class was generated from the following file:
Generated on Thu Mar 16 18:17:46 2006 for nco by  doxygen 1.4.4