tamgulong.h

/*
 *  Tamgu (탐구)
 *
 * Copyright 2019-present NAVER Corp.
 * under BSD 3-clause
 */
/* --- CONTENTS ---
 Project    : Tamgu (탐구)
 Version    : See tamgu.cxx for the version number
 filename   : tamgulong.h
 Date       : 2017/09/01
 Purpose    :  
 Programmer : Claude ROUX (claude.roux@naverlabs.com)
 Reviewer   :
*/

#ifndef tamgulong_h
#define tamgulong_h

#include "tamgufloat.h"
#include "tamgustring.h"

//We create a map between our methods, which have been declared in our class below. See MethodInitialization for an example
//of how to declare a new method.
class Tamgulong;
//This typedef defines a type "longMethod", which expose the typical parameters of a new Tamgu method implementation
typedef Tamgu* (Tamgulong::*longMethod)(Tamgu* contextualpattern, short idthread, TamguCall* callfunc);

//---------------------------------------------------------------------------------------------------------------------

class Tamgulong : public TamguReference {
public:
	//We export the methods that will be exposed for our new object
	//this is a static object, which is common to everyone
	//We associate the method pointers with their names in the linkedmethods map
	static Exchanging basebin_hash<longMethod> methods;

	//---------------------------------------------------------------------------------------------------------------------
	//This SECTION is for your specific implementation...
	//Your personal variables here...
	BLONG value;

	//---------------------------------------------------------------------------------------------------------------------
	Tamgulong(BLONG v, TamguGlobal* g, Tamgu* parent = NULL) : TamguReference(g, parent) {
        investigate |= is_number;
		//Do not forget your variable initialisation
		value = v;
	}

	Tamgulong(BLONG v) {
        investigate |= is_number;
		//Do not forget your variable initialisation
		value = v;
	}

	//----------------------------------------------------------------------------------------------------------------------
    void Putatomicvalue(Tamgu* v) {
        value = v->Long();
    }
    
	Tamgu* Put(Tamgu* index, Tamgu* v, short idthread) {
		value = v->Long();
		return this;
	}

    Tamgu* Putvalue(Tamgu* v, short idthread) {
        value = v->Long();
        return this;
    }

    Tamgu* Clonevalue(Tamgu* v, short idthread) {
        value = v->Long();
        return this;
    }

	Tamgu* Eval(Tamgu* context, Tamgu* v, short idthread) {

		return this;
	}

	bool Checkprecision(Tamgu* r) {
		if (r->Type() >= a_float)
			return false;
		return true;
	}

	short Type() {
        return a_long;
	}

	

    void Setidtype(TamguGlobal* global);
    
    string Typename() {
		return "long";
	}

	bool isInteger() {
		return true;
	}

	bool isAtom() {
		return true;
	}

    bool checkAtomType(short ty) {
        return (ty == a_long);
    }

	short Typenumber() {
		return a_long;
	}

	

	bool isLong() {
		return true;
	}

	Tamgu* Atom(bool forced = false) {
		if (forced || !protect || reference)
			return globalTamgu->Providelong(value);
		return this;
	}

    Tamgu* Atomref() {
        TamguReference* r;
        if (!protect || reference)
            r = globalTamgu->Providelong(value);
        else
            r = this;
        r->reference = 1;
        r->protect = false;
        return r;
    }

	string Bytes() {
		u_tamgulong x(value);
		unsigned char buff[u_tamgulongsz + 1];
		memcpy(buff, x.t, u_tamgulongsz);
		buff[u_tamgulongsz] = 0;
		return (char*)buff;
	}

	void storevalue(short u) {
		value = u;
	}

	void storevalue(long u) {
		value = u;
	}

	void storevalue(BLONG u) {
		value = u;
	}

	void storevalue(double u) {
		value = (BLONG)u;
	}

	void storevalue(unsigned char u) {
		value = (BLONG)u;
	}

	void storevalue(string u) {
		value = convertinteger(u);
	}

