RTOp_ROp_max.c

Go to the documentation of this file.
00001 /*
00002 // @HEADER
00003 // ***********************************************************************
00004 // 
00005 // Moocho: Multi-functional Object-Oriented arCHitecture for Optimization
00006 //                  Copyright (2003) Sandia Corporation
00007 // 
00008 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
00009 // license for use of this work by or on behalf of the U.S. Government.
00010 // 
00011 // This library is free software; you can redistribute it and/or modify
00012 // it under the terms of the GNU Lesser General Public License as
00013 // published by the Free Software Foundation; either version 2.1 of the
00014 // License, or (at your option) any later version.
00015 //  
00016 // This library is distributed in the hope that it will be useful, but
00017 // WITHOUT ANY WARRANTY; without even the implied warranty of
00018 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00019 // Lesser General Public License for more details.
00020 //  
00021 // You should have received a copy of the GNU Lesser General Public
00022 // License along with this library; if not, write to the Free Software
00023 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
00024 // USA
00025 // Questions? Contact Roscoe A. Bartlett (rabartl@sandia.gov) 
00026 // 
00027 // ***********************************************************************
00028 // @HEADER
00029 */
00030 
00031 /* ///////////////////////////////////////////// */
00032 /* RTOp_ROp_max.c */
00033 
00034 /* */
00035 /* Note: This file was created automatically by 'new_rtop.pl' */
00036 /*       on 7/15/2002 at 17:33 */
00037 /* */
00038 
00039 #define max(a,b) ( (a) > (b) ? (a) : (b) )
00040 #define min(a,b) ( (a) < (b) ? (a) : (b) )
00041 
00042 #include "RTOp_ROp_max.h"
00043 #include "RTOp_obj_null_vtbl.h"  /* vtbl for operator object instance data */
00044 #include "RTOp_reduct_max_value.h"
00045 
00046 
00047 /* Implementation functions for RTOp_RTOp */
00048 
00049 static int RTOp_ROp_max_apply_op(
00050   const struct RTOp_RTOp_vtbl_t* vtbl, const void* obj_data
00051   , const int num_vecs, const struct RTOp_SubVector vecs[]
00052   , const int num_targ_vecs, const struct RTOp_MutableSubVector targ_vecs[]
00053   , RTOp_ReductTarget reduct_obj )
00054 {
00055   /* */
00056   /* Declare local variables */
00057   /* */
00058 
00059   /* Access to the reduction object data */
00060   RTOp_value_type *max_ele = (RTOp_value_type*)reduct_obj;
00061   /* Vector data */
00062   RTOp_index_type           sub_dim;
00063   /* v0 */
00064   const RTOp_value_type     *v0_val;
00065   ptrdiff_t                 v0_val_s;
00066 
00067   /* Automatic temporary variables */
00068   register RTOp_index_type  k;
00069   /* Temporary element-wise reduction object */
00070   RTOp_value_type max_ele_ith;
00071 
00072   /* */
00073   /* Validate the input */
00074   /* */
00075   if( num_vecs != 1 || ( num_vecs && vecs == NULL ) )
00076     return RTOp_ERR_INVALID_NUM_VECS;
00077   if( num_targ_vecs != 0 || ( num_targ_vecs && targ_vecs == NULL ) )
00078     return RTOp_ERR_INVALID_NUM_TARG_VECS;
00079   assert(reduct_obj);
00080 
00081 
00082   /* */
00083   /* Get pointers to data */
00084   /* */
00085   sub_dim       = vecs[0].sub_dim;
00086   /* v0 */
00087   v0_val        = vecs[0].values;
00088   v0_val_s      = vecs[0].values_stride;
00089 
00090 
00091   /* */
00092   /* Apply the operator: */
00093   /* */
00094   for( k = 0; k < sub_dim; ++k, v0_val += v0_val_s )
00095   {
00096     /* Element-wise reduction */
00097     max_ele_ith = (*v0_val);
00098     /* Reduction of intermediates */
00099     (*max_ele) = max( (*max_ele), max_ele_ith );
00100   }
00101 
00102   return 0; /* success? */
00103 }
00104 
00105 static int RTOp_ROp_max_reduct_obj_reinit(
00106   const struct RTOp_RTOp_vtbl_t* vtbl, const void* obj_data
00107   ,RTOp_ReductTarget reduct_obj
00108   )
00109 {
00110   RTOp_value_type *max_ele = (RTOp_value_type*)reduct_obj;
00111   *max_ele = -1e+50;
00112   return 0;
00113 }
00114 
00115 /* Virtual function table */
00116 const struct RTOp_RTOp_vtbl_t RTOp_ROp_max_vtbl =
00117 {
00118   &RTOp_obj_null_vtbl
00119   ,&RTOp_obj_value_vtbl
00120   ,"ROp_max"
00121   ,RTOp_ROp_max_reduct_obj_reinit
00122   ,RTOp_ROp_max_apply_op
00123   ,RTOp_reduct_max_value
00124   ,RTOp_get_reduct_max_value_op
00125 };
00126 
00127 /* Class specific functions */
00128 
00129 int RTOp_ROp_max_construct(  struct RTOp_RTOp* op )
00130 {
00131 #ifdef RTOp_DEBUG
00132   assert(op);
00133 #endif
00134   op->obj_data  = NULL;
00135   op->vtbl      = &RTOp_ROp_max_vtbl;
00136   op->vtbl->obj_data_vtbl->obj_create(NULL,NULL,&op->obj_data);
00137   return 0;
00138 }
00139 
00140 int RTOp_ROp_max_destroy( struct RTOp_RTOp* op )
00141 {
00142   op->vtbl->obj_data_vtbl->obj_free(NULL,NULL,&op->obj_data);
00143   op->obj_data  = NULL;
00144   op->vtbl      = NULL;
00145   return 0;
00146 }
00147 
00148 
00149 RTOp_value_type RTOp_ROp_max_val(RTOp_ReductTarget reduct_obj)
00150 {
00151   return *((RTOp_value_type*)reduct_obj);
00152 }
00153 

Generated on Tue Jul 13 09:30:54 2010 for MOOCHO (Single Doxygen Collection) by  doxygen 1.4.7