AndroMeta/include/AndroMeta/MLib.h

Go to the documentation of this file.

/*
 * Copyright 2009-2012 AndroMeta LLC. All rights reserved.
 *
 * AndroMeta LLC retains all intellectual property and proprietary 
 * rights to this software and related documentation and any modifications 
 * thereto.  Any use, reproduction, disclosure, or distribution of this 
 * software and related documentation without an express license agreement 
 * from AndroMeta LLC is strictly prohibited.
 * 
 */

#ifndef ANDROMETA_M_LIB_H
#define ANDROMETA_M_LIB_H

#include <cmath>

#include <AndroMeta/MLibBase.h>
#include <AndroMeta/MNode.h>
#include <AndroMeta/MVar.h>
#include <AndroMeta/MObject.h>
#include <AndroMeta/MMath.h>
#include <AndroMeta/MProgram.h>
#include <AndroMeta/MTime.h>

namespace Meta{
  
  class MLib : public MLibBase{
  public:
    
    MLib();
    
    virtual ~MLib();
    
    static mvar toVar(mnode n, bool codeData=false);
 
    static mvar fromStr(const mstr& str, bool literal=true, bool exact=false){
      return mvar::fromStr(str, literal, exact);
    }
    
    static void srand(uint64_t seed);
    
    // ---- probability distributions
    
    static double uniform();
    
    static double uniform(double a, double b);
    
    static double exponential(double x);
    
    static double normal(double m, double s);
    
    static double erlang(double n, double x);
    
    static double pareto(double k, double a);
    
    static double lognormal(double a, double b);
    
    static double chisquare(double n);
    
    static long bernoulli(double p);
    
    static long equilikely(long a, long b);
    
    static long binomial(long n, double p);
    
    static long geometric(double p);
    
    static long bpascal(long n, double p);
    
    static long poisson(double m);
    
    static const mvar& choice(const mvar& seq);
    
    static mvec randomSequence(long a, long b);
    
    static mvar mixedDistribution(const mvar& v);
    
    // ---- math functions
    
    static mvar degrees(const mvar& d){
      return MMath::degrees(d);
    }
    
    static double pi(){
      return M_PI;
    }
    
    static double sqrt(double v){
      return std::sqrt(v);
    }
    
    static double pow(double v, double exponent){
      return std::pow(v, exponent);
    }
    
    static double abs(double v){
      return std::fabs(v);
    }
    
    static double log10(double v){
      return std::log10(v);
    }
    
    static double cos(double v){
      return std::cos(v);
    }
    
    static double acos(double v){
      return std::acos(v);
    }
    
    static double cosh(double v){
      return std::cosh(v);
    }
    
    static double sin(double v){
      return std::sin(v);
    }
    
    static double asin(double v){
      return std::asin(v);
    }
    
    static double sinh(double v){
      return std::sinh(v);
    }
    
    static double tan(double v){
      return std::tan(v);
    }
    
    static double atan(double v){
      return std::atan(v);
    }
    
    static double atan2(double y, double x){
      return std::atan2(y, x);
    }
    
    static double tanh(double v){
      return std::tanh(v);
    }
    
    static double inf(){
      return mvar::inf();
    }
    
    static double negInf(){
      return mvar::negInf();
    } 
    
    static double floor(double v){
      return std::floor(v);
    }
    
    static double ceil(double v){
      return MLib::ceil(v);
    }
    
    static double round(double v, double precision=1){
      return MMath::round(v, precision);
    }
    
    static bool nearInteger(double v, mvar& n){
      return MMath::nearInteger(v, n);
    }
    
    static double distance(const mvar& u, const mvar& v){
      return MMath::fastDistance(u, v);
    }
    
    static mvar scaleVector(const mvar& u, double magnitude){
      return MMath::scaleVector(u, magnitude);
    }
    
    static mvec vectorRange(const mvar& b){
      return MMath::vectorRange(b);
    }
    
    static mvec vectorRange(const mvar& a, const mvar& b){
      return MMath::vectorRange(a, b);
    }
    
    static mvec vectorRange(const mvar& a, const mvar& b, const mvar& inc){
      return MMath::vectorRange(a, b, inc);
    }
    
    static mlist listRange(const mvar& b){
      return MMath::listRange(b);
    }
    
