/Users/paul/Documents/phlogo/core/ArithmeticVerbs.cpp

/*
 *  PredicateVerbs.cpp
 *
 *  Author: Paul Hamilton
 *      Date: 17 Aug 2011
 *
 */

#include "Verbs.h"

#include "Thing.h"
#include "World.h"
#include "TokenStream.h"
#include "Interpreter.h"

#include <boost/algorithm/string/case_conv.hpp>

#include <math.h>

#define PI 3.14159265

using namespace std;
using namespace boost;
using namespace boost::algorithm;

namespace phlogo {

void Verbs::sum(TokenStream *ts) {

    bool isdouble = false;
    bool d = false;
    double x = getNum(ts, &d);
    if (d)
        isdouble = true;

        if (ts->withinSubExpression()) {
                while (ts->hasMoreSubExpression()) {
            d = false;
            x += getNum(ts, &d);
            if (d)
                isdouble = true;
                }
        }
        else {
        d = false;
        x += getNum(ts, &d);
        if (d)
            isdouble = true;
    }
    if (isdouble)
        setDoubleResult(x);
    else
        setLongResult(x);
}

void Verbs::difference(TokenStream *ts) {

    bool isdouble = false;
    bool d = false;
    double x = getNum(ts, &d);
    if (d)
        isdouble = true;
    
    d = false;
    x -= getNum(ts, &d);
    if (d)
        isdouble = true;
    
    if (isdouble)
        setDoubleResult(x);
    else
        setLongResult(x);
}

void Verbs::minus(TokenStream *ts) {
    
    bool isdouble = false;
    double x = getNum(ts, &isdouble);
    if (isdouble)
        setDoubleResult(-x);
    else
        setLongResult(-x);
 
}

void Verbs::product(TokenStream *ts) {

    bool isdouble = false;
    bool d = false;
    double x = getNum(ts, &d);
    if (d)
        isdouble = true;
    
        if (ts->withinSubExpression()) {
                while (ts->hasMoreSubExpression()) {
            d = false;
            x *= getNum(ts, &d);
            if (d)
                isdouble = true;
                }
        }
        else {
        d = false;
        x *= getNum(ts, &d);
        if (d)
            isdouble = true;
    }
    if (isdouble)
        setDoubleResult(x);
    else
        setLongResult(x);
}

void Verbs::quotient(TokenStream *ts) {

    bool d = false;
    double x = getNum(ts, &d);
        if (ts->withinSubExpression()) {
        x = 1/x;
        }
    else {
        x /= getNum(ts, &d);
    }  
    setDoubleResult(x);
}

void Verbs::remainder(TokenStream *ts) {

    setLongResult(getLong(ts) % getLong(ts));
    
}

void Verbs::integer(TokenStream *ts) {
    
    bool d = false;
    double x = getNum(ts, &d);
    setLongResult((int)x);
    
}

void Verbs::round(TokenStream *ts) {

    bool d = false;
    double x = getNum(ts, &d);
    setLongResult(::round(x));
    
}

void Verbs::sqrt(TokenStream *ts) {
    
    setDoubleResult(::sqrt(getDouble(ts)));
    
}

void Verbs::power(TokenStream *ts) {
    
    double a = getDouble(ts);
    double b = getDouble(ts);
    setDoubleResult(::pow(a, b));
    
}

void Verbs::exp(TokenStream *ts) {

    setDoubleResult(::exp(getDouble(ts)));
    
}

void Verbs::log10(TokenStream *ts) {

    setDoubleResult(::log10(getDouble(ts)));

}

void Verbs::ln(TokenStream *ts) {

    setDoubleResult(::log(getDouble(ts)));
    
}

double degToRad(double deg) {
    return (deg/180.0)*PI;
}
    
void Verbs::sin(TokenStream *ts) {

    setDoubleResult(::sin(degToRad(getDouble(ts))));

}

void Verbs::radsin(TokenStream *ts) {

    setDoubleResult(::sin(getDouble(ts)));

}

void Verbs::cos(TokenStream *ts) {
    
    setDoubleResult(::cos(degToRad(getDouble(ts))));
    
}

void Verbs::radcos(TokenStream *ts) {

    setDoubleResult(::cos(getDouble(ts)));
    
}

void Verbs::arctan(TokenStream *ts) {

    setDoubleResult(::atan(degToRad(getDouble(ts))));
    
}

void Verbs::radarctan(TokenStream *ts) {

    setDoubleResult(::atan(getDouble(ts)));
    
}

void Verbs::iseq(TokenStream *ts) {
    
    long a = getLong(ts);
    long b = getLong(ts);
    
    pThing t(new Thing());
    List l = t->allocList();
    if (a < b) {
        for (long i=a; i<=b; i++) {
            pThing u(new Thing());
            u->set(i);
            l.add(u);
        }
    }
    else {
        for (long i=a; i>=b; i--) {
            pThing u(new Thing());
            u->set(i);
            l.add(u);
        }
    }
    _world->setResult(t);
}

void Verbs::rseq(TokenStream *ts) {
    
    long a = getLong(ts);
    long b = getLong(ts);
    long c = getLong(ts);
    
    double dist = ((double)(b - a))/((double)c-1);
    
    pThing t(new Thing());
    List l = t->allocList();
    for (double i=a; i<=b; i += dist) {
        pThing u(new Thing());
        u->set(i);
        l.add(u);
    }
    _world->setResult(t);
}

void Verbs::lessp(TokenStream *ts) {

    setBooleanResult(getDouble(ts) < getDouble(ts));
    
}

void Verbs::greaterp(TokenStream *ts) {
    
    setBooleanResult(getDouble(ts) > getDouble(ts));
    
}

void Verbs::lessequalp(TokenStream *ts) {
    
    setBooleanResult(getDouble(ts) <= getDouble(ts));
    
}

void Verbs::greaterequalp(TokenStream *ts) {
    
    setBooleanResult(getDouble(ts) >= getDouble(ts));
    
}
    

}