	void storevalue(wstring u) {
		value = convertinteger(u);
	}

	void storevalue(wchar_t u) {
		wstring w;
		w = u;
		value = convertinteger(w);
	}

	//---------------------------------------------------------------------------------------------------------------------
	//Declaration
	//All our methods must have been declared in tamguexportedmethods... See MethodInitialization below
	bool isDeclared(short n) {
        return methods.check(n);
	}

    Tamgu* Newpureinstance(short idthread) {
        return new Tamgulong(0);
    }

	Tamgu* Newinstance(short, Tamgu* f = NULL) {
		return globalTamgu->Providelong(0);
	}

	Tamgu* Newvalue(Tamgu* a, short idthread) {
		return globalTamgu->Providelong(a->Long());
	}


	TamguIteration* Newiteration(bool direction) {
		return aITERNULL;
	}

	static void AddMethod(TamguGlobal* g, string name, longMethod func, unsigned long arity, string infos);
	
	static bool InitialisationModule(TamguGlobal* g, string version);

	
	void Methods(Tamgu* v) {
            for (const auto& it : globalTamgu->infomethods[a_long])
                 v->storevalue(it.first);
      }

      string Info(string n) {
            if (globalTamgu->infomethods[a_long].find(n) !=  globalTamgu->infomethods[a_long].end())
              return globalTamgu->infomethods[a_long][n];
             return "Unknown method";
	}


	Tamgu* Succ() {
		return globalTamgu->Providelong(value + 1);
	}

	Tamgu* Pred() {
		return globalTamgu->Providelong(value - 1);
	}

	//---------------------------------------------------------------------------------------------------------------------
	//This SECTION is for your specific implementation...
	//This is an example of a function that could be implemented for your needs.
	Tamgu* Methodchr(Tamgu* contextualpattern, short idthread, TamguCall* callfunc);

	Tamgu* MethodSucc(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		return globalTamgu->Providelong(value + 1);
	}

	Tamgu* MethodPred(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		return globalTamgu->Providelong(value - 1);
	}

	Tamgu* MethodPrimefactors(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		Tamgu* kvect = Selectaivector(contextualpattern);
		BLONG n = value;
		long dec = 2;
		BLONG ni = n;
		while (n > 1 && (dec*dec) <= ni) {
			if (n%dec == 0) {
				kvect->storevalue(dec);
				n /= dec;
			}
			else
				dec++;
		}

		if (n > 1)
			kvect->storevalue((long)n);
		return kvect;
	}

	Tamgu* MethodPrime(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		BLONG n = value;
		if (!n)
			return aFALSE;
		if (n == 2 || n == 3 || n == 5 || n == 7 || n == 11)
			return aTRUE;

		if (!n || (n % 2) == 0 || (n % 3) == 0 || (n % 5) == 0 || (n % 7) == 0 || (n % 11) == 0)
			return aFALSE;

		BLONG dec = 13;
		BLONG ni = n;

		while (n > 1 && (dec*dec) <= ni) {
			if (n%dec == 0)
				return aFALSE;
			dec += 4;
			if (n%dec == 0)
				return aFALSE;
			dec += 2;
			if (n%dec == 0)
				return aFALSE;
			dec += 2;
			if (n%dec == 0)
				return aFALSE;
			dec += 2;
		}

		return aTRUE;
	}

	Tamgu* Methodeven(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		if ((value % 2) == 0)
			return aTRUE;
		return aFALSE;
	}

	Tamgu* Methododd(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		if ((value % 2) == 0)
			return aFALSE;
		return aTRUE;
	}


	Tamgu* MethodFormat(Tamgu* contextualpattern, short idthread, TamguCall* callfunc);

	Tamgu* Methodabs(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(fabs(v));
	}

	Tamgu* Methodacos(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(acos(v));
	}

	Tamgu* Methodacosh(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(acosh(v));
	}

	Tamgu* Methodasin(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(asin(v));
	}

	Tamgu* Methodasinh(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(asinh(v));
	}

