| //===-- AST Real Math Operators Interface -----------------------*- C++ -*-===// |
| // |
| // High Level Virtual Machine (HLVM) |
| // |
| // Copyright (C) 2006 Reid Spencer. All Rights Reserved. |
| // |
| // This software 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. |
| // |
| // This software 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 in the file named LICENSE.txt; if not, write to the |
| // Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
| // MA 02110-1301 USA |
| // |
| //===----------------------------------------------------------------------===// |
| /// @file hlvm/AST/RealMath.h |
| /// @author Reid Spencer <rspencer@reidspencer.com> (original author) |
| /// @date 2006/06/14 |
| /// @since 0.2.0 |
| /// @brief Declares the AST Real Math Operators |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef HLVM_AST_REALMATH_H |
| #define HLVM_AST_REALMATH_H |
| |
| #include <hlvm/AST/Operator.h> |
| |
| namespace hlvm |
| { |
| |
| /// This class provides an Abstract Syntax Tree node that represents a test |
| /// for positive infinity on a real value. The IsPInOp is a unary operator |
| /// that determines if its real number typed operand is the postive infinity |
| /// value or not. A Boolean value is returned. |
| /// @brief AST Positive Infinity Test Operator Node |
| class IsPInfOp : public UnaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| IsPInfOp() : UnaryOperator(IsPInfOpID) {} |
| virtual ~IsPInfOp(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const IsPInfOp*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(IsPInfOpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that represents a test |
| /// for negative infinity on a real value. The IsNInOp is a unary operator |
| /// that determines if its real number typed operand is the negative infinity |
| /// value or not. A Boolean value is returned. |
| /// @brief AST Negative Infinity Test Operator Node |
| class IsNInfOp : public UnaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| IsNInfOp() : UnaryOperator(IsNInfOpID) {} |
| virtual ~IsNInfOp(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const IsNInfOp*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(IsNInfOpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that represents a test |
| /// for not-a-number (NaN) on a real value. The IsNaNOp is a unary operator |
| /// that determines if its real number typed operand is the not-a-number |
| /// value or not. A Boolean value is returned. |
| /// @brief AST Not-A-Number Test Operator Node |
| class IsNanOp : public UnaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| IsNanOp() : UnaryOperator(IsNanOpID) {} |
| virtual ~IsNanOp(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const IsNanOp*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(IsNanOpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that represents a real |
| /// number truncation operator. The TruncOp removes the fractional portion of |
| /// its real number operand and returns that truncated value. |
| /// @brief AST Truncate Operator Node |
| class TruncOp : public UnaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| TruncOp() : UnaryOperator(TruncOpID) {} |
| virtual ~TruncOp(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const TruncOp*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(TruncOpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that represents a real |
| /// number rounding operator. The TruncOp rounds its real number operand towards |
| /// the nearest integer, but rounds halfway cases away from zero. The rounded |
| /// value is returned. This follows the C99 standard for rounding floating point |
| /// numbers. |
| /// @brief AST Rounding Operator Node |
| class RoundOp : public UnaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| RoundOp() : UnaryOperator(RoundOpID) {} |
| virtual ~RoundOp(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const RoundOp*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(RoundOpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that represents a real |
| /// number rounding operator. The FloorOp rounds its real number down to the |
| /// nearest integer. |
| /// @brief AST Floor Operator Node |
| class FloorOp : public UnaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| FloorOp() : UnaryOperator(FloorOpID) {} |
| virtual ~FloorOp(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const FloorOp*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(FloorOpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that represents a real |
| /// number rounding operator. The CeilingOp rounds its real number operand |
| /// upwards to the nearest integer. The rounded value is returned. |
| /// @brief AST Ceiling Operator Node |
| class CeilingOp : public UnaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| CeilingOp() : UnaryOperator(CeilingOpID) {} |
| virtual ~CeilingOp(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const CeilingOp*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(CeilingOpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that represents an |
| /// natural logarithm operator. The LogEOp is a unary operator that computes |
| /// the natural (base e, Euler's number) logarithm of its operand and returns |
| /// the result. |
| /// @brief AST Natural Logarithm Operator Node |
| class LogEOp : public UnaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| LogEOp() : UnaryOperator(LogEOpID) {} |
| virtual ~LogEOp(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const LogEOp*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(LogEOpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that represents a base |
| /// two logarithm operator. The Log2Op is a unary operator that computes |
| /// the base 2 logaritm of its operand and returns the result. |
| /// @brief AST Base 2 Logarithm Operator Node |
| class Log2Op : public UnaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| Log2Op() : UnaryOperator(Log2OpID) {} |
| virtual ~Log2Op(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const Log2Op*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(Log2OpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that represents a base |
| /// ten logarithm operator. The Log10Op is a unary operator that computes |
| /// the base 10 logaritm of its operand and returns the result. |
| /// @brief AST Base 10 Logarithm Operator Node |
| class Log10Op : public UnaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| Log10Op() : UnaryOperator(Log10OpID) {} |
| virtual ~Log10Op(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const Log10Op*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(Log10OpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that represents a square |
| /// root operator. The SquareRootOp is a unary operator that computes |
| /// the square root of its operand and returns the result. |
| /// @brief AST Squar Root Operator Node |
| class SquareRootOp : public UnaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| SquareRootOp() : UnaryOperator(SquareRootOpID) {} |
| virtual ~SquareRootOp(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const SquareRootOp*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(SquareRootOpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that represents a cube |
| /// root operator. The CubeRootOp is a unary operator that computes |
| /// the cube root of its operand and returns the result. |
| /// @brief AST Squar Root Operator Node |
| class CubeRootOp : public UnaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| CubeRootOp() : UnaryOperator(CubeRootOpID) {} |
| virtual ~CubeRootOp(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const CubeRootOp*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(CubeRootOpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that represents a factorial |
| /// operator. The FactorialOp is a unary operator that computes |
| /// the factorial of its operand and returns the result. |
| /// @brief AST Factorial Operator Node |
| class FactorialOp : public UnaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| FactorialOp() : UnaryOperator(FactorialOpID) {} |
| virtual ~FactorialOp(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const FactorialOp*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(FactorialOpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that represents an power |
| /// operator. The PowerOp is a binary operator that raises the value of its |
| /// first operand to the power of its second operand and returns the result. |
| /// @brief AST Power Operator Node |
| class PowerOp : public BinaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| PowerOp() : BinaryOperator(PowerOpID) {} |
| virtual ~PowerOp(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const PowerOp*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(PowerOpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that represents an root |
| /// operator. The RootOp is a binary operator that determines the root of its |
| /// first operand as a base of its second operand and returns the result. |
| /// @brief AST Root Operator Node |
| class RootOp : public BinaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| RootOp() : BinaryOperator(RootOpID) {} |
| virtual ~RootOp(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const RootOp*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(RootOpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that represents a greatest |
| /// common denominator operator. The GCDOp is a unary operator that computes |
| /// the greatest common denominator of its operands and returns the result. |
| /// @brief AST Factorial Operator Node |
| class GCDOp : public BinaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| GCDOp() : BinaryOperator(GCDOpID) {} |
| virtual ~GCDOp(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const GCDOp*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(GCDOpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| /// This class provides an Abstract Syntax Tree node that represents a least |
| /// common multiple operator. The LCMOp is a binary operator that computes the |
| /// least common multiple of its operands and returns the result. |
| /// @brief AST Least Common Multiple Operator Node |
| class LCMOp : public BinaryOperator |
| { |
| /// @name Constructors |
| /// @{ |
| protected: |
| LCMOp() : BinaryOperator(LCMOpID) {} |
| virtual ~LCMOp(); |
| |
| /// @} |
| /// @name Accessors |
| /// @{ |
| public: |
| static inline bool classof(const LCMOp*) { return true; } |
| static inline bool classof(const Node* N) { return N->is(LCMOpID); } |
| |
| /// @} |
| friend class AST; |
| }; |
| |
| } // end hlvm namespace |
| |
| #endif |