Storage.hh

Go to the documentation of this file.

/*
 
Cadabra: a field-theory motivated computer algebra system.
Copyright (C) 2001-2014  Kasper Peeters <kasper.peeters@phi-sci.com>
 
This program is free software: you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
 
This program 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
General Public License for more details.
 
You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
*/
 
#pragma once
 
#include <cstddef>
#include <iostream>
#include <gmpxx.h>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <stdint.h>
#include <assert.h>
#include <initializer_list>
#include <variant>
#include <memory_resource>
 
#include "tree.hh"
#include "Multiplier.hh"
 
namespace cadabra {
 
    class NTensor;
    class NInterpolatingFunction;
    
    typedef Multiplier              multiplier_t;
    typedef std::set<std::string>   nset_t;
    typedef std::set<multiplier_t>  rset_t;
    typedef uintptr_t               hashval_t;
 
    long        to_long(multiplier_t);
    double      to_double(multiplier_t);
    std::string to_string(long);
 
    extern nset_t name_set;
    extern rset_t rat_set;
 
 
    class str_node { // size: 9 bytes (32 bit arch), can be reduced to 5 bytes.
        public:
            enum bracket_t     { b_round=0, b_square=1, b_curly=2, b_pointy=3, b_none=4, b_no=5, b_invalid=6 };
 
            enum parent_rel_t  { p_sub=0, p_super=1, p_none=2, p_property=3, p_exponent=4, p_components=5, p_invalid=7 };
 
            str_node(void);
//          str_node(const str_node&);
//          str_node(str_node&&);
            str_node(nset_t::iterator name, bracket_t btype=b_none, parent_rel_t ptype=p_none);
            str_node(const std::string& name, bracket_t btype=b_none, parent_rel_t ptype=p_none);
            str_node(const std::u32string& name, bracket_t btype=b_none, parent_rel_t ptype=p_none);
 
            bool operator==(const str_node&) const;
            bool operator<(const str_node&) const;
 
            nset_t::iterator name;
            rset_t::iterator multiplier;
 
            // Special content which does not fit the AST structure, but still needs to
            // sit in the tree, is stored in the form of a shared pointer to data outside
            // the tree. If there is nothing, the std::monostate is set.
            std::variant<std::monostate,
                             std::shared_ptr<NTensor>,
                             std::shared_ptr<NInterpolatingFunction>
                             > content;
 
#ifdef _WIN32
            struct flag_t {
                bool            keep_after_eval ;
                bracket_t       bracket         ;
                parent_rel_t    parent_rel      ;
                bool            line_per_node   ;
                };
#else
            struct flag_t { // kept inside 8 bits for speed and size
                bool            keep_after_eval : 1;
                bracket_t       bracket         : 3;
                parent_rel_t    parent_rel      : 3;
                bool            line_per_node   : 1;
                };
#endif
 
            flag_t fl;
 
            void flip_parent_rel();
 
            bool is_standard() const;
                
            bool is_zero() const;
            bool is_identity() const;
            bool is_rational() const;
            bool is_double() const;
            bool is_unsimplified_rational() const;
            bool is_unsimplified_double() const;
            bool is_integer() const;
            bool is_unsimplified_integer() const;
            bool is_index() const;            // _ or ^ parent_rel (does not query properties)
            bool is_quoted_string() const;
            bool is_command() const;
            bool is_inert_command() const;
            bool is_name_wildcard() const;    //  ?
            bool is_object_wildcard() const;  //  ??
            bool is_range_wildcard() const;   //  #{..}
            bool is_siblings_wildcard() const; // a...
            bool is_autodeclare_wildcard() const; // m#
            bool is_indexstar_wildcard() const; // ?* in sub/super
            bool is_indexplus_wildcard() const; // ?+ in sub/super
            bool is_numbered_symbol() const;  //  [a-zA-Z]+[0-9]+
 
            nset_t::iterator name_only();
 
            static bool compare_names_only(const str_node&, const str_node&);
            static bool compare_name_brack_par(const str_node&, const str_node&);
            static bool compare_name_inverse_par(const str_node&, const str_node&);
        };
 
    void     multiply(rset_t::iterator&, multiplier_t);
    void     divide(rset_t::iterator&, multiplier_t);
    void     add(rset_t::iterator&, multiplier_t);
    void     zero(rset_t::iterator&);
    void     one(rset_t::iterator&);
    void     flip_sign(rset_t::iterator&);
    void     half(rset_t::iterator&);
    void     set(rset_t::iterator&, multiplier_t);
    
 
 
//  typedef tree<str_node, std::pmr::polymorphic_allocator<tree_node_<str_node>>> cdb_tree;
//  extern std::pmr::polymorphic_allocator<tree_node_<str_node>> alloc;
    typedef tree<str_node, std::pmr::polymorphic_allocator<tree_node_<str_node>>> cdb_tree;
    