	Tamgu* Methodatan(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(atan(v));
	}

	Tamgu* Methodatanh(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(atanh(v));
	}

	Tamgu* Methodcbrt(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(cbrt(v));
	}

	Tamgu* Methodcos(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(cos(v));
	}

	Tamgu* Methodcosh(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(cosh(v));
	}

	Tamgu* Methoderf(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(erf(v));
	}

	Tamgu* Methoderfc(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(erfc(v));
	}

	Tamgu* Methodexp(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(exp(v));
	}

	Tamgu* Methodexp2(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(exp2(v));
	}

	Tamgu* Methodexpm1(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(expm1(v));
	}

	Tamgu* Methodfloor(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(floor(v));
	}

	Tamgu* Methodlgamma(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(lgamma(v));
	}

	Tamgu* Methodln(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(log(v));
	}

	Tamgu* Methodlog(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(log10(v));
	}

	Tamgu* Methodlog1p(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(log1p(v));
	}

	Tamgu* Methodlog2(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(log2(v));
	}

	Tamgu* Methodlogb(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(logb(v));
	}

	Tamgu* Methodnearbyint(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(nearbyint(v));
	}

	Tamgu* Methodrint(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(rint(v));
	}

	Tamgu* Methodround(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(round(v));
	}

	Tamgu* Methodsin(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(sin(v));
	}

	Tamgu* Methodsinh(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(sinh(v));
	}

	Tamgu* Methodsqrt(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(sqrt(v));
	}

	Tamgu* Methodtan(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(tan(v));
	}

	Tamgu* Methodtanh(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(tanh(v));
	}

	Tamgu* Methodtgamma(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(tgamma(v));
	}

	Tamgu* Methodtrunc(Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		double v = (double)value;
		return globalTamgu->ProvideConstfloat(trunc(v));
	}

	//---------------------------------------------------------------------------------------------------------------------

	//ExecuteMethod must be implemented in order to execute our new Tamgu methods. This method is called when a TamguCallMethodMethod object
	//is returned by the Declaration method.
	Tamgu* CallMethod(short idname, Tamgu* contextualpattern, short idthread, TamguCall* callfunc) {
		//This call is a bit cryptic. It takes the method (function) pointer that has been associated in our map with "name"
		//and run it with the proper parameters. This is the right call which should be invoked from within a class definition
		return (this->*Tamgulong::methods.get(idname))(contextualpattern, idthread, callfunc);
	}

	void Clear() {
		//To set a variable back to empty
		value = 0;
	}

	


    string String() {
        return convertfromnumber(value);
    }

    wstring UString() {
        return wconvertfromnumber(value);
    }

    string JSonString() {
        return convertfromnumber(value);
    }

    void Setstring(string& v, short idthread) {
        v = convertfromnumber(value);
    }

    void Setstring(wstring& v, short idthread) {
        v = wconvertfromnumber(value);
    }

	long Integer() {
		return (long)value;
	}

	long Size() {
		return sizeof(value);
	}

	Tamgu* plusplus() {
		value++;
		return this;
	}

	Tamgu* minusminus() {
		value--;
		return this;
	}

	wstring Getustring(short idthread) {
		
		return wconvertfromnumber(value);
		
	}

	string Getstring(short idthread) {
		
		return convertfromnumber(value);
		
	}

	long Getinteger(short idthread) {
		return (long)value;
	}

	double Getfloat(short idthread) {
		return (double)value;
	}

	float Getdecimal(short idthread) {
		return (float)value;
	}

	BLONG Getlong(short idthread) {
		return (BLONG)value;
	}

	float Decimal() {
		return (float)value;
	}

	double Float() {
		return (double)value;
	}

    bool Boolean() {
        return value;
    }
    
    unsigned char asByte() {
        return value;
    }

    long asInteger() {
        return value;
    }

    float asDecimal() {
        return (float)value;
    }

    double asFloat() {
        return value;
    }

    BLONG asLong() {
        return value;
    }

    short asShort() {
        return value;
    }