    static mlist listRange(const mvar& a, const mvar& b){
      return MMath::listRange(a, b);
    }
    
    static mlist listRange(const mvar& a, const mvar& b, const mvar& inc){
      return MMath::listRange(a, b, inc);
    }
    
    static mvar clamp(const mvar& v, const mvar& min, const mvar& max){
      return MMath::clamp(v, min, max);
    }
    
    // ---- miscellaneous functions
        
    static void sleep(double secs){
      mtime::sleep(secs);
    }
    
    static void print(const mstr& str);
    
    static mstr repeatString(const mstr& str, int n);
    
    static mvar mergeSymbolicMaps(const mvar& m1, const mvar& m2);
    
    static bool hasArg(const mvar& key){
      return MProgram::hasArg(key);
    }
    
    static mvar args(){
      return MProgram::args();
    }
    
    static void setArgs(const mvar& args){
      MProgram::setArgs(args);
    }
    
    static mvar arg(const mvar& key){
      return MProgram::arg(key);
    }
    
    static mvar arg(const mvar& key, const mvar& def){
      return MProgram::arg(key, def);
    }
    
    static void setArg(const mvar& key, const mvar& value){
      MProgram::setArg(key, value);
    }
    
    static void argDefault(const mvar& key, const mvar& value){
      MProgram::argDefault(key, value);
    }
    
    static double systemTime(){
      return mtime::now();
    }
    
    static mstr formatTime(double t, const mstr& format){
      mtime time(t, true);
      return time.toStr(format);
    }
    
    static void setDefaultPrecision(size_t bits){
      MReal::setDefaultPrecision(bits);
    }
    
    static mstr formatTime(double t){
      mtime time(t, true);
      return time.toStr();
    }

    static mvec crossProduct(const mvec& u, const mvec& v);

    static mvar dotProduct(const mvec& u, const mvec& v);

    virtual mnode process(mnode n, uint32_t flags=0);
    
  private:
    bool restricted_;
    
    MLib& operator=(const MLib&);
    MLib(const MLib&);
  };
  
  namespace MFunc{
    inline mvar toVar(mnode n, bool codeData=false){
      return MLib::toVar(n, codeData);
    }
    
    inline mvar fromStr(const mstr& str, bool literal=true, bool exact=false){
      return MLib::fromStr(str, literal, exact);
    }
    
    inline void srand(uint64_t seed){
      return MLib::srand(seed);
    }
    
    inline double uniform(){
      return MLib::uniform();
    }
    
    inline double uniform(double a, double b){
      return MLib::uniform(a, b);
    }
    
    inline double exponential(double x){
      return MLib::exponential(x);
    }
    
    inline double normal(double m, double s){
      return MLib::normal(m, s);
    }
    
    inline double erlang(double n, double x){
      return MLib::erlang(n, x);
    }
    
    inline double pareto(double k, double a){
      return MLib::pareto(k, a);
    }

    inline double lognormal(double a, double b){
      return MLib::lognormal(a, b);
    }
    
    inline double chisquare(double n){
      return MLib::chisquare(n);
    }
    
    inline long bernoulli(double p){
      return MLib::bernoulli(p);
    }
    
    inline long equilikely(long a, long b){
      return MLib::equilikely(a, b);
    }
    
    inline long binomial(long n, double p){
      return MLib::binomial(n, p);
    }
    
    inline long geometric(double p){
      return MLib::geometric(p);
    }
    
    inline long bpascal(long n, double p){
      return MLib::bpascal(n, p);
    }
    
    inline long poisson(double m){
      return MLib::poisson(m);
    }
    
    inline const mvar& choice(const mvar& seq){
      return MLib::choice(seq);
    }
    
    inline mvec randomSequence(long a, long b){
      return MLib::randomSequence(a, b);
    }
    
    inline mvar mixedDistribution(const mvar& v){
      return MLib::mixedDistribution(v);
    }
    
    inline mvar degrees(const mvar& d){
      return MLib::degrees(d);
    }
    
    inline double mpi(){
      return MLib::pi();
    }
    
    inline double sqrt(double v){
      return MLib::sqrt(v);
    }
    
    inline double pow(double v, double exponent){
      return MLib::pow(v, exponent);
    }
    