    class Ex : public std::enable_shared_from_this<Ex>, public cdb_tree {
        public:
            Ex();
            explicit Ex(cdb_tree::iterator);
            explicit Ex(const str_node&);
            Ex(const Ex&);
            // explicit Ex(Ex);
            explicit Ex(const std::string&);
            explicit Ex(int);
            explicit Ex(double);
            explicit Ex(int, int);
 
            Ex& operator=(Ex);
            
 
            enum result_t {
                l_checkpointed,
                l_no_action,
                l_applied,
                l_applied_no_new_dummies,
                l_error,
                l_cached
            };
            result_t state() const;
            void     update_state(result_t);
            void     reset_state();
 
            
            bool     changed_state();
 
            bool          is_rational() const;
            multiplier_t  to_rational() const;
            bool          is_integer()  const;
            long          to_integer()  const;
            bool          is_string()   const;
 
            bool          equals(const std::string&) const;
 
            bool          is_empty() const;
 
            static std::ostream& print_python(std::ostream& str, Ex::iterator it);
 
            std::ostream& print_entire_tree(std::ostream& str) const;
            static std::ostream& print_recursive_treeform(std::ostream& str, Ex::iterator it);
            static std::ostream& print_recursive_treeform(std::ostream& str, Ex::iterator it, unsigned int& number);
 
            std::ostream& print_repr(std::ostream& str, Ex::iterator it) const;
 
            iterator     named_parent(iterator it, const std::string&) const;
            iterator     erase_expression(iterator it);
 
            hashval_t    calc_hash(iterator it) const;
 
            static sibling_iterator arg(iterator, unsigned int);
            static unsigned int     arg_size(sibling_iterator);
 
            multiplier_t     arg_to_num(sibling_iterator, unsigned int) const; // shorthand for numerical arguments
 
            // Like 'child', but using index iterators instead.
            //      sibling_iterator tensor_index(const iterator_base& position, unsigned int) const;
 
            // Number of \\history nodes in an expression
            unsigned int     number_of_steps(iterator it) const;
            // Given an iterator pointing to any node in the tree, figure
            // out to which equation number it belongs.
//          unsigned int     number_of_equations() const;
//          unsigned int     equation_number(iterator it) const;
//          nset_t::iterator equation_label(iterator it) const;
//          iterator         equation_by_number(unsigned int i) const;
//          iterator         equation_by_name(nset_t::iterator it) const;
//          iterator         equation_by_name(nset_t::iterator it, unsigned int& ) const;
//          iterator         equation_by_number_or_name(iterator it, unsigned int last_used_equation) const;
//          iterator         equation_by_number_or_name(iterator it, unsigned int last_used_equation,
//                unsigned int&) const;
//          std::string      equation_number_or_name(iterator it, unsigned int last_used_equation) const;
//          iterator         procedure_by_name(nset_t::iterator it) const;
 
            // Determine whether a node has an '\ldots' parent (not necessarily direct).
            bool is_hidden(iterator) const;
 
            iterator         replace_index(iterator position, const iterator& from, bool keep_parent_rel=false);
 
            iterator         move_index(iterator position, const iterator& from);
 
            void             list_wrap_single_element(iterator&);
            void             list_unwrap_single_element(iterator&);
 
            iterator         flatten_and_erase(iterator position);
 
 
            bool operator==(const Ex& other) const;
 
            void push_history(const std::vector<Ex::path_t>&);
 
            std::vector<Ex::path_t> pop_history();
 
            int  history_size() const;
 
        private:
            result_t state_;
 
            std::vector<cdb_tree> history;
            std::vector<std::vector<Ex::path_t> > terms;
        };
 
 
 
    class nset_it_less {
        public:
            bool operator()(nset_t::iterator first, nset_t::iterator second) const;
        };
 
    template <typename T>
    bool is_in(const T& val, const std::initializer_list<T>& list)
        {
        for (const auto& i : list) {
            if (val == i) {
                return true;
                }
            }
        return false;
        }
 
    }
 
 
std::ostream& operator<<(std::ostream&, const cadabra::Ex&);
std::ostream& operator<<(std::ostream&, cadabra::Ex::iterator);