sx_elem.hpp

/*
 *    This file is part of CasADi.
 *
 *    CasADi -- A symbolic framework for dynamic optimization.
 *    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
 *                            KU Leuven. All rights reserved.
 *    Copyright (C) 2011-2014 Greg Horn
 *
 *    CasADi 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 3 of the License, or (at your option) any later version.
 *
 *    CasADi 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 CasADi; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */
 
 
#ifndef CASADI_SX_ELEMENT_HPP
#define CASADI_SX_ELEMENT_HPP
 
// exception class
#include "printable.hpp"
#include "exception.hpp"
#include "casadi_limits.hpp"
#include "matrix_fwd.hpp"
#include "generic_expression.hpp"
#include "serializing_stream.hpp"
 
#include <cmath>
#include <iostream>
#include <limits>
#include <sstream>
#include <string>
#include <vector>
 
#ifdef CASADI_WITH_THREAD
#include <atomic>
#ifdef CASADI_WITH_THREAD_MINGW
#include <mingw.mutex.h>
#else // CASADI_WITH_THREAD_MINGW
#include <mutex>
#endif // CASADI_WITH_THREAD_MINGW
#endif //CASADI_WITH_THREAD
 
namespace casadi {
 
  class SXNode; // include will follow in the end
 
#ifdef SWIG
  struct SXElem {};
#else // SWIG
 
  class CASADI_EXPORT SXElem : public GenericExpression<SXElem>,
                               public Printable<SXElem> {
    friend class SXNode;
    friend class BinarySXNode;
    friend class Matrix<SXElem>;
  public:
 
 
    SXElem();
 
    SXElem(double val);
 
    static SXElem sym(const std::string& name);
 
    SXElem(SXNode* node, bool dummy);
 
    SXElem(const SXElem& scalar); // copy constructor
 
    ~SXElem();
 
    static SXElem create(SXNode* node);
 
    SXElem& operator=(const SXElem& scalar);
    SXElem& operator=(double scalar); // needed since otherwise both a = SXElem(double)
                                         // and a = Matrix(double) would be ok
 
    operator Matrix<SXElem>() const;
 
    static std::string type_name() {return "SXElem";}
 
    void disp(std::ostream& stream, bool more=false) const;
 
 
    SXNode* get() const; // note: constant pointer, not pointer to constant object!
                         // (to allow access to the counter)
 
    const SXNode* operator->() const;
    SXNode* operator->();
 
    static SXElem binary(casadi_int op, const SXElem& x, const SXElem& y);
    static SXElem unary(casadi_int op, const SXElem& x);
    static std::vector<SXElem> call(const Function& f, const std::vector<SXElem>& deps);
 
    bool __nonzero__() const;
 
    bool is_leaf() const;
    bool is_constant() const;
    bool is_integer() const;
    bool is_symbolic() const;
    bool is_commutative() const;
    bool is_zero() const;
    bool is_almost_zero(double tol) const;
    bool is_one() const;
    bool is_minus_one() const;
    bool is_nan() const;
    bool is_inf() const;
    bool is_minus_inf() const;
    const std::string& name() const;
    casadi_int op() const;
    bool is_op(casadi_int op) const;
    bool is_call() const;
    bool is_output() const;
    bool has_output() const;
    Function which_function() const;
    casadi_int which_output() const;
 
    bool is_regular() const;
 
    bool is_nonnegative() const;
    SXElem dep(casadi_int ch=0) const;
 
    explicit operator double() const;
 
    explicit operator casadi_int() const;
 
    bool is_doubled() const;
 
    casadi_int n_dep() const;
 
    SXElem get_output(casadi_int oind) const;
 
    casadi_int __hash__() const;
 
    SXElem operator-() const;
 
    SXElem inv() const;
 
    static bool is_equal(const SXElem& x, const SXElem& y, casadi_int depth=0);
 
    int get_temp() const;
 
    void set_temp(int t) const;
 
    bool marked() const;
 
    void mark() const;
 
    void assignIfDuplicate(const SXElem& scalar, casadi_int depth=1);
 
    SXNode* assignNoDelete(const SXElem& scalar);
 
    inline bool is_null() {return false;}
 
    friend inline SXElem if_else(const SXElem& x, const SXElem& y, const SXElem& z) {
      return if_else_zero(x, y) + if_else_zero(!x, z);
    }
 
    void serialize(SerializingStream& s) const;
 
    static SXElem deserialize(DeserializingStream& s);
 
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    static std::mutex mutex_temp;
#endif //CASADI_WITH_THREADSAFE_SYMBOLICS
 
  private:
    SXNode* node;
  };
 
  template<>
  class CASADI_EXPORT casadi_limits<SXElem>{
  public:
    static bool is_zero(const SXElem& val);
    static bool is_equal(const SXElem& x, const SXElem& y, casadi_int depth);
    static bool is_almost_zero(const SXElem& val, double tol);
    static bool is_one(const SXElem& val);
    static bool is_minus_one(const SXElem& val);
    static bool is_constant(const SXElem& val);
    static bool is_integer(const SXElem& val);
    static bool is_inf(const SXElem& val);
    static bool is_minus_inf(const SXElem& val);
    static bool is_nan(const SXElem& val);
 
    static const SXElem zero;
    static const SXElem one;
    static const SXElem two;
    static const SXElem minus_one;
    static const SXElem nan;
    static const SXElem inf;
    static const SXElem minus_inf;
  };
 
#endif // SWIG
 
} // namespace casadi
 
#ifndef SWIG
 
namespace std {
  template<>
  class CASADI_EXPORT numeric_limits<casadi::SXElem>{
  public:
    static const bool is_specialized = true;
    static casadi::SXElem min() throw();
    static casadi::SXElem max() throw();
    static const int  digits = 0;
    static const int  digits10 = 0;
    static const bool is_signed = false;
    static const bool is_integer = false;
    static const bool is_exact = false;
    static const int radix = 0;
    static casadi::SXElem epsilon() throw();
    static casadi::SXElem round_error() throw();
    static const int  min_exponent = 0;
    static const int  min_exponent10 = 0;
    static const int  max_exponent = 0;
    static const int  max_exponent10 = 0;
 
    static const bool has_infinity = true;
    static const bool has_quiet_NaN = true;
    static const bool has_signaling_NaN = false;
    //    static const float_denorm_style has_denorm = denorm absent;
    static const bool has_denorm_loss = false;
    static casadi::SXElem infinity() throw();
    static casadi::SXElem quiet_NaN() throw();
    //    static SXElem signaling_NaN() throw();
    //    static SXElem denorm_min() throw();
    static const bool is_iec559 = false;
    static const bool is_bounded = false;
    static const bool is_modulo = false;
 
    static const bool traps = false;
    static const bool tinyness_before = false;
    static const float_round_style round_style = round_toward_zero;
  };
} //namespace std
 
#endif // SWIG
 
#endif // CASADI_SX_ELEMENT_HPP