factorial.h

Go to the documentation of this file.

/* 
 * SPDX-FileCopyrightText: 2025 Gesellschaft fuer Anlagen- und Reaktorsicherheit gGmbH
 * SPDX-License-Identifier: EUPL-1.2
 * SPDX-FileContributor: Sabine Stichel
 * SPDX-FileContributor: Goethe Universität Frankfurt
 * SPDX-FileType: SOURCE
 * 
 * This file is part of d3f++.
 * d3f++ is an extension for UG4. Licensing information and citation requirements of UG4 are provided in LICENSES/UG4-LGPL_2.1
 */
 
/*
 * Original by J.Musuuza
 */
 
// extern headers
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <cmath>
#include <vector>
 
 
#define _USE_MATH_DEFINES
#include <math.h>
#include <float.h> //for DBL_MAX
#include <iomanip>
#include <cstdlib>
#include <time.h>
#include "common/common.h"
 
#include "lib_disc/common/groups_util.h"
#include "lib_disc/common/function_group.h"
#include "lib_grid/tools/subset_group.h"
#include "bridge/bridge.h"
#include "lib_disc/domain.h"
#include "lib_disc/domain_traits.h"
#include "lib_algebra/cpu_algebra_types.h"
#include "lib_disc/quadrature/quadrature.h"
#include "lib_disc/local_finite_element/local_finite_element_provider.h"
#include "lib_disc/spatial_disc/disc_util/fv1_geom.h"
#include "lib_disc/spatial_disc/user_data/user_data.h"
#include "common/util/provider.h"
#include "lib_disc/spatial_disc/disc_util/fv1_geom.h"
#include "lib_disc/spatial_disc/disc_util/hfv1_geom.h"
#include "common/parser/rapidxml/rapidxml_print.hpp"
#include "common/parser/rapidxml/rapidxml.hpp"
#include "../plugins/experimental/biogas/save_load.h"
 
 
//using namespace std;
//using namespace rapidxml;
#ifdef UG_FOR_LUA
#include "bindings/lua/lua_user_data.h"
#endif
 
namespace ug{
namespace d3f{
 
 
/*functions copied from: factorial.c*/
 
// double Factorial( int n )                                                  //
//                                                                            //
//  Description:                                                              //
//     This function computes n! for 0 <= n <= Factorial_Max_Arg().  If       //
//     n > Factorial_Max_Arg(), then DBL_MAX is returned and if n < 0, then   //
//     0 is returned.                                                         //
//                                                                            //
//  Arguments:                                                                //
//     int    n   Argument of the Factorial function.                         //
//                                                                            //
//  Return Values:                                                            //
//     If n is negative, then 0 is returned.  If n > Factorial_Max_Arg(),     //
//     then DBL_MAX is returned.  If 0 <= n <= Factorial_Max_Arg(), then      //
//     n! is returned.                                                        //
//                                                                            //
//  Example:                                                                  //
//     int n;                                                                 //
//     double x;                                                              //
//                                                                            //
//     x = Factorial( n );                                                    //
template <typename TData, int dim, typename TRet>
double FractalField<TData,dim,TRet>::Factorial(int n)
{
               // For a negative argument (n < 0) return 0.0 //
   if ( n < 0 )
     return 0.0;
           // For a large postive argument (n >= N) return DBL_MAX //
  if ( n >= N )
    return DBL_MAX;
                         // Otherwise return n!. //
   return (double) factorials[n];
}
 
 
// long double xFactorial( int n )                                            //
//                                                                            //
//  Description:                                                              //
//     This function computes n! for 0 <= n <= Factorial_Max_Arg().  If       //
//     n > Factorial_Max_Arg(), then DBL_MAX is returned and if n < 0, then   //
//     0 is returned.                                                         //
//                                                                            //
//  Arguments:                                                                //
//     int    n   Argument of the Factorial function.                         //
//                                                                            //
//  Return Values:                                                            //
//     If n is negative, then 0 is returned.  If n > Factorial_Max_Arg(),     //
//     then DBL_MAX is returned.  If 0 <= n <= Factorial_Max_Arg(), then      //
//     n! is returned.                                                        //
//                                                                            //
//  Example:                                                                  //
//     int n;                                                                 //
//     long double x;                                                         //
//                                                                            //
//     x = xFactorial( n );                                                   //
template <typename TData, int dim, typename TRet>
long double FractalField<TData,dim,TRet>::xFactorial(int n)
{
               // For a negative argument (n < 0) return 0.0 //
   if ( n < 0 )
     return 0.0L;
           // For a large postive argument (n >= N) return DBL_MAX //
   if ( n >= N )
     return  (long double) DBL_MAX;
                          // Otherwise return n!. //
   return factorials[n];
}
 
 
// int Factorial_Max_Arg( void )                                              //
//                                                                            //
//  Description:                                                              //
//     This function returns the maximum argument of the Factorial function   //
//     for which a number < DBL_MAX is returned.                              //
//                                                                            //
//  Arguments:                                                                //
//     none                                                                   //
//                                                                            //
//  Return Values:                                                            //
//     N-1                                                                    //
//                                                                            //
//  Example:                                                                  //
//     int x;                                                                 //
//                                                                            //
//     x = Factorial_Max_Arg();                                               //
 
template <typename TData, int dim, typename TRet>
int FractalField<TData,dim,TRet>::Factorial_Max_Arg()
{
  return N - 1;
}
 
 
}
}