	bool Protectedboolean() {
        Locking _lock(*globalTamgu->booleanlocks[a_long]);
        return value;
	}

	BLONG Long() {
		return value;
	}

	//we add the current value with a
	Tamgu* andset(Tamgu* a, bool itself) {
		if (itself) {
			value &= a->Long();
			return this;
		}
		return globalTamgu->Providelong(value & a->Long());
	}

	Tamgu* orset(Tamgu* a, bool itself) {
		if (itself) {
			value |= a->Long();
			return this;
		}
		return globalTamgu->Providelong(value | a->Long());
	}

	Tamgu* xorset(Tamgu* a, bool itself) {
		if (itself) {
			value ^= a->Long();
			return this;
		}
		return globalTamgu->Providelong(value ^ a->Long());
	}


	Tamgu* plus(Tamgu* a, bool itself) {
		if (itself) {
			value += a->Long();
			return this;
		}

		if (a->isFloat()) {
			double v = value;
			return globalTamgu->ProvideConstfloat(v + a->Float());
		}

		return globalTamgu->Providelong(value + a->Long());
	}

	Tamgu* minus(Tamgu* a, bool itself) {
		if (itself) {
			value -= a->Long();
			return this;
		}
		return globalTamgu->Providelong(value - a->Long());
	}

	Tamgu* multiply(Tamgu* a, bool itself) {
		if (itself) {
			value *= a->Long();
			return this;
		}
		
		if (a->isFloat()) {
			double v = value;
			return globalTamgu->ProvideConstfloat(v * a->Float());
		}

		return globalTamgu->Providelong(value * a->Long());
	}

	Tamgu* divide(Tamgu* a, bool itself) {
		double v = a->Float();
		if (v == 0)
			return globalTamgu->Returnerror(e_error_divided_by);
		v = (double)value / v;
		
		if (itself) {
			value = v;
			return this;
		}

		return globalTamgu->ProvideConstfloat(v);
	}

    Tamgu* divideinteger(Tamgu* a, bool itself) {
        BLONG v = a->Long();
        if (v == 0)
            return globalTamgu->Returnerror(e_error_divided_by);
        if (itself) {
            value /= v;
            return this;
        }
        v = value / v;
        return globalTamgu->Providelong(v);
    }

	Tamgu* power(Tamgu* a, bool itself) {
		double v = (double)value;
		v = pow(v, a->Float());
		if (itself) {
			value = v;
			return this;
		}
		return globalTamgu->ProvideConstfloat(v);
	}

	Tamgu* shiftleft(Tamgu* a, bool itself) {
		if (itself) {
			value <<= a->Long();
			return this;
		}
		return globalTamgu->Providelong(value << a->Long());
	}

	Tamgu* shiftright(Tamgu* a, bool itself) {
		if (itself) {
			value >>= a->Long();
			return this;
		}
		return globalTamgu->Providelong(value >> a->Long());
	}

	Tamgu* mod(Tamgu* a, bool itself) {
		BLONG v = a->Long();
		if (v == 0)
			return globalTamgu->Returnerror(e_error_divided_by);
		if (itself) {
			value %= v;
			return this;
		}

		v = value % v;
		return globalTamgu->Providelong(v);
	}

	Tamgu* less(Tamgu* a) {
#ifdef TAMGUSTRICTCOMPARISON
        if (!a->isNumber())
            return aFALSE;
#endif
		if (value < a->asLong())
			return aTRUE;
		return aFALSE;
	}

	Tamgu* more(Tamgu* a) {
#ifdef TAMGUSTRICTCOMPARISON
        if (!a->isNumber())
            return aFALSE;
#endif
		if (value > a->asLong())
			return aTRUE;
		return aFALSE;
	}

	Tamgu* same(Tamgu* a) {
#ifdef TAMGUSTRICTCOMPARISON
        if (!a->isNumber())
            return aFALSE;
#endif
        return booleantamgu[value == a->asLong()];
	}

