general_objects.h

Go to the documentation of this file.

#ifndef HIGH_PRECISION_PSO_GENERAL_GENERAL_OBJECTS_H_
#define HIGH_PRECISION_PSO_GENERAL_GENERAL_OBJECTS_H_

#include <gmp.h>
#include <string>
#include <vector>

#include "function/function.h"

namespace highprecisionpso {

class ProgramVersion{
public:
    int version;
    int version_minor;
    int version_patch_level;

    ProgramVersion(int version, int version_minor, int version_patch_level);
    ProgramVersion(std::string version_string);
    std::string GetCompleteVersion() const;
};

bool operator>(const ProgramVersion & a, const ProgramVersion & b);
bool operator<=(const ProgramVersion & a, const ProgramVersion & b);
bool operator>=(const ProgramVersion & a, const ProgramVersion & b);
bool operator==(const ProgramVersion & a, const ProgramVersion & b);
bool operator<(const ProgramVersion & a, const ProgramVersion & b);

/************** VECTOR REDUCE OPERATIONS ***********************/
class VectorReduceOperation {
public:
    virtual ~VectorReduceOperation(){}
    virtual mpf_t* Evaluate(const std::vector<mpf_t*> & vec) = 0;

    virtual std::string GetName() = 0;
};

/************************* VECTOR REDUCE OPERATIONS ******************************/
class SpecificIdReduceOperation : public VectorReduceOperation {
public:
    SpecificIdReduceOperation(int id);
    mpf_t* Evaluate(const std::vector<mpf_t*> & vec);
    std::string GetName();

private:
    const int id_;
};

class IncreasingOrderNthObjectReduceOperation : public VectorReduceOperation {
public:
    IncreasingOrderNthObjectReduceOperation (int order_id);
    mpf_t* Evaluate(const std::vector<mpf_t*> & vec);
    std::string GetName();

private:
    const int order_id_;
};

class ArithmeticAverageReduceOperation : public VectorReduceOperation {
public:
    ArithmeticAverageReduceOperation();
    mpf_t* Evaluate(const std::vector<mpf_t*> & vec);
    std::string GetName();
};

class GeometricAverageReduceOperation : public VectorReduceOperation {
public:
    GeometricAverageReduceOperation();
    mpf_t* Evaluate(const std::vector<mpf_t*> & vec);
    std::string GetName();
};

class SumReduceOperation : public VectorReduceOperation {
public:
    SumReduceOperation();
    mpf_t* Evaluate(const std::vector<mpf_t*> & vec);
    std::string GetName();
};

class ProductReduceOperation : public VectorReduceOperation {
public:
    ProductReduceOperation();
    mpf_t* Evaluate(const std::vector<mpf_t*> & vec);
    std::string GetName();
};

class MaximalValueReduceOperation : public VectorReduceOperation {
public:
    MaximalValueReduceOperation();
    mpf_t* Evaluate(const std::vector<mpf_t*> & vec);
    std::string GetName();
};

class MinimalValueReduceOperation : public VectorReduceOperation {
public:
    MinimalValueReduceOperation();
    mpf_t* Evaluate(const std::vector<mpf_t*> & vec);
    std::string GetName();
};

class FunctionEvaluationReduceOperation : public VectorReduceOperation {
public:
    FunctionEvaluationReduceOperation(Function* function);
    mpf_t* Evaluate(const std::vector<mpf_t*> & vec);
    std::string GetName();

private:
    Function* function_;
};

class ObjectiveFunctionEvaluationReduceOperation : public VectorReduceOperation {
public:
    ObjectiveFunctionEvaluationReduceOperation();
    mpf_t* Evaluate(const std::vector<mpf_t*> & vec);
    std::string GetName();
};

/************** PAIR COMBINATION OPERATIONS ********************/
class PairReduceOperation {
public:
    virtual ~PairReduceOperation(){}
    virtual mpf_t* Evaluate(mpf_t* value1, mpf_t* value2) = 0;
    virtual std::string GetName() = 0;
};

class AddOperation : public PairReduceOperation {
public:
    mpf_t* Evaluate(mpf_t* value1, mpf_t* value2);
    std::string GetName();
};

class SubtractOperation : public PairReduceOperation {
public:
    mpf_t* Evaluate(mpf_t* value1, mpf_t* value2);
    std::string GetName();
};

class MultiplyOperation : public PairReduceOperation {
public:
    mpf_t* Evaluate(mpf_t* value1, mpf_t* value2);
    std::string GetName();
};

class DivideOperation : public PairReduceOperation {
public:
    mpf_t* Evaluate(mpf_t* value1, mpf_t* value2);
    std::string GetName();
};

class MinOperation : public PairReduceOperation {
public:
    mpf_t* Evaluate(mpf_t* value1, mpf_t* value2);
    std::string GetName();
};

class MaxOperation : public PairReduceOperation {
public:
    mpf_t* Evaluate(mpf_t* value1, mpf_t* value2);
    std::string GetName();
};

/************** CONSTANT EVALUATIONS ********************/
class ConstantEvaluation {
public:
    virtual ~ConstantEvaluation(){}
    virtual mpf_t* Evaluate() = 0;
    virtual std::string GetName() = 0;
};

class DoubleConstantEvaluation : public ConstantEvaluation {
public:
    DoubleConstantEvaluation(double value);
    mpf_t* Evaluate();
    std::string GetName();

private:
    const double value_;
};

class PiConstantEvaluation : public ConstantEvaluation {
public:
    mpf_t* Evaluate();
    std::string GetName();
};

class EConstantEvaluation : public ConstantEvaluation {
public:
    mpf_t* Evaluate();
    std::string GetName();
};

class PlusInfinityConstantEvaluation : public ConstantEvaluation {
public:
    mpf_t* Evaluate();
    std::string GetName();
};

class MinusInfinityConstantEvaluation : public ConstantEvaluation {
public:
    mpf_t* Evaluate();
    std::string GetName();
};

/************** VECTOR OPERATIONS *********************/
class VectorOperation {
public:
    virtual ~VectorOperation(){}
    virtual std::vector<mpf_t*> Operate(std::vector<mpf_t*> vec) = 0;
    virtual std::string GetName() = 0;
};

class DistTo1DOptimumOperation : public VectorOperation {
public:
    std::vector<mpf_t*> Operate(std::vector<mpf_t*> vec);
    std::string GetName();
};

/************** OPERATIONS ****************************/
class Operation {
public:
    virtual ~Operation(){}
    virtual mpf_t* Operate(mpf_t* value) = 0;
    virtual std::string GetName() = 0;
};


class SqrtOperation : public Operation {
public:
    mpf_t* Operate(mpf_t* value);
    std::string GetName();
};

class PowOperation : public Operation {
public:
    PowOperation(double exponent);

