utilities.h++

Go to the documentation of this file.

/*
 *Utility functions for k-dot-p code.

    Copyright (C) 2010 Joseph Pingenot

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef ___UTILITIES_HXX___
#define ___UTILITIES_HXX___

namespace kdotp {
  namespace libmodelxx {
    namespace utilities {

      /*This function will return a long unsigned int which is equal to
       *  value!  (i.e. "value factorial")  It is done at compile time
       *  and should become a numeric constant in the end.
       */
      template<long unsigned value>
      long unsigned compiletime_integer_factorial() {
  return value*compiletime_integer_factorial<value-1>();
      }
      /*oh, and we can do 2 easily!*/
      template<>
      long unsigned compiletime_integer_factorial<2>() {return 2;}
      /*technically, we only need 0, but we have 1 to shortcut it.*/
      template<>
      long unsigned compiletime_integer_factorial<1>() {return 1;}
      template<>
      long unsigned compiletime_integer_factorial<0>() {return 1;}
      
      template<long unsigned power>
      long unsigned compiletime_integer_exponentiation(long unsigned value) {
  return value*compiletime_integer_exponentiation<power-1>(value);
      }
      template<>
      long unsigned compiletime_integer_exponentiation<1>(long unsigned value) {
  return value;
      }
      template<>
      long unsigned compiletime_integer_exponentiation<0>(long unsigned value) {
  return 1;
      }
      

      /*Sets the constants such that they are the 
       *when calling, n_neighbors is = total_neighbors (so we get the power
       *  right)
       */
      template<unsigned n_neighbors>
      void get_second_derivative_consts_(long int *consts, unsigned total_neighbors, unsigned derivative) {
  get_second_derivative_consts_<n_neighbors-1>(&consts[1], total_neighbors, derivative);
      }
      /*Termination condition.  We can set one of these consts to 1.*/
      template<>
      void get_second_derivative_consts_<1>(long int *consts, unsigned total_neighbors, unsigned derivatve) {
  consts[0] = 1;
      }
      template<unsigned n_neighbors>
      void get_second_derivative_consts(long int *consts, long int *denominator) {
  get_second_derivative_consts_<n_neighbors>(consts);
  *denominator = 0;
  for(unsigned i=0; i<n_neighbors; i++) denominator += 2*consts[i];
      }
    }
  }
}

#endif