	Tamgu* different(Tamgu* a) {
#ifdef TAMGUSTRICTCOMPARISON
        if (!a->isNumber())
            return aTRUE;
#endif
		if (value != a->asLong())
			return aTRUE;
		return aFALSE;
	}

	Tamgu* lessequal(Tamgu* a) {
#ifdef TAMGUSTRICTCOMPARISON
        if (!a->isNumber())
            return aFALSE;
#endif
		if (value <= a->asLong())
			return aTRUE;
		return aFALSE;
	}

	Tamgu* moreequal(Tamgu* a) {
#ifdef TAMGUSTRICTCOMPARISON
        if (!a->isNumber())
            return aFALSE;
#endif
		if (value >= a->asLong())
			return aTRUE;
		return aFALSE;
	}
};


class TamguLoopLong : public Tamgulong {
public:

	vector<BLONG> interval;
	long position;
	Tamgu* function;

	TamguLoopLong(TamguGlobal* g) : Tamgulong(0) {

		position = 0;
		function = NULL;
	}

    bool isLoop() {
        return true;
    }
    

	short Type() {
		return a_lloop;
	}


	void Addfunction(Tamgu* f) {
		function = f;
	}

	void Callfunction();

    unsigned long CallBackArity() {
        return P_TWO;
    }

	Tamgu* Put(Tamgu*, Tamgu*, short);
	Tamgu* Vector(short idthread);
    Tamgu* Putvalue(Tamgu* ke, short idthread) {
        return Put(aNULL, ke, idthread);
    }

    Tamgu* Clonevalue(Tamgu* ke, short idthread) {
        return Put(aNULL, ke, idthread);
    }

	long Size() {
		return interval.size();
	}

	void Next() {
		if (interval.size() == 0)
			return;

		position++;
		if (position >= interval.size()) {
			if (function != NULL)
				Callfunction();
			position = 0;
		}
		value = interval[position];
	}

	Tamgu* plusplus() {
		if (interval.size() == 0)
			return this;
		position++;
		if (position >= interval.size()) {
			if (function != NULL)
				Callfunction();
			position = 0;
		}
		value = interval[position];
		return this;
	}

	Tamgu* minusminus() {
		if (interval.size() == 0)
			return this;
		position--;
		if (position < 0) {
			if (function != NULL)
				Callfunction();
			position = (long)interval.size() - 1;
		}
		value = interval[position];
		return this;
	}


	Tamgu* Newinstance(short idthread, Tamgu* f = NULL) {
		TamguLoopLong* a=new TamguLoopLong(globalTamgu);
		a->function = f;
		return a;
	}

	Tamgu* plus(Tamgu* b, bool autoself) {
		if (interval.size() == 0)
			return this;

		if (autoself) {
			position += b->Integer();

			position = abs(position) % interval.size();

			value = interval[position];
			return this;
		}

		return Tamgulong::plus(b, autoself);
	}

	Tamgu* minus(Tamgu* b, bool autoself) {
		if (interval.size() == 0)
			return this;

		if (autoself) {
			position -= b->Integer();

			position = (interval.size() - abs(position)) % interval.size();

			value = interval[position];
			return this;
		}

		return Tamgulong::minus(b, autoself);
	}
};


//---------------------------------------------------------------------------------------------------------------------
class Tamgulongbuff : public Tamgulong {
public:
    long idx;
    bool used;
    
    Tamgulongbuff(long i) : Tamgulong(0) {
            //Do not forget your variable initialisation
        idx = i;
        used = false;
    }
    
    bool Candelete() {
        return false;
    }
    
    Tamgu* anInstance(long i) {
        return new Tamgulongbuff(i);
    }

    void Resetreference(short r) {
        r = reference - r;
        if (r <= 0) {
            reference.store(0);
            if (!protect) {
                protect = true;
                
                value = 0;
                if (!globalTamgu->threadMODE && used)
                    globalTamgu->lgempties.push_back(idx);
                used = false;
            }
        }
        else
            reference.store(r);
    }
    
};
#endif