    inline double abs(double v){
      return MLib::abs(v);
    }
    
    inline double log10(double v){
      return MLib::log10(v);
    }
    
    inline double cos(double v){
      return MLib::cos(v);
    }
    
    inline double acos(double v){
      return MLib::acos(v);
    }
    
    inline double cosh(double v){
      return MLib::cosh(v);
    }
    
    inline double sin(double v){
      return MLib::sin(v);
    }
    
    inline double asin(double v){
      return MLib::asin(v);
    }
    
    inline double sinh(double v){
      return MLib::sinh(v);
    }
    
    inline double tan(double v){
      return MLib::tan(v);
    }
    
    inline double atan(double v){
      return MLib::atan(v);
    }
    
    inline double atan2(double y, double x){
      return MLib::atan2(y, x);
    }
    
    inline double tanh(double v){
      return MLib::tanh(v);
    }
    
    inline double inf(){
      return MLib::inf();
    }
    
    inline double negInf(){
      return MLib::negInf();
    } 
    
    inline double floor(double v){
      return MLib::floor(v);
    }
    
    inline double ceil(double v){
      return MLib::ceil(v);
    }
    
    inline double round(double v, double precision=1){
      return MLib::round(v, precision);
    }
    
    inline bool nearInteger(double v, mvar& n){
      return MLib::nearInteger(v, n);
    }
    
    inline double mdistance(const mvar& u, const mvar& v){
      return MLib::distance(u, v);
    }
    
    inline mvar scaleVector(const mvar& u, double magnitude){
      return MLib::scaleVector(u, magnitude);
    }
    
    inline mvec vectorRange(const mvar& b){
      return MLib::vectorRange(b);
    }
    
    inline mvec vectorRange(const mvar& a, const mvar& b){
      return MLib::vectorRange(a, b);
    }
    
    inline mvec vectorRange(const mvar& a, const mvar& b, const mvar& inc){
      return MLib::vectorRange(a, b, inc);
    }
    
    inline mlist listRange(const mvar& b){
      return MLib::listRange(b);
    }
    
    inline mlist listRange(const mvar& a, const mvar& b){
      return MLib::listRange(a, b);
    }
    
    inline mlist listRange(const mvar& a, const mvar& b, const mvar& inc){
      return MLib::listRange(a, b, inc);
    }
    
    inline mvar clamp(const mvar& v, const mvar& min, const mvar& max){
      return MLib::clamp(v, min, max);
    }
    
    inline void sleep(double secs){
      MLib::sleep(secs);
    }
    
    inline void print(const mstr& str){
      MLib::print(str);
    }
    
    inline mstr repeatString(const mstr& str, int n){
      return MLib::repeatString(str, n);
    }
    
    inline mvar mergeSymbolicMaps(const mvar& m1, const mvar& m2){
      return MLib::mergeSymbolicMaps(m1, m2);
    }
    
    inline bool hasArg(const mvar& key){
      return MLib::hasArg(key);
    }
    
    inline mvar args(){
      return MLib::args();
    }
    
    inline void setArgs(const mvar& args){
      MLib::setArgs(args);
    }
    
    inline mvar arg(const mvar& key){
      return MLib::arg(key);
    }
    
    inline mvar arg(const mvar& key, const mvar& def){
      return MLib::arg(key, def);
    }
    
    inline void setArg(const mvar& key, const mvar& value){
      MLib::setArg(key, value);
    }
    
    inline void argDefault(const mvar& key, const mvar& value){
      MLib::argDefault(key, value);
    }
    
    inline double systemTime(){
      return MLib::systemTime();
    }
    
    inline mstr formatTime(double t, const mstr& format){
      return MLib::formatTime(t, format);
    }
    
    inline void setDefaultPrecision(size_t bits){
      MLib::setDefaultPrecision(bits);
    }

    inline mstr formatTime(double t){
      return MLib::formatTime(t);
    }

    inline mvec crossProduct(const mvec& u, const mvec& v){
      return MLib::crossProduct(u, v);
    }

    inline mvar dotProduct(const mvec& u, const mvec& v){
      return MLib::dotProduct(u, v);
    }
  }
  
} // end namespace Meta

#endif // ANDROMETA_M_LIB_H