Skip to content
Snippets Groups Projects
Select Git revision
  • f238962ccb96a6e632b845f0011bb5761424fd6e
  • master default protected
2 results

sample_functions.h

Blame
  • sample_functions.h 2.69 KiB
    #ifndef __SAMPLE_FUNCTIONS_H__
    #define __SAMPLE_FUNCTIONS_H__
    
    #include "function.h"
    #include "matrix.h"
    #include <cmath>
    
    namespace numerics {
    
    class Parabola_2D
        : public numerics::Function<numerics::Coordinate<double>, double> {
        double operator()(numerics::Coordinate<double> x) const override {
            assert(x.dimension() == input_dimension());
            double a = x[0];
            double b = x[1];
    
            return a * a + b * b;
        }
    
        size_t input_dimension() const override { return 2; }
    
        size_t output_dimension() const override { return 1; }
    };
    
    class Periodic_Wave_2D
        : public numerics::Function<numerics::Coordinate<double>, double> {
        double operator()(numerics::Coordinate<double> x) const override {
            assert(x.dimension() == input_dimension());
            return sin(x[0]) + cos(x[1]);
        }
    
        size_t input_dimension() const override { return 2; }
    
        size_t output_dimension() const override { return 1; }
    };
    
    class LennardJones
        : public numerics::Function<numerics::Coordinate<double>, double> {
    
      public:
        LennardJones(double _epsilon, double _sigma)
            : epsilon(_epsilon), sigma(_sigma) {}
    
        double operator()(numerics::Coordinate<double> x) const override {
            assert(x.dimension() == input_dimension());
            double r = x[0];
    
            double rel = sigma / r;
            double rel2 = rel * rel;
            double rel4 = rel2 * rel2;
            double rel8 = rel4 * rel4;
    
            return 4 * epsilon * (rel8 * rel4 - rel4 * rel2);
        }
    
        size_t input_dimension() const override { return 1; }
    
        size_t output_dimension() const override { return 1; }
    
        double get_rm() { return pow(2, 1.0 / 6.0) * sigma; }
    
      protected:
        double epsilon, sigma;
    };
    
    class PolyWrapper
        : public numerics::Function<numerics::Coordinate<double>, double>,
          public Polynomial {
    
      public:
        PolyWrapper(std::vector<double> _coeff) : Polynomial(_coeff) {}
    
        double operator()(numerics::Coordinate<double> x) const override {
            assert(x.dimension() == Polynomial::input_dimension());
            return Polynomial::operator()(x[0]);
        }
    
        size_t input_dimension() const override {
            return Polynomial::input_dimension();
        }
    
        size_t output_dimension() const override {
            return Polynomial::output_dimension();
        }
    };
    
    struct functions {
      public:
        // 2D test functions
        static Parabola_2D parabola_2d;
        static Periodic_Wave_2D periodic_wave_2d;
    
        // 1D test functions
        // 1D Lennard Jones potentials
        static LennardJones wide_LJ;
        static LennardJones narrow_LJ;
    
        // 1D polynomials
        static PolyWrapper parabola_1d;
        static PolyWrapper higher_parabola_1d;
        static PolyWrapper ref_polynomial_1d;
    };
    
    }; // namespace numerics
    
    #endif