nodes.h

Go to the documentation of this file.

#ifndef __NODES_H
#define __NODES_H

/* Copyright (C) 2016 - James Terman
 *
 * milo is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * milo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <vector>
#include <exception>
#include <unordered_map>
#include "milo.h"

// Forward class decleration
class Parser;

class Binary : public Node
{
public:
    Binary(char op, Node* one, Node* two, Node* parent, bool neg, Node::Select s) : 
        Node(parent, neg, s), m_op(op), m_first(one), m_second(two) {}

    Binary(EqnXMLParser& in, Node* parent);

    virtual ~Binary() {}
    
    std::string toString() const { return m_first->toString() + std::string(1, m_op) + m_second->toString(); }

    bool isLeaf() const { return false; }

    Node* findNode(int x, int y);

    Node* findNode(const Box& b);

    int numFactors() const { return m_first->numFactors() + m_second->numFactors(); }
    
    ExpressionPtr getFirstExpression();

    ExpressionPtr getSecondExpression();

    static Node* parse(Parser& p, Node* one, Node* parent);

protected:
    char m_op;        
    NodePtr m_first;  
    NodePtr m_second; 
    Box m_internal;   

private:
    Node* downLeft()  { return m_first; }

    Node* downRight() { return m_second; }

    Node* getLeftSibling(Node* node)  { return (m_second == node) ? m_first->last() : nullptr; }

    Node* getRightSibling(Node* node) { return (m_first == node) ? m_second->first() : nullptr; }

    void xml_out(XML::Stream& xml) const;
};

class Divide : public Binary
{
public:
    Divide(Node* one, Node* two, Node* parent, bool neg = false, Node::Select s = Node::Select::NONE) : 
        Binary('/', one, two, parent, neg, s) 
    { 
        m_first->setParent(this); m_second->setParent(this); 
        m_first->setDrawParenthesis(false); m_second->setDrawParenthesis(false);
    }

    Divide(EqnXMLParser& in, Node* parent) : Binary(in, parent)
    { 
        m_op = '/'; m_first->setDrawParenthesis(false); m_second->setDrawParenthesis(false);
    }

    ~Divide() {}
    
    const std::string& getName() const { return name; }

    std::type_index getType() const { return type; }

    void normalize();

    bool simplify();

    static bool create(Equation& eqn);
    
    static const std::string name;     
    static const std::type_index type; 

 private:
    Frame calcSize(UI::Graphics& gc);

    void calcOrig(UI::Graphics& gc, int x, int y);

    void drawNode(UI::Graphics& gc) const;

    Complex getNodeValue() const;

    static Node* normalize(Node* n);
};

class Power : public Binary
{
public:
     Power(Node* one, Node* two, Node* parent, bool neg = false, Node::Select s = Node::Select::NONE) : 
        Binary('^', one, two, parent, neg, s) 
    { 
        m_first->setParent(this); m_second->setParent(this);
        m_first->setDrawParenthesis(m_first->numFactors()>1); m_second->setDrawParenthesis(false);
    }

    Power(EqnXMLParser& in, Node* parent) : Binary(in, parent)
    { 
        m_op = '^'; m_first->setDrawParenthesis(m_first->numFactors()>1); m_second->setDrawParenthesis(false);
    }

    ~Power() {}
    
    const std::string& getName() const { return name; }

    std::type_index getType() const { return type; }

    void normalize();

    bool simplify();

    static bool create(Equation& eqn);

    static bool simplify(NodeVector& factors);
    
    static const std::string name;     
    static const std::type_index type; 

private:
    Frame calcSize(UI::Graphics& gc);

    void calcOrig(UI::Graphics& gc, int x, int y);

    void drawNode(UI::Graphics& gc) const;

    Complex getNodeValue() const;
    
    static bool simplify(NodeVector::iterator a, NodeVector::iterator b);
};

class Constant : public Node
{
public:
    Constant(Parser& p, Node* parent);

    Constant(char name, Complex value, Node* parent, bool neg = false, Node::Select s = Node::Select::NONE) : 
        Node(parent, neg, s), m_name(name), m_value(value) {}

    Constant(EqnXMLParser& in, Node* parent);

    ~Constant() {}
    
    using const_map = std::unordered_map<char, Complex>; 

    std::string toString() const { return std::string() + m_name; }

    const std::string& getName() const { return name; }

    std::type_index getType() const { return type; }
    
    static const std::string name;     
    static const std::type_index type; 

    static Constant* parse(Parser& p, Node* parent);
private:
    char m_name;                      
    Complex m_value;                  
    Box m_internal;                   
    
    static const const_map constants; 

    void xml_out(XML::Stream& xml) const;
    
    Frame calcSize(UI::Graphics& gc);

    void calcOrig(UI::Graphics& gc, int x, int y);

    void drawNode(UI::Graphics& gc) const;

    Complex getNodeValue() const { return constants.at(m_name); }
};


class Variable : public Node
{
public:
    Variable(Parser& p, Node* parent);

     Variable(char name, Node* parent, bool neg = false, Node::Select s = Node::Select::NONE) : 
        Node(parent, neg, s), m_name(name)
    { 
        values.emplace(name, Complex(0, 0)); 
    }

    Variable(EqnXMLParser& in, Node* parent);

    ~Variable() {}
    
    using var_map = std::unordered_map<char, Complex>; 

    std::string toString() const { return std::string(1, m_name); }

    const std::string& getName() const { return name; }

    std::type_index getType() const { return type; }
    
    static const std::string name;     
    static const std::type_index type; 

    static Variable* parse(Parser& p, Node* parent);

    static void setValue(char name, Complex value);

private:
    char m_name;    
    Box m_internal; 

    static var_map values; 

    void xml_out(XML::Stream& xml) const;
    
    Frame calcSize(UI::Graphics& gc);

    void calcOrig(UI::Graphics& gc, int x, int y);

    void drawNode(UI::Graphics& gc) const;

    Complex getNodeValue() const { return values[m_name]; }
};

class Number : public Node
{
public:
    Number(Parser& p, Node* parent) : Node(parent), m_isInteger(true) { getNumber(p); }

    Number(std::string real, Node* parent, bool neg = false, Node::Select s = Node::Select::NONE) :
        Node(parent, neg, s), m_value(stod(real)), m_isInteger(isInteger(real)) {}

    Number(int n, Node* parent, bool neg = false, Node::Select s = Node::Select::NONE) :
        Node(parent, neg, s), m_value(n), m_isInteger(true) {}

    Number(double d, Node* parent, bool neg = false, Node::Select s = Node::Select::NONE) :
        Node(parent, neg, s), m_value(d), m_isInteger(isInteger(d)) {}

    Number(EqnXMLParser& in, Node* parent);

    ~Number() {}
    
    void getNumber(Parser& p);

    std::string toString() const;

    const std::string& getName() const { return name; }

    std::type_index getType() const { return type; }

    bool simplify();
    
    static const std::string name;     
    static const std::type_index type; 

    static Number* parse(Parser& p, Node* parent);

private:
    double m_value;   
    bool m_isInteger; 
    Box m_internal;   

    static std::string getInteger(Parser& p);

    void xml_out(XML::Stream& xml) const;
    
    Frame calcSize(UI::Graphics& gc);

    void calcOrig(UI::Graphics& gc, int x, int y);

    void drawNode(UI::Graphics& gc) const;

    Complex getNodeValue() const { return {m_value, 0}; }
};

class Function : public Node
{
public:
    using func_ptr = Complex (*)(Complex);

    using func_map = std::unordered_map<std::string, func_ptr>;

    static Function* parse(Parser& p, Node* parent);

    std::string toString() const { return m_name + m_arg->toString(); }

    bool isLeaf() const { return false; }

    Node* findNode(int x, int y);

    Node* findNode(const Box& b);

    int numFactors() const { return m_arg->numFactors() + 1; }

    void normalize() { m_arg->normalize(); }

    bool less(NodePtr b) const;

    const std::string& getName() const { return name; }

    std::type_index getType() const { return type; }
    
    static const std::string name;     
    static const std::type_index type; 
    
    Function(const std::string& name, func_ptr fp, Parser& p, Node* parent, 
             bool neg = false, Node::Select s = Node::Select::NONE) : 
                 Node(parent, neg, s), m_name(name), m_func(fp), m_arg(new Expression(p, this)) {}

    Function(EqnXMLParser& in, Node* parent);

    ~Function() {}
private:
    std::string m_name; 
    func_ptr m_func;    
    NodePtr m_arg;      
    Box m_internal;     

    Node* downLeft()  { return m_arg->first(); }

    Node* downRight() { return m_arg->last(); }
    void xml_out(XML::Stream& xml) const;
    
    Frame calcSize(UI::Graphics& gc);

    void calcOrig(UI::Graphics& gc, int x, int y);

    void drawNode(UI::Graphics& gc) const;

    Complex getNodeValue() const;
    
    static const func_map functions;

    static Complex sinZ(Complex z); 
    static Complex cosZ(Complex z); 
    static Complex tanZ(Complex z); 
    static Complex logZ(Complex z); 
    static Complex expZ(Complex z); 
};

class Differential : public Node
{
public:
    Differential(Parser& p, Node* parent);

    Differential(EqnXMLParser& in, Node* parent);

    ~Differential() {}
    
    bool isLeaf() const { return false; }

    int numFactors() const { return m_function->numFactors()+1; }

    Node* findNode(int x, int y) { return m_function->findNode(x, y); }

    Node* findNode(const Box& b);

    std::string toString() const;

    const std::string& getName() const { return name; }

    std::type_index getType() const { return type; }

    void normalize() { m_function->normalize(); }

    bool simplify() { return false; }
    
    static const std::string name;     
    static const std::type_index type; 

    static Differential* parse(Parser& p, Node* parent);

private:
    Box m_internal;      
    char m_variable;     
    NodePtr m_function;  

    Node* downLeft()  { return m_function->first(); }

    Node* downRight() { return m_function->last(); }
    void xml_out(XML::Stream& xml) const;
    
    Frame calcSize(UI::Graphics& gc);

    void calcOrig(UI::Graphics& gc, int x, int y);

    void drawNode(UI::Graphics& gc) const;

    Complex getNodeValue() const { return {0, 0}; }
};

#endif // __NODES_H