// Expression
//
// The Copyright for this file is shared equally by the
// Contributors listed below
//
// Contributors:  Alan Hadley
//
// You may use, modify and distribute this file as you see
// fit, so long as this notice remains intact, you
// may add your name to the contributors if you wish if you
// distribute modified versions of the file
//
// The Copyright holder(s) do not guarantee that the software
// is fit for any purpose, nor will they accept responsibility
// for any consequences of its use.

#include "expclass.h"
#include "qregularexpression.h"

Exp::Exp(
    bool(*newvar)(Exp *E,int,bool),
    bool(*var)(Exp *E,int,int,bool))
{
    newVar=newvar;
    Var=var;
    MyRoot=NewN(Start,0,999999,LRoot,1,0.0,0,0,"Start",Rootfix);
    AddN(MyRoot);
    AN.clear();
    Variables.reserve(1024);
    unknown_key=987654321;
}
Exp::~Exp()
{
}

int Exp::NewExp(QString e)
{
    int n;
    ERROR="";
    tokens.clear();
    an=MyRoot;
    AN.clear();
    AN.append(an);
    last_added=an;
    POS.clear();
    POS.append(0);
    pos=0;
    YourRoot=MyRoot;

    if(e.isEmpty())
    {
        ERROR="Nothing to do";
        goto Quit;
    }

    hasnumbers=false;
    hasbrackets=false;
    hasquotes=false;
    Tokenize(e);

    YourRoot=MyRoot;

    FindMultiOps();

    if(hasquotes)
    {
        FindQuotes(); // also remove spaces
        if(ERROR!="")
            goto Quit;
    }

    if(hasbrackets)
    {
        CheckBrackets();
        if(ERROR!="")
            goto Quit;
    }

    if(hasnumbers)
    {
        FindNumbers();
        if(ERROR!="")
            goto Quit;
    }

    IsMinus=false;
    close_bracket=0;
    YourRoot=BuildTree();
    if(ERROR!="")
        goto Quit;

    Simplify(YourRoot);
    if(ERROR!="")
        goto Quit;

    return YourRoot;

Quit:
    if(YourRoot!=MyRoot && N[YourRoot].parent!=-1)
        Free(YourRoot);

    while(AN.last()!=MyRoot) AN.takeLast();
    an=MyRoot;

    ERROR.replace("\"+\"","\"+/-\"");
    n=NewN(Error,0,0,LLeaf,1,__LINE__,0,0,ERROR,Nofix);
    AddN(n);
    return n;
}

bool Exp::ReplaceExp(int node,QString e)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In ReplaceExp";
        return false;;
    }
#endif
    int n;
    int TempRoot=YourRoot;
    YourRoot=MyRoot;

    ERROR="";
    tokens.clear();
    an=MyRoot;
    AN.clear();
    AN.append(an);
    last_added=an;
    POS.clear();
    POS.append(0);
    pos=0;

    if(e.isEmpty())
    {
        ERROR="Nothing to do";
        goto Quit;
    }

    hasnumbers=false;
    hasbrackets=false;
    hasquotes=false;
    Tokenize(e);

    FindMultiOps();

    if(hasquotes)
    {
        FindQuotes(); // also remove spaces
        if(ERROR!="")
            goto Quit;
    }

    if(hasbrackets)
    {
        CheckBrackets();
        if(ERROR!="")
            goto Quit;
    }

    if(hasnumbers)
    {
        FindNumbers();
        if(ERROR!="")
            goto Quit;
    }
    IsMinus=false;
    close_bracket=0;
    YourRoot=BuildTree();
    if(ERROR!="")
        goto Quit;

    Over(node,YourRoot);
    while(simplifyN(node) && ERROR=="");
    YourRoot=TempRoot;
    return true;
Quit:
    Free(YourRoot);
    YourRoot=TempRoot;

    while(AN.last()!=MyRoot) AN.takeLast();
    an=MyRoot;

    ERROR.replace("\"+\"","\"+/-\"");
    n=NewN(Error,0,0,LLeaf,1,__LINE__,0,0,ERROR,Nofix);
    AddN(n);
    return false;
}

// sort + and *
void Exp::Sort(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In Sort";
        return;
    }
#endif
    int nc=N[node].links.count();
    int i,t=N[node].type;
    if(N[node].level==LLeaf) return;
    if(nc>1 && N[node].max==MAX_LINKS && t!=Comma && t!=Semi)
        SortLinks(node);
    if(nc>0) for(i=0; i<nc; i++)
    {
        t=N[node].type;
        if(t<=RBracket || t>=RSBracket)
            Sort(N[node].links[i]);
    }
    return;
}

bool Exp::Free(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In Free";
        return false;
    }
#endif
    int p=N[node].parent;
//    if(p!=-1)
        N[p].links.removeOne(node);
    return free(node);
}
bool Exp::free(int node)
{
    // Free decendants first
    int nl=N[node].links.count(),c;
    if(nl)
    {
        for(int i=0; i<nl; i++)
        {
            c=N[node].links[i];
            free(c);
        }
    }

    // Free me
    N[node].type=Nothing;
    N[node].parent=-1;
    UsedNs.removeOne(node);
    FreeNs.append(node);
    N[node].links.clear();
    return true;
}

// is a node and ? its decendants free of text, exact match
bool Exp::FreeOf(int node,QString text,int depth)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In FreeOf text";
        return true;
    }
#endif
    if(N[node].text==text) return false;
    if(depth==0) return true;
    bool hasx=false;
    int nl=N[node].links.count(),i;
    if(nl!=0)
    {
        for(i=0; i<nl; i++)
        {
            if(!FreeOf(N[node].links[i],text,depth-1))
            {
                hasx=true;
                break;
            }
        }
    }
    return !hasx;
}
// similar for type
bool Exp::FreeOf(int node,int type,int depth)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In FreeOf type";
        return true;
    }
#endif
    if(N[node].type==type) return false;
    if(depth==0) return true;
    bool hasx=false;
    int nl=N[node].links.count(),i;
    if(nl!=0)
    {
        for(i=0; i<nl; i++)
        {
            if(!FreeOf(N[node].links[i],type,depth-1))
            {
                hasx=true;
                break;
            }
        }
    }
    return !hasx;
}

int Exp::Copy(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In Copy";
        return -1;
    }
#endif
    int n=NewN(
        N[node].type,
        N[node].min,
        N[node].max,
        N[node].level,
        N[node].sign,
        N[node].value,
        N[node].a,
        N[node].b,
        N[node].text,
        N[node].fix
    );
    int nc=N[node].links.count(),i,c;
    if(nc>0) for(i=0; i<nc; i++)
    {
        c=CopyTo(N[node].links[i]);
        N[n].links.append(c);
    }
    return n;
}
int Exp::CopyTo(int node)
{
    int n=NewN(
        N[node].type,
        N[node].min,
        N[node].max,
        N[node].level,
        N[node].sign,
        N[node].value,
        N[node].a,
        N[node].b,
        N[node].text,
        N[node].fix
    );
    // copy decendants
    int nc=N[node].links.count(),i,c;
    if(nc>0) for(i=0; i<nc; i++)
    {
        c=CopyTo(N[node].links[i]);
        N[n].links.append(c);
    }
    return n;
}

void Exp::ListVars(int node,QList<int> &vars)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In ListVars";
        return;
    }
#endif
    // only add var to list once
    if(N[node].type==Variable)
    {
        int key=Variables.value(N[node].text);
        if(!vars.contains(key))
            vars.append(key);
        return;
    }

    // check decendants
    int nc=N[node].links.count(),i;
    if(nc) for(i=0; i<nc; i++)
        if(N[node].type!=Variable)
            ListVars(N[node].links[i],vars);
}

int Exp::unknown_key;
bool Exp::AddVar(QString name,int key)
{
    QRegularExpression v("[_|a-z|A-Z][a-z|A-Z|0-9|\\_]*");
    if(v.match(name).captured(0)!=name)
        return false;

    // adjust unknown_key if it clashes with a genuine one
    while(Variables.values().contains(unknown_key)) unknown_key--;

    int k=Variables.value(name,unknown_key);
    if(k!=unknown_key) return false;

    // brand new
    Variables.insert(name,key);
    return true;
}
int Exp::GetVar(QString name)
{
    return Variables.value(name,unknown_key);
}
void Exp::DeleteVar(QString name)
{
    // If still in expression, newVar called
    Variables.remove(name);
}

#define ADD_FUN(fun,name) \
{ \
    if(f) fun.insert(name,f); \
    else fun.remove(name); \
}
void Exp::addRFun(QString name,bool
    (*f)(Exp *E,int n,int arg,NodeType t,bool eval))
    ADD_FUN(RFuns,name)
void Exp::addRCFun(QString name,bool
    (*f)(Exp *E,int n,int arg1,NodeType t1,int arg2,NodeType t2,bool eval))
    ADD_FUN(RCFuns,name)
void Exp::addRSFun(QString name,bool
    (*f)(Exp *E,int n,int arg1,NodeType t1,int arg2,NodeType t2,bool eval))
    ADD_FUN(RSFuns,name)
void Exp::addCFun(QString name,bool
    (*f)(Exp *E,int n,int arg,NodeType t,bool eval))
    ADD_FUN(CFuns,name)
void Exp::addCRFun(QString name,bool
    (*f)(Exp *E,int n,int arg1,NodeType t1,int arg2,NodeType t2,bool eval))
    ADD_FUN(CRFuns,name)
void Exp::addCRCFun(QString name,bool
    (*f)(Exp *E,int n,int arg1,NodeType t1,int arg2,NodeType t2,int arg3,NodeType t3,bool eval))
    ADD_FUN(CRCFuns,name)
void Exp::addCSFun(QString name,bool
    (*f)(Exp *E,int n,int arg1,NodeType t1,int arg2,NodeType t2,bool eval))
    ADD_FUN(CSFuns,name)
void Exp::addSFun(QString name,bool
    (*f)(Exp *E,int n,int arg,NodeType t,bool eval))
    ADD_FUN(SFuns,name)
void Exp::addSRFun(QString name,bool
    (*f)(Exp *E,int n,int arg1,NodeType t1,int arg2,NodeType t2,bool eval))
    ADD_FUN(SRFuns,name)
void Exp::addSCFun(QString name,bool
    (*f)(Exp *E,int n,int arg1,NodeType t1,int arg2,NodeType t2,bool eval))
    ADD_FUN(SCFuns,name)
void Exp::addPrePostFun(QString name,bool
    (*f)(Exp *E,int n,bool pre,int arg,NodeType t,bool eval))
    ADD_FUN(PPFuns,name)
void Exp::addOpperatorFun(QString name,bool
    (*f)(Exp *E,int n,bool eval))
    ADD_FUN(OPFuns,name)

double Exp::ValueOf(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In ValueOf";
        return 0.0;
    }
#endif
    double value=N[node].value;
    if(N[node].type==Frac)
        value+=((double)N[node].a)/((double)N[node].b);
    value*=N[node].sign;
    return value;
}
// same for child node
double Exp::ValueOf(int node,int l)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In ValueOf";
        return 0;
    }
    if(!VALID_LINK(node,l))
    {
        ERROR="Invalid Link In ValueOf";
        return 0;
    }
#endif
    double value=N[N[node].links[l]].value;
    if(N[N[node].links[l]].type==Frac)
        value+=((double)N[N[node].links[l]].a)/((double)N[N[node].links[l]].b);
    value*=N[N[node].links[l]].sign;
    return value;
}

Exp::NodeType Exp::GetType(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In GetType 1";
        return Nothing;
    }
#endif
    return N[node].type;
}
Exp::NodeType Exp::GetType(int node,int link)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In GetType ";
        return Nothing;
    }
    if(!VALID_LINK(node,link))
    {
        ERROR="Invalid Link In GetType 2";
        return Nothing;
    }
#endif
    return N[N[node].links[link]].type;
}
QString Exp::GetText(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In GetText 1";
        return "";
    }
#endif
    return N[node].text;
}
QString Exp::GetText(int node,int link)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In GetText 2";
        return "";
    }
    if(!VALID_LINK(node,link))
    {
        ERROR="Invalid Link In GetText 2";
        return "";
    }
#endif
    return N[N[node].links[link]].text;
}
void Exp::SetText(int node,QString s)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In SetText 1";
        return;
    }
#endif
    N[node].text=s;
}
void Exp::SetText(int node,QString s,int link)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In SetText 2";
        return;
    }
    if(!VALID_LINK(node,link))
    {
        ERROR="Invalid Link In SetText 2";
        return;
    }
#endif
    N[N[node].links[link]].text=s;
}
int Exp::GetA(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In GetA 1";
        return 0;
    }
#endif
    return N[node].a;
}
int Exp::GetA(int node,int link)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In GetA 2";
        return 0;
    }
    if(!VALID_LINK(node,link))
    {
        ERROR="Invalid Link In GetA 2";
        return 0;
    }
#endif
    return N[N[node].links[link]].a;
}
void Exp::SetA(int node,int i)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In SetA 1";
        return;
    }
#endif
    N[node].a=i;
}
void Exp::SetA(int node,int i,int link)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In SetA 2";
        return;
    }
    if(!VALID_LINK(node,link))
    {
        ERROR="Invalid Link In SetA 2";
        return ;
    }
#endif
    N[N[node].links[link]].a=i;
}
int Exp::GetB(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In SetB 1";
        return 0;
    }
#endif
    return N[node].b;
}
int Exp::GetB(int node,int link)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In SetB 2";
        return 0;
    }
    if(!VALID_LINK(node,link))
    {
        ERROR="Invalid Link In SetB 2";
        return 0;
    }
#endif
    return N[N[node].links[link]].b;
}
void Exp::SetB(int node,int i)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In SetB 1";
        return;
    }
#endif
    N[node].b=i;
}
void Exp::SetB(int node,int i,int link)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In SetB 2";
        return;
    }
    if(!VALID_LINK(node,link))
    {
        ERROR="Invalid Link In SetB 2";
        return;
    }
#endif
    N[N[node].links[link]].b=i;
}
double Exp::GetValue(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In GetValue 1";
        return 0;
    }
#endif
    return N[node].value;
}
double Exp::GetValue(int node,int link)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In GetValue 2";
        return 0;
    }
    if(!VALID_LINK(node,link))
    {
        ERROR="Invalid Link In GetValue 2";
        return 0;
    }
#endif
    return N[N[node].links[link]].value;
}
void Exp::SetValue(int node,double d)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In SetValue 1";
        return;
    }
#endif
    N[node].value=d;
}
void Exp::SetValue(int node,double d,int link)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In SetValue 2";
        return;
    }
    if(!VALID_LINK(node,link))
    {
        ERROR="Invalid Link In SetValue 2";
        return;
    }
#endif
    N[N[node].links[link]].value=d;
}
int Exp::GetSign(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In GetSign 1";
        return 0;
    }
#endif
    return N[node].sign;
}
int Exp::GetSign(int node,int link)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In GetSign 2";
        return 0;
    }
    if(!VALID_LINK(node,link))
    {
        ERROR="Invalid Link In GetSign 2";
        return 0;
    }
#endif
    return N[N[node].links[link]].sign;
}
void Exp::SetSign(int node,int i)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In SetSign 1";
        return;
    }
#endif
    N[node].sign=i;
}
void Exp::SetSign(int node,int i,int link)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In SetSign 2";
        return;
    }
    if(!VALID_LINK(node,link))
    {
        ERROR="Invalid Link In SetSign 2";
        return;
    }
#endif
    N[N[node].links[link]].sign=i;
}

void Exp::SwapLinks(int node,int pos1,int pos2)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In SwapLinks";
        return;
    }
    if(!VALID_LINK(node,pos1))
    {
        ERROR="Invalid Link In SwapLinks";
        return;
    }
    if(!VALID_LINK(node,pos2))
    {
        ERROR="Invalid Link In SwapLinks";
        return;
    }
    if(pos1==pos2)
    {
        ERROR="Duplicate Links In SwapLinks";
        return;
    }
#endif
    N[node].links.swapItemsAt(pos1,pos2);
}
int Exp::LinksCount(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In LinksCount";
        return -1;
    }
#endif
    return N[node].links.count();
}
int Exp::GetLink(int node,int pos)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In GetLink";
        return -1;
    }
    if(!VALID_LINK(node,pos))
    {
        ERROR="Invalid Link In GetLink";
        return -1;
    }
#endif
    return N[node].links[pos];
}
int Exp::TakeLink(int node,int pos)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In TakeLink";
        return -1;
        if(pos<0 || pos>=N[node].max)
            ERROR="Invalid Link In GetLink";
    }
    if(!VALID_LINK(node,pos))
    {
        ERROR="Invalid Link In TakeLink";
        return -1;
    }
#endif
    int nc=N[node].links.count();
    if(pos<0 || pos>=nc) return FREE;
    int n=N[node].links.takeAt(pos);
    return n;
}

void Exp::Adopt(int parent,int child)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(child) || !VALID_NODE(parent))
    {
        ERROR="Invalid Node In Adopt";
        return;
        if(child<0 || child>=N[parent].max)
            ERROR="Invalid Link In GetLink";
    }
