dox/Common/vtkExponentialFunctions.h

Go to the documentation of this file.

/*=========================================================================

  Program:   vtkCNMRRLibrary
  Module:    $RCSfile: vtkExponentialFunctions.h,v $

  Copyright  2006  The Pennsylvania State University
  
          Notice
 
  The contents of this file are subject to The Pennsylvania State University 
  Open Source License (the "License"); you may not use this file except in 
  compliance with the License. You may obtain a copy of the License at H066 
  Radiology, NMR Building, 500 University Drive, Hershey, PA, 
  tel. (717) 531-6069 or via email at dcb210@psu.edu.
 
  Software distributed under the License is distributed on an "AS IS" basis, 
  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 
  for the specific language governing rights and limitations under the 
  License.
 
  The Original Code is listed under Exhibit A of the license.
 
  The Initial Developer of the Original Code is Don Bigler.
 
  Contributor(s):

=========================================================================*/
#ifndef __vtkExponentialFunctions_h
#define __vtkExponentialFunctions_h

#include "vtkObject.h"
#include "vtkCNMRRCommonWin32Header.h"
#if defined(AMD64_TRUE) && defined(USE_AMD_ACML)
#include "acml_mv.h"
#define SIN    fastsin
#define COS    fastcos
#define EXP    fastexp
#else
#define SIN    sin
#define COS    cos
#define EXP    exp
#endif
#include <math.h>

#define SIGN(x) ((x>=0)?1:-1)

class VTK_CNMRR_COMMON_EXPORT vtkExponentialFunctions : public vtkObject
{
   public:
      static vtkExponentialFunctions *New();
      vtkTypeRevisionMacro(vtkExponentialFunctions,vtkObject);
      

      static void exponential(double *p, double *x, int m, int n, void *data)
      {
         register int i;
         
         for(i=0; i<n; ++i)
         {
            x[i]=p[0]*EXP(-(*((double *)data+i)*p[1]));
         }
      }
      

      static void exponentialWithConstant(double *p, double *x, int m, int n, void *data)
      {
         register int i;
         
         for(i=0; i<n; ++i)
         {
            x[i]=p[0]*EXP(-(*((double *)data+i)*p[1])) + p[2];
         }
      }
      

      static void jacexponential(double *p, double *jac, int m, int n, void *data)
      {
         register int i;
         
         for(i=0; i<n; ++i)
         {
            jac[i]=-p[1]*p[0]*EXP(-(*((double *)data+i)*p[1]));
         }
      }
      

      static void oneminusexponential(double *p, double *x, int m, int n, void *data)
      {
         register int i;
         
         for(i=0; i<n; ++i)
         {
            x[i]=p[0]*(1-EXP(-(*((double *)data+i)*p[1])));
         }
      }
      

      static void jaconeminusexponential(double *p, double *jac, int m, int n, void *data)
      {
         register int i;
         
         for(i=0; i<n; ++i)
         {
            jac[i]=p[1]*p[0]*EXP(-(*((double *)data+i)*p[1]));
         }
      }
      

      static double sinc(double x)
      {
         return static_cast<double>((x==0)?1:(SIN(x)/x));
      }
      

      static void exponentialSincMod(double *p, double *x, int m, int n, void *data)
      {
         register int i;
         
         for(i=0; i<n; ++i)
         {
            x[i]=p[0]*EXP(-((*((double *)data+1+i))*p[1]))
               *fabs(vtkExponentialFunctions::sinc((*((double *)data))*(*((double *)data+1+i))));
         }
      }
      

      static void exponentialSincModWithConstant(double *p, double *x, int m, int n, void *data)
      {
         register int i;
         
         for(i=0; i<n; ++i)
         {
            x[i]=p[0]*EXP(-((*((double *)data+1+i))*p[1]))
               *fabs(vtkExponentialFunctions::sinc((*((double *)data))*(*((double *)data+1+i))))
               + p[2];
         }
      }
      

      static void jacexponentialSincMod(double *p, double *jac, int m, int n, void *data)
      {
         register int i;
         
         for(i=0; i<n; ++i)
         {
            jac[i]=SIGN(vtkExponentialFunctions::sinc((*((double *)data))*(*((double *)data+1+i))))
               *p[0]*EXP(-((*((double *)data+1+i))*p[1]))
               *((COS((*((double *)data))*(*((double *)data+1+i)))/(*((double *)data+1+i)))
               -(vtkExponentialFunctions::sinc((*((double *)data))*(*((double *)data+1+i)))*p[1])
               -(vtkExponentialFunctions::sinc((*((double *)data))*(*((double *)data+1+i)))/
                                                         (*((double *)data+1+i))));
         }
      }
      

      static void exponentialSincModThreeParam(double *p, double *x, int m, int n, void *data)
      {
         register int i;
         
         for(i=0; i<n; ++i)
         {
            x[i]=p[0]*EXP(-((*((double *)data+1+i))*p[1]))
               *fabs(vtkExponentialFunctions::sinc((*((double *)data))*p[2]*(*((double *)data+1+i))));
         }
      }
      

      static void exponentialSincModThreeParamWithConstant(double *p, double *x, int m, int n, void *data)
      {
         register int i;
         
         for(i=0; i<n; ++i)
         {
            x[i]=p[0]*EXP(-((*((double *)data+1+i))*p[1]))
               *fabs(vtkExponentialFunctions::sinc((*((double *)data))*p[2]*(*((double *)data+1+i))))
               + p[3];
         }
      }
      

      static void jacexponentialSincModThreeParam(double *p, double *jac, int m, int n, void *data)
      {
         register int i;
         
         for(i=0; i<n; ++i)
         {
            jac[i]=SIGN(vtkExponentialFunctions::sinc((*((double *)data))*p[2]*(*((double *)data+1+i))))
               *p[0]*EXP(-((*((double *)data+1+i))*p[1]))
               *((COS((*((double *)data))*p[2]*(*((double *)data+1+i)))/(*((double *)data+1+i)))
               -(vtkExponentialFunctions::sinc((*((double *)data))*p[2]*(*((double *)data+1+i)))*p[1])
               -(vtkExponentialFunctions::sinc((*((double *)data))*p[2]*(*((double *)data+1+i)))/
                                                         (*((double *)data+1+i))));
         }
      }


      static void CalculateParameterApproximates(double *x, double *y, unsigned int num, 
                                 double &A, double &B);


      static void CalculateParameterApproximatesWithConstant(double *x, double *y, unsigned int num, 
                                 double &A, double &B, double &C);
   
   protected:
      vtkExponentialFunctions() {};
      ~vtkExponentialFunctions() {};
   
   private:
      vtkExponentialFunctions(const vtkExponentialFunctions&);  // Not implemented.
      void operator=(const vtkExponentialFunctions&);  // Not implemented.
};

#endif

---