    mpf_t* Operate(mpf_t* value);
    std::string GetName();

private:
    const double exponent_;
};

class Log2Operation : public Operation {
public:
    mpf_t* Operate(mpf_t* value);
    std::string GetName();
};

class Log2DoubleOperation : public Operation {
public:
    mpf_t* Operate(mpf_t* value);
    std::string GetName();
};

class AbsOperation : public Operation {
public:
    mpf_t* Operate(mpf_t* value);
    std::string GetName();
};

class ExpOperation : public Operation {
public:
    mpf_t* Operate(mpf_t* value);
    std::string GetName();
};

class SinOperation : public Operation {
public:
    mpf_t* Operate(mpf_t* value);
    std::string GetName();
};

class CosOperation : public Operation {
public:
    mpf_t* Operate(mpf_t* value);
    std::string GetName();
};

class TanOperation : public Operation {
public:
    mpf_t* Operate(mpf_t* value);
    std::string GetName();
};

class ArcsinOperation : public Operation {
public:
    mpf_t* Operate(mpf_t* value);
    std::string GetName();
};

class ArccosOperation : public Operation {
public:
    mpf_t* Operate(mpf_t* value);
    std::string GetName();
};

class ArctanOperation : public Operation {
public:
    mpf_t* Operate(mpf_t* value);
    std::string GetName();
};

class LogEOperation : public Operation {
public:
    mpf_t* Operate(mpf_t* value);
    std::string GetName();
};

} // namespace highprecisionpso

#endif /* HIGH_PRECISION_PSO_GENERAL_GENERAL_OBJECTS_H_ */