#endif
    int p=N[child].parent;
    N[p].links.removeOne(child);
    N[parent].links.append(child);
    N[child].parent=parent;
    N[child].root=N[parent].root;
    UpdateNodes(parent);
}
int Exp::AdoptNumber(int parent,double value)
{
    int child=NewN(Number,0,0,LLeaf,1,value,0,0,"Number",Nofix);
    SimplyNumber(child);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptFrac(int parent,int Int,int a,int b)
{
    int child=NewN(Frac,0,0,LLeaf,1,(double)Int,a,b,"(`)",Nofix);
    SimplyFrac(child);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptVariable(int parent,QString name)
{
    int child=NewN(Variable,0,0,LLeaf,1,0.0,0,0,name,Nofix);
    SimplyVar(child);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptPlaceHolder(int parent)
{
    int child=NewN(PlaceHolder,0,0,LLeaf,1,1.0,0,0,"...",Nofix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptPlus(int parent)
{
    int child=NewN(Plus,2,MAX_LINKS,LPlus,1,1.0,0,0,"+",Infix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptTimes(int parent,int sign)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(Times,2,MAX_LINKS,LTimes,s,1.0,0,0,"*",Infix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptDevide(int parent,int sign)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(Devide,2,2,LDevide,s,1.0,0,0,"/",Infix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptPower(int parent,int sign)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(Power,2,2,LPower,s,1.0,0,0,"^",Infix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptComma(int parent)
{
    int child=NewN(Comma,2,MAX_LINKS,LComma,1,1.0,0,0,",",Infix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptSemi(int parent)
{
    int child=NewN(Semi,2,MAX_LINKS,LSemi,1,1.0,0,0,";",Infix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptPrefix(int parent,NodeType t,int sign)
{
    QString text;
    switch(t)
    {
    case Excl: text="!"; break;
    case Not: text="'"; break;
    case Dot: text="."; break;
    case At: text="@"; break;
    case Tilda: text="~"; break;
    case Question: text="?"; break;
    default: return FREE;
    }
    int s=1; if(sign<0) s=-1;
    int child=NewN(t,1,1,LPrefix,s,1.0,0,0,text,Prefix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptPostfix(int parent,NodeType t)
{
    QString text;
    switch(t)
    {
    case Excl: text="!"; break;
    case Not: text="'"; break;
    case Dot: text="."; break;
    case At: text="@"; break;
    case Tilda: text="~"; break;
    case Question: text="?"; break;
    default: return FREE;
    }
    int child=NewN(t,1,1,LPostfix,1,1.0,0,0,text,Postfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptEqual(int parent,NodeType t)
{
    QString text;
    switch(t)
    {
    case Equal: text="="; break;
    case Less: text="<"; break;
    case More: text=">"; break;
    case Colon: text=":"; break;
    default: return FREE;
    }
    int child=NewN(t,2,MAX_LINKS,LEqual,1,1.0,0,0,text,Infix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptRBracket(int parent,int sign)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(RBracket,1,1,LBracket,s,1.0,0,0,"()",Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptRCBracket(int parent,int sign)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(RCBracket,2,2,LBracket,s,1.0,0,0,"(){}",Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptRSBracket(int parent,int sign)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(RSBracket,2,2,LBracket,s,1.0,0,0,"()[]",Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptCBracket(int parent,int sign)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(CBracket,1,1,LBracket,s,1.0,0,0,"{}",Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptCRBracket(int parent,int sign)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(CRBracket,2,2,LBracket,s,1.0,0,0,"{}()",Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptCRCBracket(int parent,int sign)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(CRCBracket,3,3,LBracket,s,1.0,0,0,"{}()",Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptCSBracket(int parent,int sign)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(CSBracket,2,2,LBracket,s,1.0,0,0,"{}[]",Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptSBracket(int parent,int sign)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(SBracket,1,1,LBracket,s,1.0,0,0,"[]",Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptSRBracket(int parent,int sign)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(SRBracket,2,2,LBracket,s,1.0,0,0,"[]()",Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptSCBracket(int parent,int sign)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(SCBracket,2,2,LBracket,s,1.0,0,0,"[]{}",Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptRFun(int parent,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(RBracket,1,1,LBracket,s,1.0,0,0,name,Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptRCFun(int parent,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(RCBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptRSFun(int parent,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(RSBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptCFun(int parent,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(CBracket,1,1,LBracket,s,1.0,0,0,name,Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptCRFun(int parent,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(CRBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptCRCFun(int parent,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(CRCBracket,3,3,LBracket,s,1.0,0,0,name,Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptCSFun(int parent,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(CSBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptSFun(int parent,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(SBracket,1,1,LBracket,s,1.0,0,0,name,Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptSRFun(int parent,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(SRBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    Adopt(parent,child);
    return child;
}
int Exp::AdoptSCFun(int parent,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int child=NewN(SCBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    Adopt(parent,child);
    return child;
}

void Exp::Over(int dest,int src)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(dest) || !VALID_NODE(src))
    {
        ERROR="Invalid Node In Over";
        return;
    }
#endif
    int p=N[src].parent;
    N[p].links.removeOne(src);

    int root=N[dest].root;
    int parent=N[dest].parent;

    QList<int> links=N[src].links;
    N[src].links.clear();

    UsedNs.removeOne(dest);
    FreeNs.append(dest); // to become copy of src
    Copy(src); // src_copy=dest

    N[dest].links=links;
    N[dest].root=root;
    N[dest].parent=parent;

    N[src].parent=-1;
    UsedNs.removeOne(src);
    FreeNs.append(src);

    UpdateNodes(dest);
}
void Exp::ToNumber(int dest,double value)
{
    int src=NewN(Number,0,0,LLeaf,1,value,0,0,"Number",Nofix);
    SimplyNumber(src);
    Over(dest,src);
}
void Exp::ToFrac(int dest,int Int,int a,int b)
{
    int src=NewN(Frac,0,0,LLeaf,1,(double)Int,a,b,"(`)",Nofix);
    SimplyFrac(src);
    Over(dest,src);
}
void Exp::ToVariable(int dest,QString name)
{
    int src=NewN(Variable,0,0,LLeaf,1,0.0,0,0,name,Nofix);
    SimplyVar(src);
    Over(dest,src);
}
void Exp::ToPlaceHolder(int dest)
{
    int src=NewN(PlaceHolder,0,0,LLeaf,1,1.0,0,0,"...",Nofix);
    Over(dest,src);
}
void Exp::ToPlus(int dest)
{
    int src=NewN(Plus,2,MAX_LINKS,LPlus,1,1.0,0,0,"+",Infix);
    Over(dest,src);
}
void Exp::ToTimes(int dest,int sign)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(Times,2,MAX_LINKS,LTimes,s,1.0,0,0,"*",Infix);
    Over(dest,src);
}
void Exp::ToDevide(int dest,int sign)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(Devide,2,2,LDevide,s,1.0,0,0,"/",Infix);
    Over(dest,src);
}
void Exp::ToPower(int dest,int sign)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(Power,2,2,LPower,s,1.0,0,0,"^",Infix);
    Over(dest,src);
}
void Exp::ToComma(int dest)
{
    int src=NewN(Comma,2,MAX_LINKS,LComma,1,1.0,0,0,",",Infix);
    Over(dest,src);
}
void Exp::ToSemi(int dest)
{
    int src=NewN(Semi,2,MAX_LINKS,LSemi,1,1.0,0,0,";",Infix);
    Over(dest,src);
}
void Exp::ToPrefix(int dest,NodeType t,int sign)
{
    QString text;
    switch(t)
    {
    case Excl: text="!"; break;
    case Not: text="'"; break;
    case Dot: text="."; break;
    case At: text="@"; break;
    case Tilda: text="~"; break;
    case Question: text="?"; break;
    default: return;
    }
    int s=1; if(sign<0) s=-1;
    int src=NewN(t,1,1,LPrefix,s,1.0,0,0,text,Prefix);
    Over(dest,src);
}
void Exp::ToPostfix(int dest,NodeType t)
{
    QString text;
    switch(t)
    {
    case Excl: text="!"; break;
    case Not: text="'"; break;
    case Dot: text="."; break;
    case At: text="@"; break;
    case Tilda: text="~"; break;
    case Question: text="?"; break;
    default: return;
    }
    int src=NewN(t,1,1,LPostfix,1,1.0,0,0,text,Postfix);
    Over(dest,src);
}
void Exp::ToEqual(int dest,NodeType t)
{
    QString text;
    switch(t)
    {
    case Equal: text="="; break;
    case Less: text="<"; break;
    case More: text=">"; break;
    case Colon: text=":"; break;
    default: return;
    }
    int src=NewN(t,2,MAX_LINKS,LEqual,1,1.0,0,0,text,Infix);
    Over(dest,src);
}
void Exp::ToRBracket(int dest,int sign)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(RBracket,1,1,LBracket,s,1.0,0,0,"()",Groupfix);
    Over(dest,src);
}
void Exp::ToRCBracket(int dest,int sign)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(RCBracket,2,2,LBracket,s,1.0,0,0,"(){}",Groupfix);
    Over(dest,src);
}
void Exp::ToRSBracket(int dest,int sign)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(RSBracket,2,2,LBracket,s,1.0,0,0,"()[]",Groupfix);
    Over(dest,src);
}
void Exp::ToCBracket(int dest,int sign)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(CBracket,1,1,LBracket,s,1.0,0,0,"{}",Groupfix);
    Over(dest,src);
}
void Exp::ToCRBracket(int dest,int sign)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(CRBracket,2,2,LBracket,s,1.0,0,0,"{}()",Groupfix);
    Over(dest,src);
}
void Exp::ToCRCBracket(int dest,int sign)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(CRCBracket,3,3,LBracket,s,1.0,0,0,"{}()",Groupfix);
    Over(dest,src);
}
void Exp::ToCSBracket(int dest,int sign)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(CSBracket,2,2,LBracket,s,1.0,0,0,"{}[]",Groupfix);
    Over(dest,src);
}
void Exp::ToSBracket(int dest,int sign)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(SBracket,1,1,LBracket,s,1.0,0,0,"[]",Groupfix);
    Over(dest,src);
}
void Exp::ToSRBracket(int dest,int sign)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(SRBracket,2,2,LBracket,s,1.0,0,0,"[]()",Groupfix);
    Over(dest,src);
}
void Exp::ToSCBracket(int dest,int sign)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(SCBracket,2,2,LBracket,s,1.0,0,0,"[]{}",Groupfix);
    Over(dest,src);
}
void Exp::ToRFun(int dest,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(RBracket,1,1,LBracket,s,1.0,0,0,name,Groupfix);
    Over(dest,src);
}
void Exp::ToRCFun(int dest,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(RCBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    Over(dest,src);
}
void Exp::ToRSFun(int dest,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(RSBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    Over(dest,src);
}
void Exp::ToCFun(int dest,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(CBracket,1,1,LBracket,s,1.0,0,0,name,Groupfix);
    Over(dest,src);
}
void Exp::ToCRFun(int dest,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(CRBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    Over(dest,src);
}
void Exp::ToCRCFun(int dest,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(CRCBracket,3,3,LBracket,s,1.0,0,0,name,Groupfix);
    Over(dest,src);
}
void Exp::ToCSFun(int dest,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(CSBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    Over(dest,src);
}
void Exp::ToSFun(int dest,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(SBracket,1,1,LBracket,s,1.0,0,0,name,Groupfix);
    Over(dest,src);
}
void Exp::ToSRFun(int dest,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(SRBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    Over(dest,src);
}
void Exp::ToSCFun(int dest,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int src=NewN(SCBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    Over(dest,src);
}

int Exp::Insert(int orig,int insert)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(orig) || !VALID_NODE(insert))
    {
        ERROR="Invalid Node In Insert";
        return 0;
    }
#endif
    QList<int> links=N[orig].links;
    N[orig].links.clear();
    int root=N[orig].root;
    int parent=N[orig].parent;
    int pos=N[parent].links.indexOf(orig);
    N[parent].links.removeOne(orig);
    int copy=Copy(orig);
    UsedNs.removeOne(orig);
    FreeNs.append(orig);
    N[copy].links=links;
    orig=copy;

    copy=Copy(insert);
    UsedNs.removeOne(insert);
    N[insert].parent=-1;
    FreeNs.append(insert);
    insert=copy;

    if(pos>-1)
        N[parent].links.insert(pos,insert);
    else N[parent].links.append(insert);

    N[insert].root=root;
    N[insert].parent=parent;
    N[insert].links.append(orig);
    N[orig].parent=insert;
    return orig;
}
int Exp::InsertPlus(int orig)
{
    int insert=NewN(Plus,2,MAX_LINKS,LPlus,1,1.0,0,0,"+",Infix);
    return Insert(orig,insert);
}
int Exp::InsertTimes(int orig,int sign)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(Times,2,MAX_LINKS,LTimes,s,1.0,0,0,"*",Infix);
    return Insert(orig,insert);
}
int Exp::InsertDevide(int orig,int sign)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(Devide,2,2,LDevide,s,1.0,0,0,"/",Infix);
    return Insert(orig,insert);
}
int Exp::InsertPower(int orig,int sign)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(Power,2,2,LPower,s,1.0,0,0,"^",Infix);
    return Insert(orig,insert);
}
int Exp::InsertComma(int orig)
{
    int insert=NewN(Comma,2,MAX_LINKS,LComma,1,1.0,0,0,",",Infix);
    return Insert(orig,insert);
}
int Exp::InsertSemi(int orig)
{
    int insert=NewN(Semi,2,MAX_LINKS,LSemi,1,1.0,0,0,";",Infix);
    return Insert(orig,insert);
}
int Exp::InsertPrefix(int orig,NodeType t,int sign)
{
    QString text;
    switch(t)
    {
    case Excl: text="!"; break;
    case Not: text="'"; break;
    case Dot: text="."; break;
    case At: text="@"; break;
    case Tilda: text="~"; break;
    case Question: text="?"; break;
    default: return FREE;
    }
    int s=1; if(sign<0) s=-1;
    int insert=NewN(t,1,1,LPrefix,s,1.0,0,0,text,Prefix);
    return Insert(orig,insert);
}
int Exp::InsertPostfix(int orig,NodeType t)
{
    QString text;
    switch(t)
    {
    case Excl: text="!"; break;
    case Not: text="'"; break;
    case Dot: text="."; break;
    case At: text="@"; break;
    case Tilda: text="~"; break;
    case Question: text="?"; break;
    default: return FREE;
    }
    int insert=NewN(t,1,1,LPostfix,1,1.0,0,0,text,Postfix);
    return Insert(orig,insert);
}
int Exp::InsertEqual(int orig,NodeType t)
{
    QString text;
    switch(t)
    {
    case Equal: text="="; break;
    case Less: text="<"; break;
    case More: text=">"; break;
    case Colon: text=":"; break;
    default: return FREE;
    }
    int insert=NewN(t,2,MAX_LINKS,LEqual,1,1.0,0,0,text,Infix);
    return Insert(orig,insert);
}
int Exp::InsertRBracket(int orig,int sign)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(RBracket,1,1,LBracket,s,1.0,0,0,"()",Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertRCBracket(int orig,int sign)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(RCBracket,2,2,LBracket,s,1.0,0,0,"(){}",Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertRSBracket(int orig,int sign)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(RSBracket,2,2,LBracket,s,1.0,0,0,"()[]",Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertCBracket(int orig,int sign)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(CBracket,1,1,LBracket,s,1.0,0,0,"{}",Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertCRBracket(int orig,int sign)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(CRBracket,2,2,LBracket,s,1.0,0,0,"{}()",Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertCRCBracket(int orig,int sign)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(CRCBracket,3,3,LBracket,s,1.0,0,0,"{}()",Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertCSBracket(int orig,int sign)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(CSBracket,2,2,LBracket,s,1.0,0,0,"{}[]",Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertSBracket(int orig,int sign)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(SBracket,1,1,LBracket,s,1.0,0,0,"[]",Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertSRBracket(int orig,int sign)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(SRBracket,2,2,LBracket,s,1.0,0,0,"[]()",Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertSCBracket(int orig,int sign)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(SCBracket,2,2,LBracket,s,1.0,0,0,"[]{}",Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertRFun(int orig,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(RBracket,1,1,LBracket,s,1.0,0,0,name,Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertRCFun(int orig,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(RCBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertRSFun(int orig,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(RSBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertCFun(int orig,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(CBracket,1,1,LBracket,s,1.0,0,0,name,Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertCRFun(int orig,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(CRBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertCRCFun(int orig,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(CRCBracket,3,3,LBracket,s,1.0,0,0,name,Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertCSFun(int orig,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(CSBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertSFun(int orig,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(SBracket,1,1,LBracket,s,1.0,0,0,name,Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertSRFun(int orig,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(SRBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    return Insert(orig,insert);
}
int Exp::InsertSCFun(int orig,int sign,QString name)
{
    int s=1; if(sign<0) s=-1;
    int insert=NewN(SCBracket,2,2,LBracket,s,1.0,0,0,name,Groupfix);
    return Insert(orig,insert);
}

void Exp::Evaluate(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In Evaluate";
        return;
    }
#endif
    bool changed=true;
    while(changed && ERROR=="")
    {
        changed=false;
        changed|=evaluate(node);
        if(ERROR!="") break;
        changed|=simplifyN(node);
    }
    if(ERROR=="") return;

    if(YourRoot!=MyRoot)
        Free(YourRoot);

    while(AN.last()!=MyRoot) AN.takeLast();
    an=MyRoot;

    int n=NewN(Error,0,0,LLeaf,1,0.0,__LINE__,0,ERROR,Nofix);
    AddN(n);
    ERROR="";
}
bool Exp::evaluate(int node)
{
    if(ERROR!="") return false;
    bool changed=false;
    QList<int> links=N[node].links;
    int nl=links.count(),i,b,c,d,key;
    NodeType t;
    bool (*opfun)(Exp*,int,bool);
    bool (*ffun)(Exp*,int,int,NodeType,bool);
    bool (*fffun)(Exp*,int,int,NodeType,int,NodeType,bool);
    bool (*ffffun)(Exp*,int,int,NodeType,int,NodeType,int,NodeType,bool);
    bool (*ppfun)(Exp*,int,bool,int,NodeType,bool);
    t=N[node].type;
    QString text;
    switch(t)
    {
    case Variable:
        if(Var==0) break;
        key=Variables.value(N[node].text,unknown_key);
        if(key!=unknown_key)
            changed|=Var(this,node,key,true);
        break;
    case RBracket:
        c=links[0];
        changed|=evaluate(c);
        ffun=RFuns.value(N[node].text,0);
        if(ffun) changed|=ffun(this,node,c,N[c].type,true);
        break;
    case RCBracket:
        c=links[0];
        changed|=evaluate(c);
        d=links[1];
        fffun=RCFuns.value(N[node].text,0);
        if(fffun) changed|=fffun(this,node,c,N[c].type,d,N[d].type,true);
        break;
    case CRCBracket:
        b=links[0];
        c=links[1];
        changed|=evaluate(c);
        d=links[2];
        ffffun=CRCFuns.value(N[node].text,0);
        if(ffffun) changed|=ffffun(this,node,b,N[b].type,c,N[c].type,d,N[d].type,true);
        break;
    case RSBracket:
        c=links[0];
        changed|=evaluate(c);
        d=links[1];
        changed|=evaluate(d);
        fffun=RCFuns.value(N[node].text,0);
        if(fffun) changed|=fffun(this,node,c,N[c].type,d,N[d].type,true);
        break;
    case CBracket:
        c=links[0];
        ffun=CFuns.value(N[c].text,0);
        if(ffun) changed|=ffun(this,node,c,N[c].type,true);
        break;
    case CRBracket:
        c=links[0];
        d=links[1];
        changed|=evaluate(d);
        fffun=RCFuns.value(N[node].text,0);
        if(fffun) changed|=fffun(this,node,c,N[c].type,d,N[d].type,true);
        break;
    case CSBracket:
        c=links[0];
        d=links[1];
        changed|=evaluate(d);
        fffun=RCFuns.value(N[node].text,0);
        if(fffun) changed|=fffun(this,node,c,N[c].type,d,N[d].type,true);
        break;
    case SBracket:
        c=links[0];
        changed|=evaluate(c);
        ffun=SFuns.value(N[c].text,0);
        if(ffun) changed|=ffun(this,node,c,N[c].type,true);
        break;
    case SRBracket:
        c=links[0];
        changed|=evaluate(c);
        d=links[1];
        changed|=evaluate(d);
        fffun=RCFuns.value(N[node].text,0);
        if(fffun) changed|=fffun(this,node,c,N[c].type,d,N[d].type,true);
        break;
    case SCBracket:
        c=links[0];
        changed|=evaluate(c);
        d=links[1];
        fffun=RCFuns.value(N[node].text,0);
        if(fffun) changed|=fffun(this,node,c,N[c].type,d,N[d].type,true);
        break;
    case Excl:
    case Not:
    case Dot:
    case At:
    case Tilda:
    case Question:
    {
        c=links[0];
        changed|=evaluate(c);
        ppfun=PPFuns.value(N[node].text,0);
        bool pre=false; if(N[node].fix==Prefix) pre=true;
        if(ppfun) changed|=ppfun(this,node,pre,c,N[c].type,true);
        break;
    }
    default:
        if(nl)
        {
            for(i=0; i<nl; i++)
            {
                c=links[i];
                changed|=evaluate(c);
            }
            opfun=OPFuns.value(N[node].text,0);
            if(opfun) changed|=opfun(this,node,true);
        }
        break;
    }
    return changed;
}

void Exp::updatenodes(int node)
{
    int n,nn,i;
    if(parent==-1)
    {
        root=MyRoot;
        parent=MyRoot;
    } else {
        if(root==MyRoot) root=node;
        N[node].root=root;
        N[node].parent=parent;
        parent=node;
    }
    // Check Children
    nn=N[node].links.count();
    if(nn) for(i=0; i<nn; i++)
    {
        n=N[node].links[i];
        updatenodes(n);
    }
    // restore parent
    if(root==-1)
        parent=MyRoot;
    else
        parent=N[node].parent;
}
void Exp::UpdateNodes(int node)
{
    parent=N[node].parent;
    root=N[node].root;
    if(root==-1) root=MyRoot;
    updatenodes(node);
}

int Exp::NewN(
    NodeType type,
    int min,
    int max,
    Level level,
    int sign,
    double value,
    int a,
    int b,
    QString text,
    Fix fix)
{
    if(FreeNs.isEmpty())
    {
        int i;
        Item new_n;
        new_n.type=Nothing;
        new_n.parent=-1;
        int used=UsedNs.count();
        for(i=used; i<used+MAX_LINKS; i++)
        {
            N.append(new_n);
            FreeNs.append(i);
        }
        NsCount=N.count();
    }

    int n=FreeNs.takeLast();
    N[n].me=n;
    N[n].type=type;
    N[n].links.clear();
    N[n].min=min;
    N[n].max=max;
    N[n].fix=fix;
    N[n].level=level;
    N[n].sign=sign;
    N[n].value=value;
    N[n].a=a;
    N[n].b=b;
    N[n].text=text;
    if(UsedNs.count())
        N[n].parent=MyRoot;
    else
        N[n].parent=-1;
    N[n].root=-1;
    UsedNs.append(n);
    return n;
}
bool Exp::AddN(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In AddN";
        return false;
    }
#endif
    int n,c,nf,at,nt;
    // first node is special
    if(N[node].type==Start)
    {
        MyRoot=node;
        // only node with root=parent=-1
        N[node].root=-1;
        N[node].parent=-1;
        return true;
    }

    while(close_bracket>0 && an!=MyRoot)
    {
        close_bracket--;
        while(N[AN.last()].level!=LBracket && an!=MyRoot)
        {
            AN.takeLast();
            an=AN.last();
        }
        if(an==MyRoot) goto Skip;
        AN.takeLast();
        an=AN.last();
        last_added=an;
        POS.takeLast();
        pos=POS.last();
        int ml=N[an].max;
        int nl=N[an].links.count();
        if(ml==1 && nl==0)
        {
            int ph=NewN(PlaceHolder,0,0,LLeaf,1,0.0,0,0,"...",Nofix);
            N[an].links.append(ph);
        } else if(ml==2 && nl==1)
        {
            int ph=NewN(PlaceHolder,0,0,LLeaf,1,0.0,0,0,"...",Nofix);
            N[an].links.append(ph);
        }
    }
Skip:
    if(an==MyRoot && N[last_added].level!=LLeaf)
        YourRoot=node;

    // All except Brackets must connect to a lower level
    if(N[node].level!=LBracket)
        while(N[an].level>N[node].level &&
            AN.last()!=MyRoot)
        {
            // don't leave a node with too few Links
            if((N[node].type==Comma || N[node].type==Semi)
                && N[an].level==LBracket)
                break;
#ifdef QT_DEBUG
            if(N[an].links.count()<N[an].min-1)
                goto Error;
#endif
            AN.takeLast();
            an=AN.last();
            last_added=an;
            // reached the end nothing to connect to
#ifdef QT_DEBUG
            if(AN.isEmpty())
                goto Error;
#endif
        }

    an=AN.last();
    nf=N[node].fix;
    switch(nf)
    {
    case Nofix:
        if(IsMinus)
            N[node].sign*=-1;
        IsMinus=false;
        // just attach
        N[an].links.append(node);
        N[node].root=YourRoot;
        N[node].parent=an;
        last_added=node;
        POS.last()++; pos=POS.last();
        break;
    case Prefix:
        if(IsMinus)
            N[node].sign*=-1;
        IsMinus=false;
        N[an].links.append(node);
        // attach and wait
        N[node].root=YourRoot;
        N[node].parent=an;
        AN.append(node); an=node;
        last_added=node;
        POS.last()++; pos=POS.last();
        break;
    case Infix:
        // already have this type active;
        nt=N[node].type;
        at=N[an].type;
        if(at==nt)
        {
            if(N[an].max>N[an].links.count())
            {
                last_added=an;
                Free(node);
                break;
            }
        }

        // steal node attach and wait
#ifdef QT_DEBUG
        if(N[an].links.count()==0)
            goto Error;
#endif
        c=N[an].links.takeLast();
        if(c==YourRoot) YourRoot=node;
        N[an].links.append(node);
        N[node].root=YourRoot;
        N[node].parent=an;
        N[node].links.append(c);
        N[c].root=YourRoot;
        N[c].parent=node;
        if(
            N[node].type!=Plus &&
            N[node].level!=LEqual &&
            N[node].type!=MultiOp
        )
        {
            if(IsMinus)
                N[node].sign*=-1;
            IsMinus=false;
            if(std::signbit(N[c].value))
            {
                // transfer sign
                c=N[node].links[0];
                {
                    N[c].value*=-1.0;
                    N[node].sign*=-1;
                }
            }
        }
        AN.append(node); an=node;
        last_added=node;
        POS.last()++; pos=POS.last();
        break;
    case Postfix:
        // attach and steal to connection
#ifdef QT_DEBUG
        if(N[an].links.count()==0)
            goto Error;
#endif
        n=N[an].links.takeLast();
        N[an].links.append(node);
        N[node].root=YourRoot;
        N[node].parent=an;
        N[node].links.append(n);
        N[n].root=YourRoot;
        N[n].parent=node;
        last_added=node;
        POS.last()++; pos=POS.last();
        break;
    case Groupfix:
        if(IsMinus)
            N[node].sign*=-1;
        IsMinus=false;
        POS.append(0); pos=0;
        N[an].links.append(node);
        N[node].root=YourRoot;
        N[node].parent=an;
        AN.append(node); an=node;
        last_added=node;
        pos=POS.last();
        break;
    }
#ifdef QT_DEBUG
    if(N[an].links.count()>N[an].max)
        goto Error;
#endif
    return true;
#ifdef QT_DEBUG
Error:
    ERROR="Error near \""+N[node].text+"\" or \""+N[an].text+"\"";
    return false;
#endif
}

int Exp::CompareNs(int n1,int n2,bool Abs) // return -1,0,1
{
#ifdef QT_DEBUG
    if(!VALID_NODE(n1) || !VALID_NODE(n2))
    {
        ERROR="Invalid Node In CompareNs";
        return false;
    }
#endif
    int result=0,i,n;
    double a=N[n1].value;
    double b=N[n2].value;
    if(!Abs)
    {
        a*=N[n1].sign;
        b*=N[n2].sign;
    }
    int t1=N[n1].type,c1;
    int t2=N[n2].type,c2;
    bool nu1= (t1==Number || t1==Frac);
    bool nu2= (t2==Number || t2==Frac);
    if(nu1 && nu2)
    {
        if(!Abs)
        {
            if(t1==Frac)
                a+=(N[n1].sign*(double)N[n1].a)/((double)N[n1].b);
            if(t2==Frac)
                b+=(N[n2].sign*(double)N[n2].a)/((double)N[n2].b);
        } else {
            if(t1==Frac)
                a+=((double)N[n1].a)/((double)N[n1].b);
            if(t2==Frac)
                b+=((double)N[n2].a)/((double)N[n2].b);
        }
        if(a<b) return -1;
        if(a>b) return 1;
        return 0;
    }
    bool nm1= (t1==Variable);
    bool nm2= (t2==Variable);
    if(nm1 && nm2)
    {
        result=N[n1].text.compare(N[n2].text);
        if(!Abs && result==0)
        {
            if(N[n1].sign<N[n2].sign) return -1;
            if(N[n1].sign>N[n2].sign) return 1;
        }
        if(result<0) return -1;
        if(result>0) return 1;
        return 0;
    }
    if(nu1 && nm2) return -1;
    if(nu2 && nm1) return 1;
    if(nm1 && !(nm2 || nu2)) return -1;
    if(nm2 && !(nm1 || nu1)) return 1;
    if(nu1 && !(nm2 || nu2)) return -1;
    if(nu2 && !(nm1 || nu1)) return 1;

    result=N[n1].text.compare(N[n2].text);
    if(!Abs && result==0)
    {
        if(N[n1].sign<N[n2].sign) return -1;
        if(N[n1].sign>N[n2].sign) return 1;
    }
    if(result<0) return -1;
    if(result>0) return 1;

    if(t1==Plus || t2==Plus) Abs=false;
    int nc1=N[n1].links.count();
    int nc2=N[n2].links.count();
    if(nc1==0 || nc2==0)
    {
        result=N[n1].text.compare(N[n2].text);
        if(result<0) return -1;
        if(result>0) return 1;
    }
    n=nc1; if(nc2<nc1) n=nc2;
    if(N[n1].type==Times && N[n2].type==Times)
        // reverse order
        for(i=n-1; i>-1; i--)
        {
            c1=N[n1].links[i];
            c2=N[n2].links[i];
            result=CompareNs(c1,c2,Abs);
            if(result!=0) break;
        }
    else
        for(i=0; i<n; i++)
        {
            c1=N[n1].links[i];
            N[c1].sign*=N[n1].sign;
            c2=N[n2].links[i];
            N[c2].sign*=N[n2].sign;
            result=CompareNs(c1,c2,Abs);
            N[c1].sign*=N[n1].sign;
            N[c2].sign*=N[n2].sign;
            if(result!=0) break;
        }
    if(result==0)
    {
        if(t1<t2) return -1;
        if(t1>t2) return 1;
        if(nc1<nc2) result=-1;
        else if(nc1>nc2) result=1;
    }
    return result;
}
bool Exp::SortLinks(int node) // for + and *, return true if changed anything;
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In SortLinks";
        return false;
    }
#endif
    int nl=N[node].links.count(),i,q;
    if(nl<2) return true;
    QList<int> links;
    links=N[node].links;
    nl=N[node].links.count();
    bool changed=true;
    while(changed)
    {
        changed=false;
        for(i=0; i<nl-1; i++)
        {
            q=CompareNs(links[i],links[i+1],true);
            if(q==1)
            {
                links.swapItemsAt(i,i+1);
                changed=true;
            }
        }
    }
    N[node].links=links;
    return true;
}

void Exp::Signature(int node,QList<QString> &parts)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In Signature";
        return;
    }
#endif
    QString s="",sig="";
    int ninit=parts.count();
    signature(node,s,sig,parts,ninit);
    parts.append(sig);
    parts.append(s);
}
void Exp::Consts(int node,QList<QString> &parts)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In Consts";
        return;
    }
#endif
    int ninit=parts.count();
    if(N[node].type==Number)
        N[node].text=ExpText(node);
    int n=N[node].links.count();
    if(n==0) return;
    // do children first
    for(int i=0; i<n; i++)
    {
        int l=N[node].links[i];
        Consts(l,parts);
    }
    n=N[node].links.count();
    int t=N[node].type;
    if(t==Plus)
    {
        // collect lone constants in pl
        // add 1* to vars without constant
        int rb=AdoptRBracket(node,1);
        int pl=AdoptPlus(rb);
        for(int i=n-1; i>=0; i--)
        {
            int l=N[node].links[i];
            int lsign=N[l].sign; N[l].sign=1;
            bool hasx=false;
            // see if a var of interest
            for(int j=0; j<ninit; j++)
                if(!FreeOf(l,parts[j],999))
                    hasx=true;
            if(hasx)
            {
                if(N[l].type!=Times)
                {
                    InsertTimes(l,1);
                    AdoptNumber(l,1.0);
                }
                int nl=N[l].links.count(),j;
                // probably won't cover every case
                // attach sign to a non dependant factor
                // or create one
                for(j=0; j<nl; j++)
                {
                    int ll=N[l].links[j];
                    hasx=false;
                    for(int k=0; k<ninit; k++)
                        if(!FreeOf(ll,parts[k],999))
                            hasx=true;
                    if(!hasx)
                    {
                        N[ll].sign=lsign;
                        break;
                    }
                }
                if(j==nl)
                    AdoptNumber(l,lsign);
            } else {
                Adopt(pl,l);
                N[l].sign=lsign;
            }
        }

        n=N[pl].links.count();
        // add zero if no lone constant
        if(n==0)
        {
            Free(rb);
            AdoptNumber(node,0.0);
            return;
        }
        // remove (+) if only one lone constant
        if(n==1)
        {
            Over(rb,N[pl].links[0]);
            N[pl].links.clear();
            Free(pl);
        }

        // if no x ...
        if(N[node].links.count()==1)
            Over(node,rb);

Restart:
        // Build Sig
        n=N[node].links.count();
        for(int j=0; j<n-1; j++)
        { // first link to compare
            int nnj=N[node].links[j];
            if(N[nnj].links.count()!=2) continue;
            int jn=N[nnj].links[0]; // var
            int jsign=N[jn].sign;
            for(int i=j+1; i<n; i++)
            { // second link to compare
                int nni=N[node].links[i];
                if(N[nni].links.count()!=2) continue;
                int in=N[nni].links[0]; // var
                int isign=N[in].sign;
                if(CompareNs(in,jn,true)==0)
                { // combine constants belonging to same var
                    int in1=N[nni].links[1]; // const
                    N[in1].sign*=isign;
                    int jn1=N[nnj].links[1]; // const
                    N[jn1].sign*=jsign;
                    in1=InsertRBracket(in1,1);
                    InsertPlus(in1);
                    Adopt(in1,jn1);
                    Free(nnj);
                    goto Restart;
                }
            }
        }
        if(N[node].links.count()==1)
            Over(node,N[node].links[0]);

        return;
    }
    if(t==Times)
    {
        int rbx=AdoptRBracket(node,1);
        int tix=AdoptTimes(rbx,1);
        int rbc=AdoptRBracket(node,1);
        int tic=AdoptTimes(rbc,1);
        for(int i=n-1; i>=0; i--)
        {
            int l=N[node].links[i];
            bool hasx=false;
            for(int j=0; j<ninit; j++)
                if(!FreeOf(l,parts[j],999))
                    hasx=true;
            if(hasx)
                Adopt(tix,l);
            else
                Adopt(tic,l);
        }

        n=N[tix].links.count();
        if(n==0)
            Free(rbx);
        if(n==1)
        {
            Over(rbx,N[tix].links[0]);
            N[tix].links.clear();
            Free(tix);
        }

        n=N[tic].links.count();
        if(n==0)
        {
            Free(rbc);
            AdoptNumber(node,1.0);
            return;
        }
        if(n==1)
        {
            Over(rbc,N[tic].links[0]);
            N[tic].links.clear();
            Free(tic);
        }

        if(N[node].links.count()==1)
            Over(node,rbc);
        return;
    }
}
void Exp::signature(int node,QString &s,QString &sig,QList<QString> &parts,int ninit)
{
    int nl=N[node].links.count(),i,l,n;
    char ch[4];
    QString text;
    bool bracket=false;
    if(s!="" && nl!=0) bracket=true;
    if(bracket){s+="("; sig+="(";}
    // handle nodes without children
    if(nl==0)
    {
        int t=N[node].type;
        if(t==Number || t==Frac)
            text=ExpText(node);
        else
            text=N[node].text;
        n=parts.indexOf(text);
        if(n<0)
        {
            n=parts.count();
            parts.append(text);
        }
        sprintf_s(ch,"%02i",n);
        if(n<ninit)
            {s+="$"+QString(ch); sig+="$";}
        else
            {s+="#"+QString(ch); sig+="#";}
        goto end;
    }
    s+=N[node].text;
    sig+=N[node].text;
    // these have children
    for(i=0; i<nl; i++)
    {
        l=N[node].links[i];
        if(ninit)
        {
            bool hasx=false;
            // see if has a variable of interest
            for(int j=0; j<ninit; j++)
            {
                text=parts[j];
                if(!FreeOf(l,text,999))
                {
                    hasx=true;
                    break;
                }
            }
            if(!hasx) // must be constant
            {
                text=ExpText(l);
                n=parts.count();
                parts.append(text); // add to parts
                sprintf_s(ch,"%02i",n); // and sig
                s+="#"+QString(ch);
                sig+="#";
                continue;
            }
        }
        signature(l,s,sig,parts,ninit); // recursive call
    }
end:
    if(bracket){s+=")"; sig+=")";}
}

int Exp::MoveText(int node,QString text)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In MoveText";
        return -1;
    }
#endif
    int count=0,nl=N[node].links.count(),i;
    if(N[node].level==LBracket) return 0;
    if(N[node].max<3) // not allowed to sort
    {
        if(nl==0 && N[node].text==text)
            return 1;
        if(nl>0 && N[N[node].links[0]].text==text)
            return 1;
        return 0;
    }
    QList<int> links=N[node].links;
    N[node].links.clear();
    for(i=0; i<nl; i++)
    {
        if(!FreeOf(links[i],text,999))
        {
            N[node].links.prepend(links[i]);
            count++;
        } else N[node].links.append(links[i]);
    }
    return count;
}
unsigned int Exp::MoveTText(int node,QString text)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In MoveTText";
        return -1;
    }
#endif
    if(N[node].max==0)
    {
        if(N[node].text==text) return 1;
        return 0;
    }
    if(N[node].level==LBracket) return 0;
    unsigned int count=0,nl=N[node].links.count(),i,j,m;
    QList<int> links=N[node].links;
    N[node].links.clear();
    j=0;
    for(i=0; i<nl; i++)
    {
        m=MoveText(links[i],text);
        if(m)
        {
            if(m>15) m=15;
            N[node].links.prepend(links[i]);
            count+=m<<j;
            j+=4;
            if(j==32) j=0;
            continue;
        }
        N[node].links.append(links[i]);
    }
    return count;
}
int Exp::MoveType(int node,int type)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In MoveType";
        return -1;
    }
#endif
    int count=0,nl=N[node].links.count(),i;
    if(N[node].level==LBracket) return 0;
    int istype=1;
    if(N[node].type==type){istype=-1; count=1;}
    if(N[node].max<3) // not allowed to sort
    {
        if(nl==0 && N[node].type==type)
            return -1;
        if(nl>0 && N[N[node].links[0]].type==type)
            return istype*(count+1);
        return istype*count;
    }
    QList<int> links=N[node].links;
    N[node].links.clear();
    for(i=0; i<nl; i++)
    {
        if(N[links[i]].type==type)
        {
            N[node].links.prepend(links[i]);
            count++;
        } else N[node].links.append(links[i]);
    }
    return istype*count;
}
unsigned int Exp::MoveTType(int node,int type)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In MoveTType";
        return -1;
    }
#endif
    if(N[node].max==0)
    {
        if(N[node].type==type) return 1;
        return 0;
    }
    if(N[node].level==LBracket) return 0;
    unsigned int count=0,nl=N[node].links.count(),i,m,j;
    QList<int> links=N[node].links;
    N[node].links.clear();
    j=0;
    for(i=0; i<nl; i++)
    {
        m=MoveType(links[i],type);
        if(m)
        {
            if(m>15) m=15;
            N[node].links.prepend(links[i]);
            count+=m<<j;
            j+=4;
            if(j==32) j=0;
            continue;
        }
        N[node].links.append(links[i]);
    }
    return count;
}
int Exp::MoveA(int node,int a)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In MoveA";
        return -1;
    }
#endif
    int count=0,nl=N[node].links.count(),i;
    if(N[node].level==LBracket) return 0;
    if(N[node].max<3) // not allowed to sort
    {
        if(nl==0 && N[node].a==a)
            return 1;
        if(nl>0 && N[N[node].links[0]].a==a)
            return 1;
        return 0;
    }
    QList<int> links=N[node].links;
    N[node].links.clear();
    for(i=0; i<nl; i++)
    {
        if(N[links[i]].a==a)
        {
            N[node].links.prepend(links[i]);
            count++;
        } else N[node].links.append(links[i]);
    }
    return count;
}
unsigned int Exp::MoveAA(int node,int a)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In MoveAA";
        return -1;
    }
#endif
    if(N[node].max==0)
    {
        if(N[node].a==a) return 1;
        return 0;
    }
    if(N[node].level==LBracket) return 0;
    unsigned int count=0,nl=N[node].links.count(),i,m,j;
    QList<int> links=N[node].links;
    N[node].links.clear();
    j=0;
    for(i=0; i<nl; i++)
    {
        m=MoveA(links[i],a);
        if(m)
        {
            if(m>15) m=15;
            N[node].links.prepend(links[i]);
            count+=m<<j;
            j+=4;
            if(j==32) j=0;
            continue;
        }
        N[node].links.append(links[i]);
    }
    return count;
}
int Exp::MoveB(int node,int b)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In MoveB";
        return -1;
    }
#endif
    int count=0,nl=N[node].links.count(),i;
    if(N[node].level==LBracket) return 0;
    if(N[node].max<3) // not allowed to sort
    {
        if(nl==0 && N[node].b==b)
            return 1;
        if(nl>0 && N[N[node].links[0]].b==b)
            return 1;
        return 0;
    }
    QList<int> links=N[node].links;
    N[node].links.clear();
    for(i=0; i<nl; i++)
    {
        if(N[links[i]].b==b)
        {
            N[node].links.prepend(links[i]);
            count++;
        } else N[node].links.append(links[i]);
    }
    return count;
}
unsigned int Exp::MoveBB(int node,int b)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In MoveBB";
        return -1;
    }
#endif
    if(N[node].max==0)
    {
        if(N[node].b==b) return 1;
        return 0;
    }
    if(N[node].level==LBracket) return 0;
    unsigned int count=0,nl=N[node].links.count(),i,m,j;
    QList<int> links=N[node].links;
    N[node].links.clear();
    j=0;
    for(i=0; i<nl; i++)
    {
        m=MoveB(links[i],b);
        if(m)
        {
            if(m>15) m=15;
            N[node].links.prepend(links[i]);
            count+=m<<j;
            j+=4;
            if(j==32) j=0;
            continue;
        }
        N[node].links.append(links[i]);
    }
    return count;
}

bool Exp::CancelFrac(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In CancelFrac";
        return false;
    }
#endif
    if(N[node].type!=Frac) return true;
    int a=N[node].a;
    int b=N[node].b;
    int c;
    double v=N[node].value;
    int s=1; if(std::signbit(v)) s=-1;
    v=abs(v);
    if(a>b)
    {
        c=(double)(a/b);
        v+=c;
        a-=c*b;
    }
    CancelInt(a,b);
    if(v<eps)
        v=0.0;
    N[node].value=v;
    N[node].a=a;
    N[node].b=b;
    N[node].sign=s;
    return true;
}
bool Exp::CancelInt(int &a,int &b)
{
    if(a==0) {b=0; return true;}

    if(a==1 || b==1) return true;

    if(b==0)
    {
        ERROR="A Fraction has Zero on the bottom";
        return false;
    }

    if(a==b){a=1; b=1; return true;}

    int i=0,a1=1,b1=1;
    int p=Prime[0],p1;
    bool changed,failed,found;
    while(p!=0)
    {
        if(p>a || p>b) break;

        changed=true;
        while(changed)
        {
            changed=false;
            a1=a/p;
            b1=b/p;
            if(a1*p==a && b1*p==b)
            {
                a/=p;
                b/=p;
                changed=true;
            }
            if(p>a || p>b) break;
        }
        i++;
        p=Prime[i];
    }

    p=LastPrime;
    while(p<a1 && p<b1)
    {
        failed=true;
        while(failed)
        {
            failed=false;
            p+=2;
            p1=p/3; if(p1*3==p1){failed=true; continue;}
            p1=p/5; if(p1*5==p1){failed=true; continue;}
            p1=p/7; if(p1*7==p1){failed=true; continue;}
            p1=p/9; if(p1*9==p1){failed=true; continue;}
        }

        found=true;
        while(found)
        {
            found=false;
            a1=a/p;
            b1=b/p;
            if(a1*p==a && b1*p==b)
            {
                a/=p;
                b/=p;
                found=true;
            }
        }
    }
    return true;
}
bool Exp::CancelDbl(double &a,double &b)
{
    if(a==0.0) {b=0; return true;}

    if(a==1.0 || b==1.0) return true;

    if(b==0.0)
    {
        ERROR="A Fraction has Zero on the bottom";
        return false;
    }

    if(abs(a-b)<eps){a=1.0; b=1.0; return true;}
    if(a>max_int || b>max_int)
    {
        ERROR=QString::number(a)+" or "+QString::number(a)+" is too big for an Integer";
        return false;
    }

    int ia=(int)a;
    int ib=(int)b;
    CancelInt(ia,ib);
    a=(double)ia;
    b=(double)ib;

    return true;
}
bool Exp::IsInt(double d)
{
    d=abs(d);
    if(d>max_int) return false;
    int i=(int)(d+eps);
    if((d-(double)i)<eps) return true;
    return false;
}
bool Exp::IsInt(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In IsInt";
        return -1;
    }
#endif
    if(N[node].a) return false;
    double d=N[node].value;
    d=abs(d);
    if(d>max_int) return false;
    int i=(int)(d+eps);
    if((d-(double)i)<eps) return true;
    return false;
}
bool Exp::MakeFrac(int n)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(n))
    {
        ERROR="Invalid Node In MakeFrac";
        return -1;
    }
#endif
    if(N[n].type!=Number) return true;
    double v=N[n].value;
    double sign=1.0; if(v<+0.0) sign=-1.0;
    v=abs(v);
    int V=(int)v;
    double frac=v+eps/8-(double)V;
    int i;
    int a=1,b=2;
    bool found=false;
    double test;
    if(frac>eps)
    {
        for(i=0; i<100; i++)
        {
            test=((double)a)/((double)b);
            if(abs(test-frac)<eps)
            {
                found=true;
                break;
            }
            if(frac>test) a++;
            b++;
        }
    } else {
        if(IsInt(v))
        {
            found=true;
            a=b=0;
        }
    }
    if(found && a<max_int && b<max_int)
    {
        N[n].value=sign*(double)V;
        N[n].a=a;
        N[n].b=b;
        N[n].type=Frac;
        CancelFrac(n);
        return true;
    }
    ToNumber(n,sign*v);
    return true;
}

double Exp::FracToDouble(int n)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(n))
    {
        ERROR="Invalid Node In FracToDouble";
        return -1;
    }
#endif
    double v=N[n].value;
    double s=1.0; if(std::signbit(v)) s=-1;
    v=abs(v);
    if(N[n].a!=0)
        return s*(v+((double)N[n].a)/((double)N[n].b));
    else
        return N[n].value;
}

#define NN 0
#define NF 1
#define FN 2
#define FF 3
bool Exp::SimplyDefault(int node)
{
    bool changed=false;
    int i,nl;
    QList<int> links;
    links=N[node].links;
    nl=links.count();
    if(nl)
        for(i=0; i<nl; i++)
        {
            changed|=simplifyN(links[i]);
            if(ERROR!="") return changed;
        }
    return changed;
}
bool Exp::SimplyStop(int node)
{
    int c;
    if(N[node].links.count())
    {
        c=N[node].links.takeFirst();
        bool changed=simplifyN(c);
        Adopt(node,c);
        return changed;
    } else return false;
}
bool Exp::SimplyNumber(int n)
{
    bool changed=false;
    double value=N[n].value;
    if(std::signbit(value))
    {
        N[n].sign*=-1;
        N[n].value=abs(value);
        changed=true;
    }
    return changed;
}
bool Exp::SimplyFrac(int n)
{
    bool changed=false;
    double value=N[n].value;
    if(std::signbit(value))
    {
        N[n].sign*=-1;
        N[n].value=abs(value);
        changed=true;
    }

    int a=N[n].a;
    if(a<0)
    {
        N[n].sign*=-1;
        N[n].a=abs(a);
        changed=true;
    }

    int b=N[n].b;
    if(b<0)
    {
        N[n].sign*=-1;
        N[n].b=abs(b);
        changed=true;
    }
    return changed;
}
bool Exp::SimplyVar(int node)
{
    if(newVar==0) return false;
    QString name=N[node].text;
    int k=Variables.value(name,unknown_key);
    if(k==unknown_key)
        newVar(this,node,false);
    N[node].a=k & 0xffff;
    N[node].b=k & 0xffff0000;
    return false;
}
bool Exp::SimplyBracket(int node)
{
    bool changed=false;
    int p,c,i,ct,nl;
    double s;
    c=N[node].links[0];
    ct=N[c].type;

    // appears as empty brackets
    if(ct==PlaceHolder)
        return false;

    if(ct!=CBracket)
    {
        changed|=simplifyN(c);
        if(ERROR!="") return true;
        if(changed) return true;
    }

    // only interested in non-fun ()
    if(N[node].text!="()")
        return changed;

    // needed if child is , or ;
    if(ct==Comma || ct==Semi)
        return changed;

    s=N[node].sign;
    N[node].sign=1;
    c=N[node].links[0];
    p=N[node].parent;

    if(ct==Power)
    {
        // needed if -ve arround power
        if(s==-1)
        {
            N[node].sign=-1;
            return changed;
        }
    }

    // leave if multiop, don't know users intent
    if(ct==MultiOp)
    {
        // unless inside ()
        N[node].sign*=s;
        if(p!=-1 && N[p].type==RBracket)
        {
            Over(node,N[node].links[0]);
            return true;
        }
        return changed;
    }

    // needed if -ve && child power
    if(s==-1 && N[c].type==Power)
    {
        N[node].sign=s;
        return changed;
    }

    // need if parent is power and -ve child
    if(p!=-1 && N[p].type==Power && N[c].sign==-1)
    {
        if(N[p].links[0]==node) // not exponent
        {
            N[node].sign=s;
            return changed;
        }
    }

    // leave on -ve postfix child, remove from +ve
    if(p!=-1 && N[p].fix==Postfix || N[p].fix==Prefix)
    {
        if(N[c].sign!=-1)
        {
            Over(node,c);
            N[node].sign*=s;
            return true;
        }
        return false;
    }

    // leave on negative Postfix or Prefix
    if((N[c].fix==Postfix || N[c].fix==Prefix)
        && s==-1)
    {
        N[node].sign=-1;
        return changed;
    }

    // leaves don't need 'em
    if(N[c].max==0)
    {
        Over(node,c);
        N[node].sign*=s;
        return true;
    }

    // () not needed if child is fun or ()
    if(N[c].level==LBracket)
    {
        Over(node,c);
        N[node].sign*=s;
        return true;
    }

    // () not needed if parent is bracket or fun
    if(p>-1 && N[p].level==LBracket)
    {
        Over(node,c);
        N[node].sign*=s;
        return true;
    }

    // not needed if parent is Start, except , and ;
    if(p!=-1 && N[p].type==Start && ct!=Comma && ct!=Semi)
    {
        Over(node,c);
        if(N[node].type!=Plus)
        {
            N[node].sign*=s;
            return true;
        }
        nl=N[node].links.count();
        for(i=0; i<nl; i++)
            N[N[node].links[i]].sign*=s;
        return true;
    }

    // not needed on top of fraction if times
    if(p!=-1 && N[p].type==Devide &&
        (ct==Times || N[c].level==LLeaf))
    {
        if(N[p].links[0]==node)
        {
            Over(node,c);
            N[node].sign*=s;
            return true;
        }
    }

    // Unnecessary () if parent has == level
    // nested * and + cleared in SimplyPlus/Times
    if(p!=-1 && N[p].level==N[c].level)
    {
        Over(node,c);
        switch(N[node].type)
        {
        case Plus:
            nl=N[node].links.count();
            for(i=0; i<nl; i++)
                N[N[node].links[i]].sign*=s;
            s=1;
            break;
        default:
            N[node].sign*=s;
        }
        changed=true;
    }

    // not needed based on priority
    if(p!=-1 && N[p].type<N[c].type)
    {
        Over(node,c);
        N[node].sign*=s;
        return true;
    }

    N[node].sign*=s;
    return changed;
}
void Exp::AddEr(int n1,int n2)
{
    int t=0;
    if(N[n1].type==Frac) t+=2;
    if(N[n2].type==Frac) t+=1;
    int s1,s2;
    double a,b,v1,v2;
    double a1,b1,a2,b2,v;
    N[n1].value*=N[n1].sign; N[n1].sign=1;
    N[n2].value*=N[n2].sign; N[n2].sign=1;
    switch(t)
    {
    case NN:
        v=N[n1].value;
        v+=N[n2].value;
        if(v>=0.0)
            N[n1].value=v;
        else {
            N[n1].value=abs(v);
            N[n1].sign=-1;
        }
        break;
    case NF:
        ToNumber(n2,FracToDouble(n2));
        N[n2].value*=N[n1].sign; N[n2].sign=1;
        N[n1].value+=N[n2].value;
        break;
    case FN:
        ToNumber(n1,FracToDouble(n1));
        N[n1].value*=N[n1].sign; N[n1].sign=1;
        N[n1].value+=N[n2].value;
        break;
    case FF:
        v1=N[n1].value; a1=N[n1].a;
        v2=N[n2].value; a2=N[n2].a;
        if(a1==0 && a2==0)
        {
            N[n1].value=v1+v2;
            if(N[n1].value>max_int)
                ToNumber(n1,N[n1].value);
            break;
        }
        if(v1==0.0 && a1==0)
        {
            N[n1].value=N[n2].value;
            N[n1].a=N[n2].a;
            N[n1].b=N[n2].b;
            break;
        }
        if(v2==0.0 && a2==0.0)
            break;
        s1=1; if(signbit(v1)) s1=-1;
        s2=1; if(signbit(v2)) s2=-1;
        b1=N[n1].b; b2=N[n2].b;
        if(v1==0.0 && v2==0.0)
        {
            a=s1*a1*b2+s2*a2*b1;
            b=b1*b2;
            if(abs(a)>max_int || b>max_int)
            {
                ToNumber(n1,a/b);
                SimplyNumber(n1);
                break;
            }
            v=0.0; if(a<0){a=abs(a); v*=-1;}
            N[n1].value=v;
            N[n1].a=a;
            N[n1].b=b;
            CancelFrac(n1);
            break;
        }
        if(a1!=0 && a2!=0)
        {
            if(v1==0) // v2 is not==0
            {
                a=s1*a1*b2+s2*(a2+b2*abs(v2))*b1;
                b=b1*b2;
                if(abs(a)>max_int || b>max_int)
                {
                    ToNumber(n1,a/b);
                    break;
                }
                v=0.0; if(a<0){a=abs(a); v*=-1.0;}
                N[n1].value=v;
                N[n1].a=a;
                N[n1].b=b;
                CancelFrac(n1);
                break;
            }
            if(v2==0) // v1 is not==0
            {
                a=s2*a2*b1+s1*(a1+b1*abs(v1))*b2;
                b=b1*b2;
                if(abs(a)>max_int || b>max_int)
                {
                    ToNumber(n1,a/b);
                    break;
                }
                v=0.0; if(a<0){a=abs(a); v*=-1;}
                N[n1].value=v;
                N[n1].a=a;
                N[n1].b=b;
                CancelFrac(n1);
                break;
            }
            // full house
            a=s1*(a1+b1*abs(v1))*b2+s2*(a2+b2*abs(v2))*b1;
            b=b1*b2;
            if(abs(a)>max_int || b>max_int)
            {
                ToNumber(n1,a/b);
                break;
            }
            v=0.0; if(a<0){a=abs(a); v*=-1;}
            N[n1].value=v;
            N[n1].a=a;
            N[n1].b=b;
            CancelFrac(n1);
            break;
        }
        if(v1!=0 && a1==0)
        {
            a=v1*b2+s2*(a2+abs(v2)*b2);
            b=b2;
            if(abs(a)>max_int)
            {
                ToNumber(n1,a/b);
                SimplyNumber(n1);
                break;
            }
            v=0.0; if(a<0){a=abs(a); v*=-1;}
            N[n1].value=v;
            N[n1].a=a;
            N[n1].b=b;
            CancelFrac(n1);
            break;
        }
        // if(v2!=0 && a2==0)
        a=v2*b1+s1*(a1+abs(v1)*b1);
        b=b1;
        if(abs(a)>max_int)
        {
            ToNumber(n1,a/b);
            break;
        }
        v=0.0; if(a<0){a=abs(a); v*=-1;}
        N[n1].value=v;
        N[n1].a=a;
        N[n1].b=b;
        CancelFrac(n1);
        break;
    }
    Free(n2);
}
bool Exp::SimplyPlus(int node)
{
    bool changed=false;
    int i,j,nl,ct,c,dt,d,cct,cc,ddt,dd,n,nn,q,count,p;
    QList<int> links;
    bool has_numbers=false;
    bool has_plus=false;
    bool has_times=false;
    bool has_other=false;
    nl=N[node].links.count();
    for(i=0; i<nl; i++)
    {
        c=N[node].links[i];
        changed|=simplifyN(c);
        if(ERROR!="") goto PlusEnd;
    }
    if(changed)
        goto PlusEnd;

    p=N[node].parent;
    if(p>-1 && (N[p].type==Times || N[p].type==Devide || N[p].type==Power))
    {
        InsertRBracket(node,1);
        return true;
    }

    links=N[node].links;
    N[node].links.clear();
    nl=links.count();
    for(i=0; i<nl; i++)
    {
        c=links.takeLast();
        ct=N[c].type;
        switch(ct)
        {
        case Number:
            // drop zeros
            if(abs(N[c].value)<eps)
            {
                links.removeOne(c);
                Free(c);
                changed=true;
                N[node].links.append(links);
                goto PlusEnd;
            }
            has_numbers=true;
            break;
        case Frac:
            // drop zeros
            if(abs(N[c].value)<eps && N[c].a==0)
            {
                links.removeOne(c);
                Free(c);
                changed=true;
                N[node].links.append(links);
                goto PlusEnd;
            }
            has_numbers=true;
            break;
        case Plus:
            has_plus=true;
            break;
        case Times:
            has_times=true;
            break;
        default:
            has_other=true;
        }
        N[node].links.append(c);
    }
    if(N[node].links.count()<2)
        goto PlusEnd;

    if(has_numbers)
    {
        links=N[node].links;
        N[node].links.clear();
        nl=links.count();
        // sum numbers and fractions
        // sort links into numeric and non numeric
        for(i=0; i<nl; i++)
        {
            c=links.takeLast();
            ct=N[c].type;
            if(ct==Frac || ct==Number)
            {
                links.prepend(c);
            } else
                N[node].links.append(c);
        }
        // do arithmetic
        nl=links.count();
        switch(nl)
        {
        case 0:
            break;
        case 1:
            N[node].links.append(links[0]);
            break;
        default:
            changed=true;
            c=links[0];
            while(links.count()>1)
                AddEr(c,links.takeLast());
            N[node].links.append(c);
        }
        if(changed) goto PlusEnd;
    }

    if(has_plus)
    {
        // remove nested + a+|b+c|+d
        links=N[node].links;
        N[node].links.clear();
        nl=links.count();
        for(i=0; i<nl; i++)
        {
            c=links[i];
            ct=N[c].type;
            if(ct==Plus)
            {
                nn=N[c].links.count();
                for(j=0; j<nn; j++)
                    N[node].links.append(N[c].links.takeFirst());
                Free(c);
                changed=true;
            } else
                N[node].links.append(c);
        }
        if(changed || N[node].links.count()<2)
            goto PlusEnd;
    }

    if(has_other)
    {
        // look for duplicates with oposite signs
        SortLinks(node);
        links=N[node].links;
        N[node].links.clear();
        nl=links.count();
        i=nl-1;
        while(i>0)
        {
            int a=Copy(links[i]);
            int s=N[a].sign;
            if(N[a].text!="()")
                InsertRBracket(a,s);
            int b=Copy(links[i-1]);
            s=N[b].sign;
            if(N[b].text!="()")
                InsertRBracket(b,s);
            N[a].sign*=-1;
            q=CompareNs(a,b,false);
            Free(a); Free(b);
            if(q==0)
            {
                Free(links[i]);
                links.takeLast();
                i--;
                Free(links[i]);
                links.takeLast();
                i--;
                changed=true;
                continue;
            }
            Adopt(node,links.takeLast());
            i--;
        }
        // check for odd one left over
        if(!links.isEmpty())
            Adopt(node,links.takeLast());
        if(changed) goto PlusEnd;

        // convert from adding same to times an int
        links=N[node].links;
        nl=links.count();
        N[node].links.clear();
        i=0;
        while(i<nl)
        {
            count=0;
            // count matching links
            if(i<nl-1)
            {
                q=CompareNs(links[i],links[i+1],true);
                if(N[links[i]].sign*N[links[i+1]].sign>0)
                    while(i<nl-1 && q==0)
                    {
                        Free(links[i]);
                        count++;
                        i++;
                        if(i<nl-1)
                            q=CompareNs(links[i],links[i+1],true);
                    }
            }
            if(count==0)
            {
                Adopt(node,links[i]);
            } else {
                // create product
                n=NewN(Times,2,MAX_LINKS,LTimes,1,1.0,0,0,"*",Infix);
                Adopt(node,n);
                nn=NewN(Number,0,0,LLeaf,1,count+1.0,0,0,"Number",Nofix);
                Adopt(n,nn);
                Adopt(n,links[i]);
                changed=true;
            }
            i++;
        }
    }

    if(has_times)
    {
        // convert from n1*x + n2*x to (n1+n2) * x
        links=N[node].links;
        nl=links.count();
        N[node].links.clear();
        for(j=0; j<nl-1; j++)
        {
            c=links[j];
            if(c==-1) continue;
            ct=N[c].type;
            for(i=j+1; i<nl; i++)
            {
                d=links[i];
                if(d==-1) continue;
                dt=N[d].type;
                if(ct==Times)
                {
                    if(dt==Times) // c* and d*
                    {
                        cc=N[c].links[0];
                        cct=N[cc].type;
                        dd=N[d].links[0];
                        ddt=N[dd].type;
                        if(cct!=Number)
                        {
                            AdoptNumber(c,1.0);
                            SortLinks(c);
                            cc=N[c].links[0];
                        }
                        if(ddt!=Number)
                        {
                            AdoptNumber(d,1.0);
                            SortLinks(d);
                            dd=N[d].links[0];
                        }
                        n=Copy(c);
                        N[N[n].links[0]].value=1.0; N[n].a=N[n].b=0;
                        nn=Copy(d);
                        N[N[nn].links[0]].value=1.0; N[nn].a=N[nn].b=0;
                        if(CompareNs(n,nn,true)==0)
                        {
                            AddEr(cc,dd);
                            N[node].links.append(c);
                            links[i]=-1;
                            links[j]=-1;
                            Free(d);
                            changed=true;
                        }
                        Free(n); Free(nn);
                    } else { // c* d?
                        cc=N[c].links[0];
                        cct=N[cc].type;
                        if(cct!=Number)
                            continue;
                        nn=NewN(Times,2,MAX_LINKS,LTimes,1,1.0,0,0,"*",Infix);
                        dd=AdoptNumber(nn,1.0);
                        Adopt(nn,Copy(d));
                        n=Copy(c);
                        q=N[n].links[0];
                        N[q].value=1.0;
                        N[q].a=0;
                        N[q].b=0;
                        if(CompareNs(n,nn,true)==0)
                        {
                            N[cc].value++;
                            N[node].links.append(c);
                            links[i]=-1;
                            links[j]=-1;
                            Free(d);
                            changed=true;
                        }
                        Free(n); Free(nn);
                    }
                } else { // c? d*
                    if(dt==Times)
                    {
                        int temp=c; c=d; d=temp;
                        cc=N[c].links[0];
                        cct=N[cc].type;
                        if(cct!=Number)
                            continue;
                        nn=NewN(Times,2,MAX_LINKS,LTimes,1,0.0,0,0,"*",Infix);
                        dd=AdoptNumber(nn,1.0);
                        Adopt(nn,Copy(d));
                        n=Copy(c);
                        q=N[n].links[0];
                        N[q].value=1.0;
                        N[q].a=0;
                        N[q].b=0;
                        if(CompareNs(n,nn,true)==0)
                        {
                            N[cc].value++;
                            N[node].links.append(c);
                            links[i]=-1;
                            links[j]=-1;
                            Free(d);
                            changed=true;
                        }
                        Free(n); Free(nn);
                    }
                }
            }
        }
        nl=links.count();
        if(nl) for(i=0; i<nl; i++)
        {
            if(links[i]==-1) continue;
            if(N[links[i]].type==Times)
            {
                c=N[links[i]].links[0];
                if(N[c].type==Number || N[c].type==Frac)
                    if(N[c].value==1.0 && N[c].a==0)
                {
                    N[links[i]].sign*=N[c].sign;
                    Free(c);
                }
            }
            N[node].links.append(links[i]);
        }
    }
PlusEnd:
    // just replace with zero
    if(N[node].links.isEmpty())
    {
        n=NewN(Number,0,0,LLeaf,1,0.0,0,0,"Number",Nofix);
        Over(node,n);
        return true;
    }

    // if only one left
    if(N[node].links.count()==1)
    {
        c=N[node].links.takeLast();
        Over(node,c);
        return true;
    }

    Sort(node);
    return changed;
}
void Exp::MulEr(int n1,int n2)
{
    int t=0;
    if(N[n1].type==Frac) t+=2;
    if(N[n2].type==Frac) t+=1;
    bool s;
    double a,b,a1,b1,a2,b2,v1,v2;
    switch(t)
    {
    case NN:
        N[n1].value*=N[n2].value;
        break;
    case NF:
        ToNumber(n2,FracToDouble(n2));
        N[n1].value*=N[n2].value;
        break;
    case FN:
        ToNumber(n1,FracToDouble(n1));
        N[n1].value*=N[n2].value;
        break;
    case FF:
        a1=N[n1].a; a2=N[n2].a;
        v1=N[n1].value;
        v2=N[n2].value;
        if(a1==0.0 && a2==0.0)
        {
            N[n1].value=v1*v2;
            if(N[n1].value>max_int)
                ToNumber(n1,N[n1].value);
            break;
        }
        s=std::signbit(v1)^std::signbit(v2);
        b1=N[n1].b; v1=abs(v1);
        b2=N[n2].b; v2=abs(v2);
        if(a1==0.0)
        {
            a=(v1)*(v2*b2+a2);
            b=b2;
        } else if(a2==0.0) {
            a=(v1*b1+a1)*(v2);
            b=b1;
        } else {
            a=(v1*b1+a1)*(v2*b2+a2);
            b=b1*b2;
        }
        if(a>max_int || b>max_int)
        {
            if(s) a*=-1;
            ToNumber(n1,a/b);
        } else {
            N[n1].value=0.0;
            if(s) N[n1].value*=-1.0;
            CancelDbl(a,b);
            N[n1].a=a;
            N[n1].b=b;
            CancelFrac(n1);
        }
        break;
    }
    N[n1].sign*=N[n2].sign;
    Free(n2);
}
bool Exp::SimplyTimes(int node)
{
    bool changed=false;
    int i,j,nl,ct,c,d,c0,d0,c1,d1,nd1,n,nn,count,q;
    double sign;
    bool found=false;
    QList<int> links;
    bool has_numbers=false;
    bool has_times=false;
    bool has_devide=false;
    bool has_brackets=false;
    bool has_other=false;
    sign=N[node].sign; N[node].sign=1;
    nl=N[node].links.count();
    for(i=0; i<nl; i++)
    {
        c=N[node].links[i];
        changed|=simplifyN(c);
        if(N[c].type==Plus)
            InsertRBracket(c,1);
        sign*=N[c].sign;
        N[c].sign=1;
        if(ERROR!="") goto TimesEnd;
    }
    if(changed)
        goto TimesEnd;

    links=N[node].links;
    N[node].links.clear();
    nl=links.count();
    for(i=0; i<nl; i++)
    {
        c=links[i];
        ct=N[c].type;
        switch(ct)
        {
        case Number:
            if(N[c].value==0.0)
            {
                ToNumber(node,0.0);
                for(i=0; i<nl; i++) Free(links[i]);
                return true;
            }
            has_numbers=true;
            break;
        case Frac:
            if(N[c].value==0.0 && N[c].a==0)
            {
                ToNumber(node,0.0);
                return true;
            }
            has_numbers=true;
            break;
        case Times:
            has_times=true;
            break;
        case Devide:
            has_devide=true;
            break;
        case RBracket:
            if(N[c].text=="()")
                has_brackets=true;
            else
                has_other=true;
            break;
        default:
            has_other=true;
        }
        N[node].links.append(c);
    }
    if(N[node].links.count()<2)
        goto TimesEnd;

    if(has_numbers)
    {
        links=N[node].links;
        N[node].links.clear();
        nl=links.count();
        for(i=0; i<nl; i++)
        {
            c=links[i];
            if(N[c].value==1.0 && N[c].sign==1 &&
                (N[c].type==Number ||
                    (N[c].type==Frac && N[c].a==0)))
            {
                links.removeOne(c);
                Free(c);
                changed=true;
                N[node].links=links;
                goto TimesEnd;
            }
        }

        // multiply numbers and fractions
        found=false;
        n=-1;
        for(i=0; i<nl; i++)
        {
            c=links[i];
            ct=N[c].type;
            // find an accumulator node;
            if(ct!=Number && ct!=Frac)
            {// skip non numbers/fracs
                Adopt(node,c);
                continue;
            }
            if(!found)
            {
                found=true;
                n=c;
                continue;
            }
            MulEr(n,c);
            changed=true;
        }
        if(n!=-1)
            Adopt(node,n);
        if(changed) goto TimesEnd;
    }

    if(has_times)
    {
        links=N[node].links;
        N[node].links.clear();
        nl=links.count();
        // remove nested * a*|b*c|*d etc.
        for(i=0; i<nl; i++)
        {
            c=links[i];
            ct=N[c].type;
            if(ct==Times)
            {
                nn=N[c].links.count();
                for(j=0; j<nn; j++)
                    N[node].links.append(N[c].links[j]);
                N[c].links.clear();
                Free(c);
                changed=true;
            } else
                N[node].links.append(c);
        }
        if(changed) goto TimesEnd;
    }

    if(has_brackets)
    {
        links=N[node].links;
        N[node].links.clear();
        nl=links.count();
        // expand a*(b+c)
        c=NewN(Times,2,MAX_LINKS,LTimes,1,0,0,0,"*",Infix);
        d=NewN(Times,2,MAX_LINKS,LTimes,1,0.0,0,0,"*",Infix);
        for(i=0; i<nl; i++)
        {
            n=links[i];
            if(N[n].text=="()")
            {
                nn=N[n].links[0];
                if(N[nn].type==Plus)
                    Adopt(d,n);
                else
                    Adopt(c,n);
            } else {
                Adopt(c,n);
            }
        }
        if(N[d].links.count())
        {
            d0=N[d].links.takeLast(); // (b+c)
            d1=N[d0].links.takeLast(); // b+c
            Free(d0);
            N[c].links.append(N[d].links); // a
            if(N[c].links.count()==1)
                Over(c,N[c].links[0]);
            N[d].links.clear();
            Free(d);
            nd1=N[d1].links.count();
            for(i=0; i<nd1; i++)
            {
                n=N[d1].links.takeFirst(); // b...
                nn=AdoptTimes(d1,1); // will go last
                Adopt(nn,n); // d1=c+b*
                Adopt(nn,Copy(c)); // d1=c+b*a
            }
            Over(node,d1);
            Free(c);
            changed=true;
        } else {
            Free(d);
            Over(node,c);
        }
        if(changed) goto TimesEnd;
    }

    if(has_devide)
    {
        // Collect devides together
        links=N[node].links;
        N[node].links.clear();
        nl=links.count();
        count=0;
        for(i=0; i<nl; i++)
            if(N[links[i]].type==Devide)
                count++;
        if(count>1)
        {
            ToDevide(node,1);
            c=AdoptTimes(node,1);
            d=AdoptRBracket(node,1);
            d=AdoptTimes(d,1);
            for(i=0; i<nl; i++)            {
                n=links[i];
                if(N[n].type!=Devide)
                {
                    Adopt(c,n);
                    continue;
                }
                Adopt(c,N[n].links[0]);
                Adopt(d,N[n].links[0]); // [1] has moved down
                Free(n);
            }
            changed=true;
        } else if(count==1) {
            ToDevide(node,1);
            c=AdoptTimes(node,1);
            d=AdoptRBracket(node,1);
            for(i=0; i<nl; i++)
            {
                n=links[i];
                if(N[n].type!=Devide)
                {
                    Adopt(c,n);
                    continue;
                }
                Adopt(c,N[n].links[0]);
                Adopt(d,N[n].links[0]); // [1] has moved down
                Free(n);
                changed=true;
            }
        } else N[node].links=links;
        if(changed) goto TimesEnd;
    }
    if(has_other)
    {
        links=N[node].links;
        N[node].links.clear();
        nl=links.count();
        // give everything a power
        for(i=0; i<nl; i++)
        {
            c=links[i];
            if(N[c].type!=Power)
            {
                n=NewN(Power,2,2,LPower,1,N[c].value,0,0,"^",Infix);
                nn=NewN(Number,0,0,LLeaf,1,1.0,0,0,"Number",Nofix);
                Adopt(n,c);
                Adopt(n,nn);
                links[i]=n;
            }
        }
        // search for powers of same thing
repeat: i=0;
        nl=links.count();
        while(i<nl-1)
        {
            c=links[i];
            c0=N[c].links[0];
            j=i+1;
            while(j<nl)
            {
                d=links[j];
                d0=N[d].links[0];
                q=CompareNs(c0,d0,true);
                if(q==0)
                {
                    c1=N[c].links[1];
                    d1=N[d].links[1];
                    if(N[c1].text!="()")
                        InsertRBracket(c1,1);
                    n=N[c1].links[0];
                    if(N[n].type!=Plus)
                        InsertPlus(n);
                    Adopt(n,Copy(d1));
                    Free(d);
                    links.removeOne(d);
                    changed=true;
                    goto repeat;
                }
                j++;
            }
            i++;
        }
        nl=links.count();
        if(nl)
        {
            for(i=0; i<nl; i++)
                Adopt(node,links[i]);
        }
        // change a^1 back to a
        links=N[node].links;
        N[node].links.clear();
        nl=links.count();
        for(i=0; i<nl; i++)
        {
            c=links[i]; // a^1
            if(N[c].type==Power)
            {
                d=N[c].links[1]; // 1
                switch(N[d].type) // number
                {
                case Number:
                    if(N[d].value==1.0 && N[d].sign==1) // need to drop ^1
                    {
                        n=N[c].links.takeFirst(); // a
                        Free(c);
                        Adopt(node,n);
                    } else Adopt(node,c);
                    continue;
                case Frac:
                    if(N[d].value==1.0 && N[d].a==0 && N[d].sign==1)
                    {
                        n=N[c].links.takeAt(0);
                        Free(c);
                        Adopt(node,n);
                    } else Adopt(node,c);
                    continue;
                default:
                    break;
                }
            }
            Adopt(node,c);
        }
    }

TimesEnd:
    // make sure at least 2 links, else overwrite
    nl=N[node].links.count();
    if(nl==1)
    {
        c=N[node].links[0];
        N[c].sign*=sign;
        Over(node,c);
        return true;
    }
    // apply sign
    if(N[node].type!=Plus)
        N[node].sign*=sign;
    else {
        for(i=0; i<nl; i++)
            N[N[node].links[i]].sign*=sign;
    }
    Sort(node);
    return changed;
}
void Exp::DevEr(int n1,int n2)
{
    int t=0;
    if(N[n1].type==Frac) t+=2;
    if(N[n2].type==Frac) t+=1;
    double a,b,a1,b1,a2,b2,v1,v2;
    switch(t)
    {
    case NN:
        N[n1].value/=N[n2].value;
        N[n1].sign*=N[n2].sign;
        break;
    case NF:
        ToNumber(n2,FracToDouble(n2));
        N[n1].value/=N[n2].value;
        N[n1].sign*=N[n2].sign;
        break;
    case FN:
        ToNumber(n1,FracToDouble(n1));
        N[n1].value/=N[n2].value;
        N[n1].sign*=N[n2].sign;
        break;
    case FF:
        a1=N[n1].a; b1=N[n1].b; v1=N[n1].value;
        a2=N[n2].a; b2=N[n2].b; v2=N[n2].value;
        if(v1>0 && a1==0)
            {v1-=1; a1=1; b1=1;}
        if(v2>0 && a2==0)
            {v2-=1; a2=1; b2=1;}
        a=(v1*b1+a1)*b2;
        b=b1*(v2*b2+a2);
        if(abs(a)>max_int || b>max_int)
        {
            ToNumber(n1,a/b);
            N[n1].sign*=N[n2].sign;
            break;
        }
        CancelDbl(a,b);
        N[n1].value=0.0;
        N[n1].a=a;
        N[n1].b=b;
        CancelFrac(n1);
        N[n1].sign*=N[n2].sign;
        break;
    }
    Free(n2);
}
bool Exp::SimplyDevide(int node)
{
    bool changed=false;
    int c,cc,d,dd,nc,nd,n,n0,n1,a,b,tc,td,i,j;
    QList<int> links;
    QString e1,e2;
    c=N[node].links[0];
    d=N[node].links[1];
    changed|=simplifyN(c);
    if(ERROR!="") return true;
    changed|=simplifyN(d);
    if(ERROR!="") return true;
    if(changed) return true;

    int sign=N[node].sign; N[node].sign=1;
    links=N[node].links;
    N[node].links.clear();
    c=links[0]; sign*=N[c].sign; N[c].sign=1;
    tc=N[c].type;
    d=links[1]; sign*=N[d].sign; N[d].sign=1;
    td=N[d].type;

    if(N[c].value<eps)
    {
        if(N[c].type==Number)
        {
            ToNumber(node,0.0);
            Free(c);
            Free(d);
            return true;
        }
        if(N[c].type==Frac && N[c].a==0)
        {
            ToNumber(node,0.0);
            Free(c);
            Free(d);
            return true;
        }
    }
    if(N[d].value<eps)
    {
        if(N[d].type==Number)
        {
            ERROR="Devision by 0";
            return true;
        }
        if(N[d].type==Frac && N[c].a==0)
        {
            ERROR="Devision by 0";
            return true;
        }
    }

    // a==a
    if(CompareNs(c,d,true)==0)
    {
        Free(c);
        Free(d);
        ToNumber(node,sign);
        return true;
    }

    if(N[c].max==0 && N[d].max==0)
    {
        if(tc==Number || tc==Frac) // c number
        {
            // do calculations
            if(td==Number || td==Frac) // d number
            {
                DevEr(c,d);
                if(ERROR!="") return true;
                N[c].sign*=sign;
                Over(node,c);
                if(ERROR!="") return true;
                return true;
            } // c number d not
            goto finish;
        } // c not number d might be
        if(td==Number || td==Frac) // d number
        { // c*1/d
            InsertTimes(c,1);
            InsertDevide(d,1);
            AdoptNumber(d,1.0);
            SwapLinks(d,0,1);
            Adopt(c,d);
            Over(node,c);
            N[node].sign=sign;
            return true;
        }
        goto finish;
    }

    // expand (a+...)/b to a/b+...
    if(N[c].text=="()")
    {
        cc=N[c].links[0];
        if(N[cc].type==Plus)
        {
            ToPlus(node);
            nc=N[cc].links.count();
            for(i=0; i<nc; i++)
            {
                n=N[cc].links.takeFirst();
                Adopt(node,n);
                InsertDevide(n,sign);
                Adopt(n,Copy(d));
            }
            Free(c);
            Free(d);
            return true;
        }
    }

    if(N[d].text=="()"
        && N[N[d].links[0]].type==Times)
    {
        dd=N[d].links[0];
        // move number to c
        int dd0=N[dd].links[0];
        if(N[dd0].type==Number)
        {
            double v=ValueOf(dd0);
            Free(dd0);
            switch(tc)
            {
            case Number:
                N[c].value/=v;
                break;
            case Frac:
                N[c].value/=v;
                MakeFrac(c);
                break;
            case Times:
                AdoptTimes(c,1.0/v);
                break;
            default:
                InsertTimes(c,1);
                AdoptNumber(c,1.0/v);
                break;
            }
            changed=true;
            goto finish;
        }
        // a.../(a...)
        if(CompareNs(c,dd,true)==0)
        {
            Free(c);
            Free(d);
            ToNumber(node,sign);
            return true;
        }
        td=N[dd].type;
        if(td==Times)
        { // check for a/ab...
            if(N[c].max==0 || tc==RBracket)
            {
                nd=N[dd].links.count();
                for(i=0; i<nd; i++)
                {
                    n=N[dd].links[i];
                    if(CompareNs(c,n,true)==0)
                    {
                        ToNumber(c,1);
                        Free(n);
                        if(nd==2)
                            Over(d,N[dd].links[0]);
                        Adopt(node,c);
                        Adopt(node,d);
                        N[node].sign=sign;
                        return true;
                    }
                }
                goto finish;
            }
            // check for abc.../def...
            if(tc==Times) // already checked d is
            {
                nc=N[c].links.count();
                nd=N[dd].links.count();
                for(j=0; j<nc; j++)
                {
                    n0=N[c].links[j];
                    for(i=0; i<nd; i++)
                    {
                        n1=N[dd].links[i];
                        if(CompareNs(n0,n1,true)==0)
                        {
                            Free(n0);
                            if(nc==2)
                                Over(c,N[c].links[0]);
                            Free(n1);
                            if(nd==2)
                                Over(d,N[dd].links[0]);
                            Adopt(node,c);
                            Adopt(node,d);
                            N[node].sign=sign;
                            return true;
                        }
                    }
                }
            }
        }
    }

    if(tc==Times)
    {
        // check for numbers to cancel
        if(td==Number)
        {
            nc=N[c].links.count();
            for(i=0; i<nc; i++)
            {
                n=N[c].links[i];
                if(N[n].type==Number)
                {
                    double v=N[n].value/N[d].value;
                    Free(d);
                    ToNumber(n,v);
                    Over(node,c);
                    N[node].sign=sign;
                    return true;
                }
            }
        }
        // check for ab..../a
        if(N[d].max==0 || td==RBracket)
        {
            e1=ExpText(d);
            nc=N[c].links.count();
            for(i=0; i<nc; i++)
            {
                n=N[c].links[i];
                e2=ExpText(n);
                if(e1==e2)
                {
                    Free(n);
                    if(nc==2)
                        Over(c,N[c].links[0]);
                    Free(d);
                    Over(node,c);
                    N[node].sign=sign;
                    return true;
                }
            }
        }
    }

    // a/b/c etc.
    if(tc==Devide)
    {
        b=N[c].links[1];
        b=InsertRBracket(b,1);
        InsertTimes(b,1);
        Adopt(b,d);
        Over(node,c);
        N[node].sign=sign;
        return true;
    }
    if(td==Devide)
    {
        b=N[d].links.takeLast();
        a=N[d].links.takeLast();
        Free(d);
        Adopt(node,c);
        Adopt(node,a);
        InsertTimes(c,1);
        Adopt(c,b);
        N[node].sign=sign;
        return true;
    }

    // cancel powers
    {
        bool cfree=FreeOf(c,"^",999);
        td=N[d].type;
        if(td==RBracket)
            Over(d,N[d].links[0]);
        td=N[d].type;
        bool dfree=FreeOf(d,"^",2);
        if(!cfree || !dfree)
        {
            int at,bt;
            nc=N[c].links.count();
            if(nc==0) nc=1;
            for(i=0; i<nc; i++)
            {
                if(tc==Times) a=N[c].links[i];
                else a=c;
                at=N[a].type;
                nd=N[d].links.count();
                if(nd==0) nd=1;
                for(j=0; j<nd; j++)
                {
                    if(td==Times) b=N[d].links[j];
                    else b=d;
                    bt=N[b].type;
                    if(at==Power)
                    {
                        if(bt==Power)
                        { // a and b ^
                            if(N[N[a].links[0]].text==N[N[b].links[0]].text)
                            { // powers of same thing
                                n=InsertRBracket(N[a].links[1],1);
                                InsertPlus(n);
                                N[N[b].links[1]].sign*=-1;
                                Adopt(n,N[b].links[1]);
                                ToNumber(b,1);
                                changed=true;
                            }
                        } else { // a^
                            if(N[N[a].links[0]].text==N[b].text)
                            { // power and factor
                                n=InsertRBracket(N[a].links[1],1);
                                InsertPlus(n);
                                AdoptNumber(n,-1);
                                ToNumber(b,N[b].sign);
                                changed=true;
                            }
                        }
                    } else if(bt==Power)
                    { // b ^
                        if(N[a].text==N[N[b].links[0]].text)
                        { // factor and power
                            n=InsertRBracket(N[b].links[1],1);
                            InsertPlus(n);
                            AdoptNumber(n,-1);
                            ToNumber(a,N[a].sign);
                            changed=true;
                        }
                    }
                }
            }
        }
    }
finish:
    if(d!=-1 && N[d].parent==-1) d=-1;
    if(d!=-1 && !(N[d].fix==Nofix || N[d].level==LBracket))
        InsertRBracket(d,1);
    if(N[c].type==RBracket)
    {
        int c0=N[c].links[0];
        if(N[c0].type==Times)
        {
            int n=N[c0].links.count();
            if(n<2)
            {
                if(n==0)
                    ToNumber(c,1.0);
                if(n==1)
                    Over(c,N[c0].links[0]);
                changed=true;
            }
        }
    }
    if(d!=-1 && N[d].min>0 && N[d].links.count()==0)
    {
        changed=true;
        Free(d);
        d=-1;
    }
    if(d!=-1)
    {
        if(N[d].type==RBracket)
        {
            int d0=N[d].links[0];
            if(N[d0].type==Times)
            {
                int n=N[d0].links.count();
                if(n<2)
                {
                    if(n==0)
                        ToNumber(d,1.0);
                    if(n==1)
                        Over(d,N[d0].links[0]);
                    changed=true;
                }
            }
        }
        sign=N[c].sign*N[d].sign*sign;
        N[c].sign=1;
        N[d].sign=1;
        if(N[d].type==Number && N[d].value==1.0 && N[d].a==0)
        {
            Over(node,c);
            Free(d);
            changed=true;
        }else {
            Adopt(node,c);
            Adopt(node,d);
        }
    } else Over(node,c);

    N[node].sign=sign;
    return changed;
}
void Exp::PowEr(int n1,int n2)
{
    int t=0;
    if(N[n1].type==Frac) t+=2;
    if(N[n2].type==Frac) t+=1;
    switch(t)
    {
    case NN:
        N[n1].value=
            pow(N[n1].value*N[n1].sign,
            N[n2].value*N[n2].sign);
        break;
    case NF:
        ToNumber(n2,FracToDouble(n2));
        N[n1].value=
            pow(N[n1].value*N[n1].sign,
            N[n2].value);
        break;
    case FN:
        ToNumber(n1,FracToDouble(n1));
        N[n1].value=
            pow(N[n1].value,
            N[n2].value*N[n2].sign);
        break;
    case FF:
        ToNumber(n1,FracToDouble(n1));
        ToNumber(n2,FracToDouble(n2));
        N[n1].value=pow(N[n1].value,N[n2].value);
        MakeFrac(n1);
        break;
    }
    Free(n2);
}
bool Exp::SimplyPower(int node)
{
    if(N[node].sign==-1)
    {
        N[node].sign=1;
        InsertRBracket(node,-1);
        return true;
    }
    bool changed=false;
    int c,cc,d,ct,dt,n;
    QList<int> links;
    c=N[node].links[0];
    changed|=simplifyN(c);
    if(ERROR!="") return true;
    d=N[node].links[1];
    changed|=simplifyN(d);
    if(ERROR!="") return true;
    if(changed) return true;
    links=N[node].links;
    N[node].links.clear();
    c=links[0];
    ct=N[c].type;
    d=links[1];
    dt=N[d].type;

    // numeric calculation
    if((ct==Number || ct==Frac) && (dt==Number || dt==Frac))
    {
        double cv=N[c].value;
        if(N[c].sign==-1)
        {
            Free(c);
            double dv=N[d].value*N[d].sign; Free(d);
            int di=(int)dv;
            if(di!=dv)
            {
                double df=dv-di;
                cv=std::pow(cv,dv);
                AdoptNumber(node,-1.0);
                AdoptNumber(node,df);
                int p=N[node].parent;
                if(N[p].type!=RBracket)
                {
                    InsertRBracket(node,1);
                    changed=true;
                }
                if(cv!=1.0)
                {
                    InsertTimes(node,1);
                    AdoptNumber(node,cv);
                    SwapLinks(node,0,1);
                }
                return changed;
            }
            ToNumber(node,std::pow(-cv,dv));
            return true;
        }
        PowEr(c,d);
        if(ERROR!="") return true;
        Over(node,c);
        return true;
    }

    if(ct==Number || ct==Frac)
    {
        // 0^anything
        if(N[c].value==0.0 &&
            ((ct==Number) ||
            (ct==Frac && N[c].a==0)))
        {
            ToNumber(node,0.0);
            Free(c);
            Free(d);
            return true;
        }
        // 1^anything
        if(N[c].value==1.0 && N[c].sign==1 &&
            ((ct==Number) ||
            (ct==Frac && N[c].a==0)))
        {
            ToNumber(node,1);
            Free(c);
            Free(d);
            return true;
        }
    }

    if(dt==Number || dt==Frac)
    {
        // anything^0
        if((dt==Number && N[d].value==0.0) ||
            (dt==Frac && N[d].value==0.0 && N[d].a==0))
        {
            ToNumber(node,1.0);
            Free(c);
            Free(d);
            return true;
        }
        // anything^1
        if((dt==Number && N[d].value==1.0) || (dt==Frac && N[d].value==1.0 && N[d].a==0))
        {
            if(N[d].sign==1)
            {
                Over(node,c);
                N[node].sign=1;
                Free(d);
                return true;
            }
        }
    }

    // change a^ -b into 1/a^b
    if(N[d].sign<0)
    {
        n=InsertDevide(node,1);
        AdoptNumber(node,1.0);
        SwapLinks(node,0,1);
        Adopt(n,c);
        N[d].sign=1;
        Adopt(n,d);
        return true;
    }

    if(N[c].text=="()" || ct==Times)
    {
        int p=N[c].links[0];
        if(ct==Times)
            p=c;
        if(N[p].type==Times)
        {
            int i,nl=N[p].links.count();
            for(i=0; i<nl; i++)
            {
                int cc=N[p].links[0];
                int ccc=InsertPower(cc,(int)N[c].value);
                Adopt(ccc,d);
            }
            Over(node,c);
            return true;
        }
        if(dt==Number && IsInt(d))
        {
            cc=N[c].links[0];
            if(N[cc].type==Plus)
            {
                // expand +ve int powers
                if(N[d].sign==1)
                {
                    cc=Copy(c);
                    Adopt(node,c);
                    Adopt(node,d);
                    InsertTimes(node,1);
                    Adopt(node,cc);
                    N[d].value-=1.0;
                    return true;
                }
                // turn ^- into /
                N[d].sign=1;
                Adopt(node,c);
                Adopt(node,d);
                InsertDevide(node,1);
                AdoptNumber(node,1.0);
                SwapLinks(node,0,1);
                return true;
            }
        }
    }

    Adopt(node,c);
    Adopt(node,d);
    // change -a^b into (-a)^b
    if(N[c].sign==-1 && N[c].type!=RBracket)
    {
        InsertRBracket(c,1);
        return true;
    }

    return changed;
}
bool Exp::SimplyMulti(int node)
{
    Q_UNUSED(node)
    return false;
}
bool Exp::simplifyN(int node)
{
#ifdef QT_DEBUG
qDebug()<<__func__<<ExpText(node);
#endif
    if(ERROR!="") return false;
    bool changed=false;
    if(!UsedNs.contains(node)) return false;
    int t,nl,c,d;
    QList<int> links=N[node].links;
    t=N[node].type;
    nl=N[node].links.count();
#ifdef QT_DEBUG
    if(nl<N[node].min)
    {
        ERROR="\""+N[node].text+"\" has a problem";
        return false;
    }
    if(nl>N[node].max)
    {
        ERROR="\""+N[node].text+"\" has a problem";
        return false;
    }
#endif
    switch(t)
    {
    case Start:
        changed|=SimplyStop(node);
        break;
    case Number:
        changed|=SimplyNumber(node);
        break;
    case Frac:
        changed|=SimplyFrac(node);
        break;
    case Variable:
        changed|=SimplyVar(node);
        break;
    case Plus:
        changed|=SimplyPlus(node);
        break;
    case Times:
        changed|=SimplyTimes(node);
        break;
    case Devide:
        changed|=SimplyDevide(node);
        break;
    case Power:
        changed|=SimplyPower(node);
        break;
    case RBracket:
        changed|=SimplyBracket(node);
        break;
    case RCBracket:
        c=links[0];
        changed|=simplifyN(c);
        break;
    case CBracket:
        break;
    case CRBracket:
        d=links[1];
        changed|=simplifyN(d);
        break;
    case CRCBracket:
        d=links[1];
        changed|=simplifyN(d);
        break;
    case SCBracket:
        c=links[0];
        changed|=simplifyN(c);
        break;
    case CSBracket:
        d=links[1];
        changed|=simplifyN(d);
        break;
    case RSBracket:
        c=links[0];
        changed|=simplifyN(c);
        if(ERROR!="") break;
        d=links[1];
        changed|=simplifyN(d);
        break;
    case SRBracket:
        c=links[0];
        changed|=simplifyN(c);
        if(ERROR!="") break;
        d=links[1];
        changed|=simplifyN(d);
        break;
    case SBracket:
        c=links[0];
        changed|=simplifyN(c);
        break;
    case Excl:
    case Not:
    case Dot:
    case At:
    case Tilda:
    case Question:
        c=links[0];
        if(N[c].sign==-1)
        {
            InsertRBracket(c,1);
            changed=true;
        }
        if(N[node].fix==Postfix)
        {
            if(N[node].sign==-1)
            {
                InsertRBracket(node,-1);
                N[node].sign=1;
                changed=true;
            }
        }
qDebug()<<__func__<<ExpText(node);
        changed|=simplifyN(c);
qDebug()<<__func__<<ExpText(node);
        break;
    case MultiOp:
        changed|=SimplyMulti(node);
        break;
    default:
        changed|=SimplyDefault(node);
        if(ERROR!="") break;
    }
    if(ERROR!="") return true;
    return changed;
}
bool Exp::DoCallbacks()
{
    if(ERROR!="") return false;
    int ni,i,in,t,key,b,c,d;
    bool changed=false;
    bool (*opfun)(Exp*,int,bool);
    int opfuns=OPFuns.count();
    bool (*ffun)(Exp*,int,int,NodeType,bool);
    int rfuns=RFuns.count();
    int cfuns=RFuns.count();
    int sfuns=RFuns.count();
    bool (*fffun)(Exp*,int,int,NodeType,int,NodeType,bool);
    int rcfuns=RCFuns.count();
    int rsfuns=RSFuns.count();
    int crfuns=CRFuns.count();
    int csfuns=CSFuns.count();
    int srfuns=SRFuns.count();
    int scfuns=SCFuns.count();
    bool (*ffffun)(Exp*,int,int,NodeType,int,NodeType,int,NodeType,bool);
    int crcfuns=CRCFuns.count();
    bool (*ppfun)(Exp*,int,bool,int,NodeType,bool);
    int ppfuns=PPFuns.count();

    ni=FoundNs.count();
    for(i=0; i<ni; i++)
    {
        in=FoundNs[i];
        t=N[in].type;
        switch(t)
        {
        case Variable:
            if(Var==0) break;
            if(Variables.count()==0) break;
            key=Variables.value(N[in].text,unknown_key);
            if(key!=unknown_key)
                changed|=Var(this,in,key,false);
            break;
        case Plus:
            if(opfuns==0) break;
            opfun=OPFuns.value(N[in].text,0);
            if(opfun)
                changed|=opfun(this,in,false);
            break;
        case Times:
            if(opfuns==0) break;
            opfun=OPFuns.value(N[in].text,0);
            if(opfun)
                changed|=opfun(this,in,false);
            break;
        case Devide:
            if(opfuns==0) break;
            opfun=OPFuns.value(N[in].text,0);
            if(opfun)
                changed|=opfun(this,in,false);
            break;
        case Power:
            if(opfuns==0) break;
            opfun=OPFuns.value(N[in].text,0);
            if(opfun)
                changed|=opfun(this,in,false);
            break;
        case RBracket:
            if(rfuns==0) break;
            ffun=RFuns.value(N[in].text,0);
            if(ffun)
            {
                c=N[in].links[0];
                changed|=ffun(this,in,c,N[c].type,false);
            }
            break;
        case RCBracket:
            if(rcfuns==0) break;
            fffun=RCFuns.value(N[in].text,0);
            if(fffun)
            {
                c=N[in].links[0];
                d=N[in].links[1];
                changed|=fffun(this,in,c,N[c].type,d,N[d].type,false);
            }
            break;
        case CBracket:
            if(cfuns==0) break;
            ffun=CFuns.value(N[in].text,0);
            if(ffun)
            {
                c=N[in].links[0];
                changed|=ffun(this,in,c,N[c].type,false);
            }
            break;
        case CRBracket:
            if(crfuns==0) break;
            fffun=RCFuns.value(N[in].text,0);
            if(fffun)
            {
                c=N[in].links[0];
                d=N[in].links[1];
                changed|=fffun(this,in,c,N[c].type,d,N[d].type,false);
            }
            break;
        case CRCBracket:
            if(crcfuns==0) break;
            ffffun=CRCFuns.value(N[in].text,0);
            if(ffffun)
            {
                b=N[in].links[0];
                c=N[in].links[1];
                d=N[in].links[2];
                changed|=ffffun(this,in,b,N[b].type,c,N[c].type,d,N[d].type,false);
            }
            break;
        case SCBracket:
            if(scfuns==0) break;
            fffun=RCFuns.value(N[in].text,0);
            if(fffun)
            {
                c=N[in].links[0];
                d=N[in].links[1];
                changed|=fffun(this,in,c,N[c].type,d,N[d].type,false);
            }
            break;
        case CSBracket:
            if(csfuns==0) break;
            fffun=RCFuns.value(N[in].text,0);
            if(fffun)
            {
                c=N[in].links[0];
                d=N[in].links[1];
                changed|=fffun(this,in,c,N[c].type,d,N[d].type,false);
            }
            break;
        case RSBracket:
            if(rsfuns==0) break;
            fffun=RCFuns.value(N[in].text,0);
            if(fffun)
            {
                c=N[in].links[0];
                d=N[in].links[1];
                changed|=fffun(this,in,c,N[c].type,d,N[d].type,false);
            }
            break;
        case SRBracket:
            if(srfuns==0) break;
            fffun=RCFuns.value(N[in].text,0);
            if(fffun)
            {
                c=N[in].links[0];
                d=N[in].links[1];
                changed|=fffun(this,in,c,N[c].type,d,N[d].type,false);
            }
            break;
        case SBracket:
            if(sfuns==0) break;
            ffun=SFuns.value(N[in].text,0);
            if(ffun)
            {
                c=N[in].links[0];
                changed|=ffun(this,in,c,N[c].type,false);
            }
            break;
        case Excl:
        case Not:
        case Dot:
        case At:
        case Tilda:
        case Question:
        {
            if(ppfuns==0) break;
            bool pre=false; if(N[in].fix==Prefix) pre=true;
            ppfun=PPFuns.value(N[in].text,0);
            if(ppfun)
            {
                c=N[in].links[0];
                changed|=ppfun(this,in,pre,c,N[c].type,false);
            }
            break;
        }
        default:
            if(opfuns==0) break;
            opfun=OPFuns.value(N[in].text,0);
            if(opfun)
                changed|=opfun(this,in,false);
        }
        if(changed && ERROR=="") return true;
    }
    return false;
}
void Exp::FindNodes(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In FindNodes";
        return;
    }
#endif
    int n=N[node].links.count(),i;
    FoundNs.append(node);
    if(n) for(i=0; i<n; i++)
        FindNodes(N[node].links[i]);
}
int Exp::GetSize(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In GetSize";
        return -1;
    }
#endif
    FoundNs.clear();
    FindNodes(node);
    return FoundNs.count();
}
int Exp::GetRoot(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In GetRoot";
        return -1;
    }
#endif
    return N[node].root;
}
void Exp::Simplify(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In Simplify";
        return;
    }
    if(!UsedNs.contains(node))
    {
        ERROR="No such Node";
        return;
    }
#endif
    if(ERROR!="") return;
    bool changed=false;

    changed=true;
    while(changed && UsedNs.count()>1)
    {
        changed=simplifyN(node);
        if(ERROR!="")
        {
            Free(node);
            while(AN.last()!=MyRoot) AN.takeLast();
            an=MyRoot;
            ERROR.replace("\"+\"","\"+/-\"");
            int n=NewN(Error,0,0,LLeaf,1,0.0,__LINE__,0,ERROR,Nofix);
            AddN(n);
            break;
        }
        if(changed) continue;

        FoundNs.clear();
        FindNodes(node);
        if(FoundNs.count())
            changed=DoCallbacks();
        if(ERROR!="") break;
    }
}

bool Exp::LeafN(NodeType t,QString text,double value,int a,int b)
{
    int n;
    int s=1; if(value<0.0) s=-1;
    if(close_bracket && N[an].level!=LBracket)
    {
        ERROR="Can not have \""+text+"\" after brackets";
        return false;
    }
    if(t==Hash && N[last_added].fix==Nofix)
    {
        ERROR="\""+text+"\" not allowed after \""+N[last_added].text+"\"";
        return false;
    }
    if(N[last_added].type==Hash)
    {
        ERROR="\""+N[last_added].text+"\" not allowed before \""+text+"\"";
        return false;
    }
    n=NewN(t,0,0,LLeaf,s,value,a,b,text,Nofix);
    if(t==Frac)
        CancelFrac(n);
    return(AddN(n));
}
bool Exp::PrePostN(int &i,NodeType t, QString text)
{
    bool postfix=false;
    bool prefix=false;
    TokenType tt;
    int n;
    int j=i-1;
    while(j>0 && tokens[j].typ==tSpace) j--;
    tt=tokens[j].typ;
    switch(tt)
    {
    case tWord:
    case tNumber:
    case tFrac:
    case tCRB:
    case tCCB:
    case tCSB:
        postfix=true;
    default:
        break;
    }
    j=i+1;
    while(j<tokens.count()-1 && tokens[j].typ==tSpace) j++;
    tt=tokens[j].typ;
    bool is_minus=false;
    switch(tt)
    {
    case tMinus:
        is_minus=true;
    case tWord:
    case tNumber:
    case tFrac:
    case tOCB:
    case tORB:
    case tOSB:
        prefix=true;
    default:
        break;
    }
    if((!prefix && !postfix) || (prefix && postfix))
    {
        ERROR="Problem with Prefix or Postfix operator \""+text+"\"";
        return false;
    }
    int parent=N[last_added].parent;
    if(parent!=-1 && N[parent].text=="()" && N[last_added].sign==1)
    {
        N[last_added].sign=N[parent].sign;
        Over(parent,last_added);
        last_added=parent;
        parent=N[last_added].parent;
    }
    if(prefix)
    {
        if(is_minus)
        {
            n=NewN(RBracket,1,1,LBracket,1,1.0,0,0,"()",Groupfix);
            AddN(n);
        }
        n=NewN(t,1,1,LPrefix,1,1.0,0,0,text,Prefix);
        AddN(n);
        return true;
    }
    bool has_bracket=false;
    if(N[parent].level==LBracket)
        has_bracket=true;
    int root=N[last_added].root;
    int p=Copy(last_added);
    if(!has_bracket && N[p].sign==-1)
        InsertRBracket(p,1);
    UsedNs.removeOne(last_added);
    FreeNs.append(last_added);
    n=NewN(t,1,1,LPostfix,1,1.0,0,0,text,Postfix);
    N[n].links.append(p);
    N[n].parent=parent;
    N[n].root=root;
    N[p].parent=n;
    N[p].root=root;
    return true;
}
bool Exp::GroupN(int &i,int nt,NodeType t,QString text,double value)
{
    int n;
    int s=1; if(value<0) s=-1;
    if(N[last_added].type==Variable)
    {
        text=N[last_added].text+text;
        s=N[last_added].sign;
        Free(last_added);
    }
    if(N[last_added].type==Number)
    {
        ERROR="You can not have \""+N[last_added].text+"\" before \""+text+"\"";
        return false;
    }

    if(text[0]=='(')
    {
        // fractions and ints
        int a=0,b=0;
        double v=0.0;
        if(i<nt-2 &&
            text.length()==2 &&
            tokens[i+1].typ==tNumber &&
            tokens[i+2].typ==tNot &&
            tokens[i+3].typ==tCRB)
        {
            a=0;
            b=0;
            v=tokens[i+1].v;
            i+=3;
            return(LeafN(Frac,"Frac",v,a,b));
        }
        if(i<nt-4 &&
            tokens[i+1].typ==tNot &&
            tokens[i+2].typ==tNumber &&
            tokens[i+3].typ==tDevide &&
            tokens[i+4].typ==tNumber &&
            tokens[i+5].typ==tCRB)
        {
            a=tokens[i+2].v;
            b=tokens[i+4].v;
            v=0.0;
            i+=5;
            return(LeafN(Frac,"Frac",v,a,b));
        }
        if(i<nt-6 &&
            tokens[i+1].typ==tNumber &&
            tokens[i+2].typ==tNot &&
            tokens[i+3].typ==tNumber &&
            tokens[i+4].typ==tDevide &&
            tokens[i+5].typ==tNumber &&
            tokens[i+6].typ==tCRB)
        {
            v=tokens[i+1].v;
            a=tokens[i+3].v;
            b=tokens[i+5].v;
            i+=6;
            return(LeafN(Frac,"Frac",v,a,b));
        }
    }

    n=NewN(t,1,1,LBracket,s,value,0,0,text,Groupfix);
    return(AddN(n));
}
bool Exp::DoubleGroupN(TokenType t,TokenType tt)
{
    while(N[AN.last()].level!=LBracket && an!=MyRoot)
        an=AN.takeLast();
    an=AN.last();
    if(an==MyRoot) return true;
    if(N[an].max>1) return true;
    switch(t)
    {
    case tCRB:
        switch(tt)
        {
        case tOCB:
            N[an].type=RCBracket;
            N[an].min=1;
            N[an].max=2;
            N[an].text+="{}";
            break;
        case tOSB:
            N[an].type=RSBracket;
            N[an].min=1;
            N[an].max=2;
            N[an].text+="[]";
            break;
        default:
            break;
        }
        break;
    case tCCB:
        switch(tt)
        {
        case tORB:
            N[an].type=CRBracket;
            N[an].min=1;
            N[an].max=2;
            N[an].text+="()";
            break;
        case tOSB:
            N[an].type=CSBracket;
            N[an].min=1;
            N[an].max=2;
            N[an].text+="[]";
            break;
        default:
            break;
        }
        break;
    case tCSB:
        switch(tt)
        {
        case tORB:
            N[an].type=SRBracket;
            N[an].min=1;
            N[an].max=2;
            N[an].text+="()";
            break;
        case tOCB:
            N[an].type=SCBracket;
            N[an].min=1;
            N[an].max=2;
            N[an].text+="{}";
            break;
        case tNothing:
        case tStop:
        case tError:
        case tInt:
        case tNumber:
        case tFrac:
        case tQuote:
        case tPlaceHolder:
        case tWord:
        case tMultiOp:
        case tEscape:
        case tSpace:
        case tPlus:
        case tMinus:
        case tTimes:
        case tDevide:
        case tPower:
        case tExcl:
        case tLess:
        case tEqual:
        case tMore:
        case tAnd:
        case tOr:
        case tBack:
        case tNot:
        case tComma:
        case tDot:
        case tSemi:
        case tColon:
        case tDollar:
        case tCRB:
        case tCCB:
        case tOSB:
        case tCSB:
        case tDQuote:
        case tSQuote:
        case tAt:
        case tTilda:
        case tHash:
        case tQuestion:
            break;
        default:
            break;
        }
        break;
    default:
        break;
    }
    last_added=an;
    return true;
}
bool Exp::InfixN(int i,NodeType t,int maxch,Level level,QString text,double value)
{
    int n,nt=tokens.count();
    int s=1; if(value<0.0) s=-1;
    if(i==nt-1 && t!=Comma && t!=Semi)
    {
        ERROR="Trailing \""+text+"\"";
        return false;
    }
    // ignore + after * or ^ /
    int lt=N[last_added].type;
    if(text=='+' && (lt==Times || lt==Power || lt==Devide))
        return true;
    n=NewN(t,2,maxch,level,s,value,0,0,text,Infix);
    return(AddN(n));
}
int Exp::BuildTree()
{
    if(tokens.empty()) return YourRoot;
    int start_uc=UsedNs.count();
    int i,n,nt=tokens.count();
    TokenType t,tt;
    double v;
    QString s;
    for(i=0; i<nt; i++)
    {
        t=tokens[i].typ;
        switch(t)
        {
        case tWord:
            s=tokens[i].s;
            if(!LeafN(Variable,s,0.0,0,0)) return YourRoot;
            break;
        case tNumber:
            v=tokens[i].v;
            if(!LeafN(Number,"Number",v,0,0)) return YourRoot;
            break;
        case tORB: // includes Frac
            if(nt<4) goto ShortError;
            if(!GroupN(i,nt,RBracket,"()",1.0)) return YourRoot;
            break;
        case tOCB:
            if(nt<4) goto ShortError;
            if(!GroupN(i,nt,CBracket,"{}",1.0)) return YourRoot;
            break;
        case tOSB:
            if(nt<4) goto ShortError;
            if(!GroupN(i,nt,SBracket,"[]",1.0)) return YourRoot;
            break;
        case tCRB: case tCCB: case tCSB:
            if(nt<4){ERROR="Error"; break;}
            if(i<nt-1 && tokens[i+1].typ==tWord)
            {
                ERROR="You can not have \""+tokens[i+1].s+"\" after \""+tokens[i].s+"\"";
                return YourRoot;
            }
            if(i>0)
            {
                tt=tokens[i-1].typ;
                if(tt==tORB || tt==tOCB || tt==tOSB)
                {
                    n=NewN(PlaceHolder,0,0,LLeaf,1,1.0,0,0,"",Nofix);
                    AddN(n);
                }
                if(tt==tCRB || tt==tCCB || tt==tCSB)
                {
                    while(close_bracket>0 && an!=MyRoot)
                    {
                        close_bracket--;
                        an=AN.last();
                        while(N[an].level!=LBracket && an!=MyRoot)
                        {
                            AN.takeLast();
                            an=AN.last();
                        }
                        AN.takeLast();
                        an=AN.last();
                        last_added=an;
                        POS.takeLast();
                        pos=POS.last();
                        int ml=N[an].max;
                        int nl=N[an].links.count();
                        if(ml==1 && nl==0)
                        {
                            int ph=NewN(PlaceHolder,0,0,LLeaf,1,0.0,0,0,"...",Nofix);
                            N[an].links.append(ph);
                        } else if(ml==2 && nl==1)
                        {
                            int ph=NewN(PlaceHolder,0,0,LLeaf,1,0.0,0,0,"...",Nofix);
                            N[an].links.append(ph);
                        }
                    }
                }
            }
            if(i<nt-1)
            {
                tt=tokens[i+1].typ;
                if(tt==tORB || tt==tOCB || tt==tOSB)
                {
                    i++;
                    if(!DoubleGroupN(t,tt)) return YourRoot;
                    continue;
                }
            }
            close_bracket++;
            break;
        case tSemi:
            if(nt<5) goto ShortError;
            if(i==0)
                if(!LeafN(PlaceHolder,"",1.0,0,0)) return YourRoot;
            if(!InfixN(i,Semi,MAX_LINKS,LSemi,tokens[i].s,1.0)) return YourRoot;
            if((i>0 && tokens[i-1].typ==tSemi) || i==nt-1)
                if(!LeafN(PlaceHolder,"",1.0,0,0)) return YourRoot;
            break;
        case tComma:
            if(nt<5) goto ShortError;
            if(i==0)
                if(!LeafN(PlaceHolder,"",1.0,0,0)) return YourRoot;
            if(!InfixN(i,Comma,MAX_LINKS,LComma,tokens[i].s,1.0)) return YourRoot;
            if((i>0 && tokens[i-1].typ==tComma) || i==nt-1)
                if(!LeafN(PlaceHolder,"",1.0,0,0)) return YourRoot;
            break;
        case tMinus:
            if(nt<4) goto ShortError;
            if(IsMinus) IsMinus=false;
            else IsMinus=true;
            if(pos==0 && tokens[i+1].typ!=tNothing) break;
            if(N[last_added].level==LBracket) break;
            if(N[last_added].level==LEqual) break;
            if(N[an].level>LPlus &&
                N[last_added].level!=LLeaf &&
                N[last_added].level!=LBracket
            ) break;
        case tPlus:
            if(nt<4) goto ShortError;
            if(pos==0 &&
                (tokens[i-1].typ==tORB ||
                tokens[i-1].typ==tOSB ||
                tokens[i-1].typ==tOCB ||
                tokens[i-1].typ==tNothing))
                break;
            if(!InfixN(i,Plus,MAX_LINKS,LPlus,"+",1.0))
                return YourRoot;
            break;
        case tTimes:
            if(nt<5) goto ShortError;
            if(!InfixN(i,Times,MAX_LINKS,LTimes,tokens[i].s,1.0)) return YourRoot;
            break;
        case tDevide:
            if(nt<5) goto ShortError;
            if(!InfixN(i,Devide,2,LDevide,tokens[i].s,1.0)) return YourRoot;
            break;
        case tPower:
            if(nt<5) goto ShortError;
            if(!InfixN(i,Power,2,LPower,tokens[i].s,1.0)) return YourRoot;
            break;
        case tExcl:
            if(nt==3) goto ShortError;
            if(!PrePostN(i,Excl,tokens[i].s)) return YourRoot;
            break;
        case tNot:
            if(nt==3) goto ShortError;
            if(!PrePostN(i,Not,tokens[i].s)) return YourRoot;
            break;
        case tDot:
            if(nt==3) goto ShortError;
            if(!PrePostN(i,Dot,tokens[i].s)) return YourRoot;
            break;
        case tAt:
            if(nt==3) goto ShortError;
            if(!PrePostN(i,At,tokens[i].s)) return YourRoot;
            break;
        case tTilda:
            if(nt==3) goto ShortError;
            if(!PrePostN(i,Tilda,tokens[i].s)) return YourRoot;
            break;
        case tQuestion:
            if(nt==3) goto ShortError;
            if(!PrePostN(i,Question,tokens[i].s)) return YourRoot;
            break;
        case tDQuote:
            if(!LeafN(DQuote,tokens[i].s,1.0,0,0)) return YourRoot;
            break;
        case tAnd:
            if(nt<5) goto ShortError;
            if(!InfixN(i,And,MAX_LINKS,LAnd,tokens[i].s,1.0)) return YourRoot;
            break;
        case tOr:
            if(nt<5) goto ShortError;
            if(!InfixN(i,Or,MAX_LINKS,LOr,tokens[i].s,1.0)) return YourRoot;
            break;
        case tBack:
            if(nt==3) goto ShortError;
            if(!InfixN(i,Back,MAX_LINKS,LBack,tokens[i].s,1.0)) return YourRoot;
            break;
        case tSQuote:
            if(nt==3) goto ShortError;
            if(!InfixN(i,SQuote,1,LSQuote,tokens[i].s,1.0)) return YourRoot;
            break;
        case tColon:
            if(nt<5) goto ShortError;
            if(!InfixN(i,Colon,2,LEqual,tokens[i].s,1.0)) return YourRoot;
            break;
        case tLess:
            if(nt<5) goto ShortError;
            if(!InfixN(i,Less,2,LEqual,tokens[i].s,1.0)) return YourRoot;
            break;
        case tEqual:
            if(nt<5) goto ShortError;
            if(!InfixN(i,Equal,2,LEqual,tokens[i].s,1.0)) return YourRoot;
            break;
        case tMore:
            if(nt<5) goto ShortError;
            if(!InfixN(i,More,2,LEqual,tokens[i].s,1.0)) return YourRoot;
            break;
        case tPlaceHolder:
            if(nt==3) goto ShortError;
            if(i==0) break;
            if(!LeafN(PlaceHolder,tokens[i].s,1.0,0,0)) return YourRoot;
            break;
        case tMultiOp:
            if(nt<3) goto ShortError;
            if(i==0 ||
                (N[last_added].level<LMultiOp &&
                N[last_added].level!=LBracket))
                    if(!LeafN(PlaceHolder,tokens[i].s,1.0,0,0))
                        return YourRoot;
            if(!InfixN(i,MultiOp,2,LMultiOp,tokens[i].s,1.0)) return YourRoot;
            break;
        case tHash:
            if(nt<3) goto ShortError;
            v=(int)tokens[i].v;
            if(!LeafN(Hash,tokens[i].s,1.0,(int)v,0)) return YourRoot;
            break;
        case tDollar:
            if(nt<3) goto ShortError;
            v=(int)tokens[i].v;
            if(!LeafN(Dollar,tokens[i].s,1.0,(int)v,0)) return YourRoot;
            break;
        default:
            break;
        }
    }
    tokens.clear();
    POS.clear();
    POS.append(0);
    pos=0;
#ifdef QT_DEBUG
qDebug()<<__func__<<ExpText(YourRoot);
#endif
    return YourRoot;
ShortError:
    ERROR="Error in Input";
    return YourRoot;
}

void Exp::CheckBrackets()
{
    int tn=tokens.count();
    QList<int> br;
    for(int i=0; i<tn; i++)
    {
        int t=tokens[i].typ;
        switch(t)
        {
        case tORB: br.append(tORB); break;
        case tOCB: br.append(tOCB); break;
        case tOSB: br.append(tOSB); break;
        case tCRB:
            if(br.empty() || br.last()!=tORB) goto Quit;
            br.takeLast();
            break;
        case tCCB:
            if(br.empty() || br.last()!=tOCB) goto Quit;
            br.takeLast();
            break;
        case tCSB:
            if(br.empty() || br.last()!=tOSB) goto Quit;
            br.takeLast();
        }
    }
    if(br.isEmpty()) return;
Quit:
    ERROR="Brackets Do not Match, or are Unpaired";
}
void Exp::FindNumbers()
{
    int i=0,nt=tokens.count(),j;
    QList<Token> toks;
    Token newt;
    toks.reserve(nt);
    TokenType t;
    QString s;
    double n,f,e,digits,sign;
    double d;
    i=0;
    bool foundE=true;
    while(i<nt)
    {
        f=0; e=0; digits=0; sign=1.0;
        t=tokens[i].typ;
        s=tokens[i].s;
        if(t!=tInt)
        {
            newt.s=s;
            newt.typ=t;
            newt.v=tokens[i].v;
            toks.append(newt);
            i++;
            continue;
        }
        n=s.toInt();
        i++;
        if(i<nt)
        {
            t=tokens[i].typ;
            s=tokens[i].s;
            if(t==tDot)
            {
                i++;
                if(i<nt)
                {
                    t=tokens[i].typ;
                    s=tokens[i].s;
                    if(t==tInt)
                    {
                        i++;
                        f=s.toInt();
                        digits=s.length();
                    } else
                        goto Error;
                }
            }
        }
        if(i<nt)
        {
            t=tokens[i].typ;
            s=tokens[i].s;
            if(s.length() && (s[0]=='E' || s[0]=='e'))
            {
                foundE=false;
                if(s.length()>1)
                {
                    i++;
                    s=s.right(s.length()-1);
                    for(j=0; j<s.length(); j++)
                        if(!s[j].isDigit()) goto Error;
                    e=s.toInt();
                    foundE=true;
                }
                else if(i<nt-1)
                {
                    i++;
                    t=tokens[i].typ;
                    s=tokens[i].s;
                    if(t==tPlus || t==tMinus)
                    {
                        i++;
                        if(t==tMinus)
                            sign=-1.0;
                    }
                    if(i<nt)
                    {
                        t=tokens[i].typ;
                        s=tokens[i].s;
                        if(t==tInt)
                        {
                            i++;
                            e=s.toInt();
                            for(j=0; j<s.length(); j++)
                                if(!s[j].isDigit()) goto Error;
                            foundE=true;
                        } else goto Error;
                    }
                } else goto Error;
            } else if(t==tWord) goto Error;
        }
        if(foundE)
        {
            d=(n+f/(pow(10.0,digits)))*pow(10.0,sign*e);
            newt.v=d;
            newt.s="Number";
            newt.typ=tNumber;
            toks.append(newt);
        } else goto Error;
    }
    tokens=toks;
    return;
Error:
    ERROR="Found a badly formed Number";
    return;
}
bool Exp::MultiOps_test(int i)
{ // return true if tPlaceHolder needed
    int t=tokens[i].typ;
    switch(t)
    {
    case tNothing:
    case tStop:
    case tError:
//    case tInt:
//    case tNumber:
//    case tFrac:
    case tQuote:
//    case tPlaceHolder:
//    case tWord:
//    case tMultiOp:
//    case tEscape:
    case tSpace:
//    case tPlus:
//    case tMinus:
//    case tTimes:
//    case tDevide:
//    case tPower:
//    case tExcl:
    case tLess:
    case tEqual:
    case tMore:
//    case tAnd:
//    case tOr:
//    case tBack:
//    case tNot:
    case tComma:
//    case tDot:
    case tSemi:
    case tColon:
    case tDollar:
//    case tORB:
//    case tCRB:
//    case tOCB:
//    case tCCB:
//    case tOSB:
//    case tCSB:
//    case tDQuote:
//    case tSQuote:
//    case tAt:
//    case tTilda:
    case tHash:
//    case tQuestion:
        return true;
    }
    return false;
}
void Exp::FindMultiOps()
{
    if(OPFuns.isEmpty()) return;
    int i=0,tn=tokens.count();
    QList<Token> toks;
    Token place_holder={"",0.0,tPlaceHolder};
    Token multi_op={"",0.0,tMultiOp};
    TokenType t;
    QString s;
    s="";
    bool exempt=false;
    int start_in=0,start_out=0;
    while(i<tn)
    {
        t=tokens[i].typ;
        exempt=false;
        switch(t)
        {
        case tSpace:
        case tComma:
        case tSemi:
        case tORB:
        case tCRB:
        case tOCB:
        case tCCB:
        case tOSB:
        case tCSB:
        case tDQuote:
        case tHash:
        case tDollar:
            exempt=true;
            break;
        default:
            exempt=false;
        }
        if(t<=tSpace || exempt)
        {
            if(s!="")
            {
                if(s.length()==1)
                    toks+=tokens[start_in];
                else {
                    int l=s.length();
                    while(!OPFuns.contains(s) && l)
                    {
                        s.chop(1);
                        l--;
                        toks.insert(start_out,tokens[start_in+l]);
                    }
                    if(l==1)
                        toks.insert(start_out,tokens[start_in]);
                    if(l>1)
                    {
                        multi_op.s=s;
                        toks.insert(start_out,multi_op);
                        if(start_in==0 || MultiOps_test(start_in-1))
                            toks.insert(start_out,place_holder);
                        else if(MultiOps_test(start_in+s.length()))
                            toks.insert(start_out+1,place_holder);
                    }
                }
            }
            toks+=tokens[i];
            start_out=toks.length();
            s="";
            i++;
            start_in=i;
            continue;
        }
        s+=tokens[i].s;
        i++;
    }
    tokens=toks;
    return;
}
void Exp::FindQuotes()
{
    int i=0,tn=tokens.count();
    QList<Token> toks;
    Token newt;
    TokenType t;
    QString s;
repeat:
    bool inquote=false;
    while(i<tn)
    {
        t=tokens[i].typ;
        if(t!=tDQuote)
        {
            s=tokens[i].s;
            if(!s[0].isSpace())
            {
                newt.s=s;
                newt.typ=t;
                toks.append(newt);
            }
            i++;
            continue;
        }

        s="";
        inquote=true;
        i++;
        if(i==tn) goto Quit;
        while(i<tn)
        {
            t=tokens[i].typ;
            if(t==tDQuote)
            {
                newt.s=s;
                newt.typ=tDQuote;
                toks.append(newt);
                inquote=false;
                i++;
                break;
            }
            s+=tokens[i].s;
            i++;
        }
    }
    if(inquote) goto Quit;
    if(i<tn-1) goto repeat;
    tokens=toks;
    return;
Quit:
    ERROR="Unmatched Quote";
}
void Exp::Tokenize(QString exp)
{
    tokens.clear();
    Token newt;
    newt.typ=tNothing;
    newt.v=0.0;
    newt.s="";
    tokens.append(newt);

    int len=exp.length(),pos=0;
    QChar ch;
    QString token("");
    int number;
    ch=exp[pos]; if(ch.isSpace()) ch=' ';
    while(pos<len)
    {
        number=0;
        token="";

        // get an int
        while(ch.isDigit() && pos<len)
        {
            number++;
            token+=ch;
            pos++;
            if(pos<len){ch=exp[pos]; if(ch.isSpace()) ch=' ';}
        }
        if(number)
        {
            hasnumbers=true;
            newt.s=token;
            newt.typ=tInt;
            tokens.append(newt);
            continue;
        }

        // escape character
        if(ch=="\\" && pos<len-1)
        {
            ch=exp[pos];
            pos++;
            token="\\";
            token+=ch;
            pos++;
            newt.s=token;
            newt.typ=tEscape;
            tokens.append(newt);
            if(pos<len){ch=exp[pos]; if(ch.isSpace()) ch=' ';}
            continue;
        }

        // get a name
        if(ch.isLetter() || ch=='_')
        {
            while((ch.isDigit() || ch.isLetter() || ch=='_') && pos<len)
            {
                number++;
                token+=ch;
                pos++;
                if(pos<len){ch=exp[pos]; if(ch.isSpace()) ch=' ';}
            }
            if(number)
            {
                newt.s=token;
                newt.typ=tWord;
                tokens.append(newt);
                continue;
            }
        }

        // get hash/dollar
        if(ch=="#")
        {
            newt.s=ch;
            newt.typ=tHash;
            newt.v=0.0;
        }
        // get hash/dollar
        if(ch=="$")
        {
            newt.s=ch;
            newt.typ=tDollar;
            newt.v=0.0;
        }
        if(newt.typ==tHash || newt.typ==tDollar)
        {
            pos++;
            if(pos<len){ch=exp[pos]; if(ch.isSpace()) ch=' ';}
            // get an int
            token="";
            while(ch.isDigit() && pos<len)
            {
                number++;
                token+=ch;
                pos++;
                if(pos<len){ch=exp[pos];
                if(ch.isSpace()) ch=' ';}
            }
            if(number)
                newt.v=token.toInt();
            tokens.append(newt);
            continue;
        }

        // must be a symbol
        switch(ch.toLatin1())
        {
        case '(':
        case ')':
        case '[':
        case ']':
        case '{':
        case '}':
            hasbrackets=true;
            break;
        case '\"':
            hasquotes=true;
            break;
        }
        newt.s=ch;
        newt.typ=(TokenType)ch.toLatin1();
        tokens.append(newt);
        pos++;
        if(pos<len){ch=exp[pos]; if(ch.isSpace()) ch=' ';}
    }
    newt.typ=tNothing;
    newt.v=0.0;
    newt.s="";
    tokens.append(newt);
}

QString Exp::BuildPrePostText(int node)
{
    QString s="";
    if(N[node].fix==Prefix)
        s=" "+N[node].text+exptext(N[node].links.first());
    if(N[node].fix==Postfix)
        s=exptext(N[node].links.first())+N[node].text+" ";
    return s;
}
QString Exp::BuildInfixText(int node,QString text)
{
    int nl,i,l;
    QString s="";
    int t=N[node].type;
    nl=N[node].links.count();
    if(nl==0) return text;
    bool bracket=false;
    if(t==MultiOp)
    {
        if(N[N[node].parent].type!=RBracket)
            if(N[N[node].links[0]].type!=PlaceHolder)
                if(N[N[node].links[1]].type!=PlaceHolder)
                    bracket=true;
    }
    if(bracket) s+="(";
    l=N[node].links[0];
    s+=exptext(l);
    if(nl) for(i=1; i<nl; i++)
    {
        s+=text;
        l=N[node].links[i];
        s+=exptext(l);
    }
    if(nl<2) s+=text;
    if(bracket) s+=")";
    return s;
}
QString Exp::BuildFracText(int node)
{
    double v=N[node].value;
    QString s="(";
    int a=N[node].a;
    int b=N[node].b;
    if(v<eps && a==0)
        return "(0')";
    if(v>eps)
    {
        s+=QString::number(abs(v))+"`";
        if(a!=0)
        {
            s+=QString::number(a);
            if(b>1)
            {
                s+="/";
                s+=QString::number(b);
            }
        }
    } else {
        s+="`"+QString::number(a);
        if(b>1)
        {
            s+="/";
            s+=QString::number(b);
        }
    }
    s+=")";
    return s;
}
QString Exp::ExpText(int node)
{
    if(ERROR!="") return ERROR;
    QString s=exptext(node);
    if(s.length()) while(s[0]==' ') s.removeFirst();
    s.replace("( ","(");
    s.replace(" )",")");
    return s;
}
QString Exp::exptext(int node)
{
#ifdef QT_DEBUG
    if(!VALID_NODE(node))
    {
        ERROR="Invalid Node In ExpText";
        return "";
    }
#endif
    int n;
    QString s,text=N[node].text;
    if(N[node].sign<0) s=" -";
    else s="";
    switch(N[node].type)
    {
    case PlaceHolder:
        s+=" ";
        break;
    case Error:
        s+=N[node].text;
        break;
    case Start:
        if(N[node].links.isEmpty())
        {
            s+="Empty";
            ERROR=s;
            break;
        } else
            s+=exptext(N[node].links[0]);
        break;
    case RBracket: case CBracket: case SBracket:
        s+=N[node].text.first(N[node].text.length()-1);
        s+=BuildInfixText(node,"");
        s+=N[node].text.last(1);
        break;
    case RCBracket: case RSBracket:
    case CRBracket: case CSBracket:
    case SRBracket: case SCBracket:
        n=N[node].links.count();
        s+=N[node].text.first(N[node].text.length()-3);
        if(n>0)
            s+=exptext(N[node].links[0]);
        s+=N[node].text.mid(N[node].text.length()-3,2);
        if(n>1)
            s+=exptext(N[node].links[1]);
        s+=N[node].text.last(1);
        break;
    case Variable:
        s+=N[node].text;
        break;
    case DQuote:
        s+="\""+N[node].text+"\"";
        break;
    case Number:
        s+=QString::number(abs(N[node].value),'g',10);
        break;
    case Frac:
        s+=BuildFracText(node);
        break;
    case Comma:
        s+=BuildInfixText(node,N[node].text);
        break;
    case Semi:
        s+=BuildInfixText(node,N[node].text);
        break;
    case And:
        s+=BuildInfixText(node,N[node].text);
        break;
    case Or:
        s+=BuildInfixText(node,N[node].text);
        break;
    case Back:
        s+=BuildInfixText(node,N[node].text);
        break;
    case Plus:
        s+=BuildInfixText(node,text);
        break;
    case Times:
        s+=BuildInfixText(node,text);
        break;
    case Devide:
        s+=BuildInfixText(node,text);
        break;
    case Power:
        s+=BuildInfixText(node,text);
        break;
    case Equal:
        s+=BuildInfixText(node,text);
        break;
    case More:
        s+=BuildInfixText(node,text);
        break;
    case Less:
        s+=BuildInfixText(node,text);
        break;
    case Colon:
        s+=BuildInfixText(node,text);
        break;
    case MultiOp:
        s+=BuildInfixText(node,text);
        break;
    case Hash:
    case Dollar:
        char n[10]; sprintf_s(n,"%02i",N[node].a);
        s+=" "+N[node].text+QString(n);
        break;
    default:
        s+=BuildPrePostText(node);
    }
    return s;
}