Expr

#include <popops/Expr.hpp>

Expressions with elements of tensors.

Defines

POPLIBS_DEFINE_EXPR_UNARY_OP(Name, Op)

POPLIBS_DEFINE_EXPR_UNARY_OP_AND_SYMBOL(Name, Op, Sym)

POPLIBS_DEFINE_EXPR_BINARY_OP(Name, Op)

POPLIBS_DEFINE_EXPR_BINARY_OP_AND_SYMBOL(Name, Op, Sym)

POPLIBS_DEFINE_EXPR_TERNARY_OP(Name, Op)

namespace popops

Common functions, such as elementwise and reductions.

namespace expr

Functions

std::ostream &operator<<(std::ostream &os, const Expr &expr)

bool deepEquals(const Expr &a, const Expr &b)

inline ConstHalf operator""_half(long double x)

const PlaceHolder _1 (1)

const PlaceHolder _2 (2)

const PlaceHolder _3 (3)

const PlaceHolder _4 (4)

const PlaceHolder _5 (5)

const PlaceHolder _6 (6)

const PlaceHolder _7 (7)

const PlaceHolder _8 (8)

const PlaceHolder _9 (9)

const PlaceHolder _10 (10)

const PlaceHolder _11 (11)

const PlaceHolder _12 (12)

const PlaceHolder _13 (13)

const PlaceHolder _14 (14)

const PlaceHolder _15 (15)

const PlaceHolder _16 (16)

const PlaceHolder _17 (17)

const PlaceHolder _18 (18)

const PlaceHolder _19 (19)

const PlaceHolder _20 (20)

inline BitwiseNot operator~(const Expr &a)

inline Not operator!(const Expr &a)

inline Neg operator-(const Expr &a)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Add >::type operator+ (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Add >::type operator+ (const Expr &a, const T &b)

inline Add operator+(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), BitwiseAnd >::type operator& (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), BitwiseAnd >::type operator& (const Expr &a, const T &b)

inline BitwiseAnd operator&(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), BitwiseOr >::type operator| (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), BitwiseOr >::type operator| (const Expr &a, const T &b)

inline BitwiseOr operator|(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), BitwiseXor >::type operator^ (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), BitwiseXor >::type operator^ (const Expr &a, const T &b)

inline BitwiseXor operator^(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Divide >::type operator/ (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Divide >::type operator/ (const Expr &a, const T &b)

inline Divide operator/(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Equal >::type operator== (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Equal >::type operator== (const Expr &a, const T &b)

inline Equal operator==(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Gte >::type operator>= (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Gte >::type operator>= (const Expr &a, const T &b)

inline Gte operator>=(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Gt >::type operator> (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Gt >::type operator> (const Expr &a, const T &b)

inline Gt operator>(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Lte >::type operator<= (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Lte >::type operator<= (const Expr &a, const T &b)

inline Lte operator<=(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), And >::type operator&& (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), And >::type operator&& (const Expr &a, const T &b)

inline And operator&&(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Or >::type operator|| (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Or >::type operator|| (const Expr &a, const T &b)

inline Or operator||(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Lt >::type operator< (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Lt >::type operator< (const Expr &a, const T &b)

inline Lt operator<(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Mul >::type operator* (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Mul >::type operator* (const Expr &a, const T &b)

inline Mul operator*(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), NotEqual >::type operator!= (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), NotEqual >::type operator!= (const Expr &a, const T &b)

inline NotEqual operator!=(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Rem >::type operator% (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Rem >::type operator% (const Expr &a, const T &b)

inline Rem operator%(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Shl >::type operator<< (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Shl >::type operator<< (const Expr &a, const T &b)

inline Shl operator<<(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Shr >::type operator>> (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Shr >::type operator>> (const Expr &a, const T &b)

inline Shr operator>>(const Expr &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Sub >::type operator- (const T &a, const Expr &b)

template<typename T> inline std::enable_if<!std::is_base_of< Expr, T >::value &&poplar::TypeTraits::isSimpleType< T >), Sub >::type operator- (const Expr &a, const T &b)

inline Sub operator-(const Expr &a, const Expr &b)

class Abs : public popops::expr::UnaryOp 

Public Functions

inline Abs(const Expr &a)

class Add : public popops::expr::BinaryOp 

Public Functions

inline Add(const Expr &a, const Expr &b)

class And : public popops::expr::BinaryOp 

Public Functions

inline And(const Expr &a, const Expr &b)

class Any

#include <Expr.hpp>

A class that can contain any expression, useful for building up expression trees dynamically where the type of the outermost expression may change.

Public Functions

inline Any(const Expr &expr)

inline Any(const Any &expr)

Any(Any&&) = default

inline Any &operator=(const Any &other)

Any &operator=(Any &&other) = default

inline operator Expr&()

inline operator const Expr&() const

inline std::string name(const std::vector<poplar::Tensor> &inputs) const

Private Members

std::unique_ptr<Expr> expr

class Asin : public popops::expr::UnaryOp 

Public Functions

inline Asin(const Expr &a)

class Atan2 : public popops::expr::BinaryOp 

Public Functions

inline Atan2(const Expr &a, const Expr &b)

class BinaryOp : public popops::expr::ExprType<BinaryOp>

#include <Expr.hpp>

A class to represent expressions with binary operators.

Subclassed by popops::expr::Add, popops::expr::And, popops::expr::Atan2, popops::expr::BitwiseAnd, popops::expr::BitwiseOr, popops::expr::BitwiseXnor, popops::expr::BitwiseXor, popops::expr::Divide, popops::expr::Equal, popops::expr::Gt, popops::expr::Gte, popops::expr::InvStdDevToVariance, popops::expr::Lt, popops::expr::Lte, popops::expr::Max, popops::expr::Min, popops::expr::Mul, popops::expr::NotEqual, popops::expr::Or, popops::expr::Pow, popops::expr::Rem, popops::expr::Shl, popops::expr::Shr, popops::expr::ShrSE, popops::expr::Sub, popops::expr::VarianceToInvStdDev

Public Functions

inline BinaryOp(BinaryOpType type, const Expr &a, const Expr &b)

BinaryOp(BinaryOp&&) = default

BinaryOp &operator=(BinaryOp&&) = default

inline BinaryOp(const BinaryOp &other)

inline BinaryOp &operator=(const BinaryOp &other)

inline BinaryOpType getOpType() const

inline const Expr &getLHS() const

inline const Expr &getRHS() const

inline virtual std::unique_ptr<Expr> clone() const override

virtual std::string name(const std::vector<poplar::Tensor> &inputs) const override

inline std::string exprName(const std::vector<poplar::Tensor> &inputs) const

virtual bool deepEquals(const Expr &other) const override

virtual void print(std::ostream &os, unsigned indent = 0, bool prettyPrint = true) const override

Private Members

BinaryOpType type

std::unique_ptr<Expr> a

std::unique_ptr<Expr> b

class BitwiseAnd : public popops::expr::BinaryOp 

Public Functions

inline BitwiseAnd(const Expr &a, const Expr &b)

class BitwiseNot : public popops::expr::UnaryOp 

Public Functions

inline BitwiseNot(const Expr &a)

class BitwiseOr : public popops::expr::BinaryOp 

Public Functions

inline BitwiseOr(const Expr &a, const Expr &b)

class BitwiseXnor : public popops::expr::BinaryOp 

Public Functions

inline BitwiseXnor(const Expr &a, const Expr &b)

class BitwiseXor : public popops::expr::BinaryOp 

Public Functions

inline BitwiseXor(const Expr &a, const Expr &b)

class Cast : public popops::expr::ExprType<Cast>

#include <Expr.hpp>

A class to represent cast expressions.

Public Functions

inline Cast(const Expr &a_, const poplar::Type bType_)

Cast(Cast &&other) = default

Cast &operator=(Cast &&other) = default

inline Cast(const Cast &other)

inline Cast &operator==(const Cast &other)

inline const Expr &getLHS() const

inline const poplar::Type &getRHSType() const

inline virtual std::unique_ptr<Expr> clone() const override

virtual std::string name(const std::vector<poplar::Tensor> &inputs) const override

virtual bool deepEquals(const Expr &other) const override

virtual void print(std::ostream &os, unsigned indent = 0, bool prettyPrint = true) const override

Private Members

std::unique_ptr<Expr> a

poplar::Type bType

class Cbrt : public popops::expr::UnaryOp 

Public Functions

inline Cbrt(const Expr &a)

class Ceil : public popops::expr::UnaryOp 

Public Functions

inline Ceil(const Expr &a)

class Clamp : public popops::expr::TernaryOp 

Public Functions

inline Clamp(const Expr &a, const Expr &b, const Expr &c)

class Const : public popops::expr::ExprType<Const>

#include <Expr.hpp>

A class to represent constant expressions.

Subclassed by popops::expr::ConstHalf

Public Functions

template<typename T, typename = typename std::enable_if<poplar::TypeTraits::isSimpleType<T>(), T>::type> inline Const(T x)

inline Const(poplar::TypeTraits typeTraits_, poplar::Type type_, const char *data_)

Const(Const&&) = default

Const &operator=(Const&&) = default

inline Const(const Const &other)

inline Const &operator=(const Const &other)

inline char *getData() const

inline const poplar::TypeTraits &getTypeTraits() const

inline const poplar::Type &getType() const

std::string printValue() const

double getDataAsDouble() const

std::uint64_t getDataForUnsignedIntegral() const

inline virtual std::unique_ptr<Expr> clone() const override

virtual std::string name(const std::vector<poplar::Tensor>&) const override

virtual bool deepEquals(const Expr &other) const override

virtual void print(std::ostream &os, unsigned indent = 0, bool prettyPrint = true) const override

Protected Functions

template<typename T> inline Const(T x, bool isHalfType)

Private Members

poplar::TypeTraits typeTraits

poplar::Type type

std::unique_ptr<char[]> data

class ConstHalf : public popops::expr::Const 

#include <Expr.hpp>

A class to represent constant expressions of type half.

Public Functions

inline ConstHalf(float x)

ConstHalf(ConstHalf&&) = default

ConstHalf &operator=(ConstHalf&&) = default

inline ConstHalf(const ConstHalf &other)

inline ConstHalf &operator=(const ConstHalf &other)

class Cos : public popops::expr::UnaryOp 

Public Functions

inline Cos(const Expr &a)

class Divide : public popops::expr::BinaryOp 

Public Functions

inline Divide(const Expr &a, const Expr &b)

class Equal : public popops::expr::BinaryOp 

Public Functions

inline Equal(const Expr &a, const Expr &b)

class Erf : public popops::expr::UnaryOp 

Public Functions

inline Erf(const Expr &a)

class Exp : public popops::expr::UnaryOp 

Public Functions

inline Exp(const Expr &a)

class Exp2 : public popops::expr::UnaryOp 

Public Functions

inline Exp2(const Expr &a)

class Expm1 : public popops::expr::UnaryOp 

Public Functions

inline Expm1(const Expr &a)

class Expr

#include <Expr.hpp>

Type to represent element expressions.

This class represents an expression that can be applied to elements of tensors.

The Expr type is an abstract type which can be instantiated by its sub-classes to build up expressions, for example: Tanh(Add(Square(_1), Const(3)))).

Expressions can be applied to tensors with the popops::map() and popops::mapInPlace() functions.

Subclassed by popops::expr::ExprType< BinaryOp >, popops::expr::ExprType< Cast >, popops::expr::ExprType< Const >, popops::expr::ExprType< PlaceHolder >, popops::expr::ExprType< TernaryOp >, popops::expr::ExprType< UnaryOp >, popops::expr::ExprType< T >

Public Functions

virtual ~Expr()

template<class T> inline bool isA() const

template<class T> inline T *getAs()

template<class T> inline const T *getAs() const

virtual std::unique_ptr<Expr> clone() const = 0

virtual std::string name(const std::vector<poplar::Tensor>&) const = 0

virtual bool deepEquals(const Expr &other) const = 0

virtual void print(std::ostream &os, unsigned indent = 0, bool prettyPrint = true) const = 0

Protected Types

using ExprClassID = void (*)(void)

Protected Functions

inline Expr(ExprClassID classId)

Protected Attributes

ExprClassID classId

template<class T> class ExprType : public popops::expr::Expr 

Subclassed by popops::expr::BinaryOp, popops::expr::Cast, popops::expr::Const, popops::expr::PlaceHolder, popops::expr::TernaryOp, popops::expr::UnaryOp

Public Functions

inline ExprType()

Private Static Functions

static void loc()

static inline ExprClassID getClassId()

Friends

friend class Expr

class Floor : public popops::expr::UnaryOp 

Public Functions

inline Floor(const Expr &a)

class GeluErf : public popops::expr::UnaryOp 

Public Functions

inline GeluErf(const Expr &a)

class Gt : public popops::expr::BinaryOp 

Public Functions

inline Gt(const Expr &a, const Expr &b)

class Gte : public popops::expr::BinaryOp 

Public Functions

inline Gte(const Expr &a, const Expr &b)

class Inv : public popops::expr::UnaryOp 

Public Functions

inline Inv(const Expr &a)

class InvStdDevToVariance : public popops::expr::BinaryOp 

Public Functions

inline InvStdDevToVariance(const Expr &a, const Expr &b)

class IsFinite : public popops::expr::UnaryOp 

Public Functions

inline IsFinite(const Expr &a)

class IsInf : public popops::expr::UnaryOp 

Public Functions

inline IsInf(const Expr &a)

class IsNaN : public popops::expr::UnaryOp 

Public Functions

inline IsNaN(const Expr &a)

class Log : public popops::expr::UnaryOp 

Public Functions

inline Log(const Expr &a)

class Log1p : public popops::expr::UnaryOp 

Public Functions

inline Log1p(const Expr &a)

class Lt : public popops::expr::BinaryOp 

Public Functions

inline Lt(const Expr &a, const Expr &b)

class Lte : public popops::expr::BinaryOp 

Public Functions

inline Lte(const Expr &a, const Expr &b)

class Max : public popops::expr::BinaryOp 

Public Functions

inline Max(const Expr &a, const Expr &b)

class Min : public popops::expr::BinaryOp 

Public Functions

inline Min(const Expr &a, const Expr &b)

class Mul : public popops::expr::BinaryOp 

Public Functions

inline Mul(const Expr &a, const Expr &b)

class NearbyInt : public popops::expr::UnaryOp 

Public Functions

inline NearbyInt(const Expr &a)

class Neg : public popops::expr::UnaryOp 

Public Functions

inline Neg(const Expr &a)

class Not : public popops::expr::UnaryOp 

Public Functions

inline Not(const Expr &a)

class NotEqual : public popops::expr::BinaryOp 

Public Functions

inline NotEqual(const Expr &a, const Expr &b)

class Or : public popops::expr::BinaryOp 

Public Functions

inline Or(const Expr &a, const Expr &b)

class PlaceHolder : public popops::expr::ExprType<PlaceHolder>

Public Functions

inline PlaceHolder(unsigned index)

PlaceHolder(PlaceHolder&&) = default

PlaceHolder &operator=(PlaceHolder&&) = default

inline PlaceHolder(const PlaceHolder &other)

inline PlaceHolder &operator=(const PlaceHolder &other)

inline unsigned getIndex() const

inline std::unique_ptr<Expr> clone() const override

std::string name(const std::vector<poplar::Tensor> &inputs) const override

bool deepEquals(const Expr &other) const override

void print(std::ostream &os, unsigned indent = 0, bool prettyPrint = true) const override

Private Members

unsigned index

class Pow : public popops::expr::BinaryOp 

Public Functions

inline Pow(const Expr &a, const Expr &b)

class Rem : public popops::expr::BinaryOp 

Public Functions

inline Rem(const Expr &a, const Expr &b)

class Round : public popops::expr::UnaryOp 

Public Functions

inline Round(const Expr &a)

class Rsqrt : public popops::expr::UnaryOp 

Public Functions

inline Rsqrt(const Expr &a)

class Select : public popops::expr::TernaryOp 

#include <Expr.hpp>

Computes the conditional ternary operation.

c ? a : b

Public Functions

inline Select(const Expr &a, const Expr &b, const Expr &c)

class Shl : public popops::expr::BinaryOp 

Public Functions

inline Shl(const Expr &a, const Expr &b)

class Shr : public popops::expr::BinaryOp 

Public Functions

inline Shr(const Expr &a, const Expr &b)

class ShrSE : public popops::expr::BinaryOp 

Public Functions

inline ShrSE(const Expr &a, const Expr &b)

class Sigmoid : public popops::expr::UnaryOp 

Public Functions

inline Sigmoid(const Expr &a)

class Signum : public popops::expr::UnaryOp 

Public Functions

inline Signum(const Expr &a)

class Sin : public popops::expr::UnaryOp 

Public Functions

inline Sin(const Expr &a)

class Sqrt : public popops::expr::UnaryOp 

Public Functions

inline Sqrt(const Expr &a)

class Square : public popops::expr::UnaryOp 

Public Functions

inline Square(const Expr &a)

class Sub : public popops::expr::BinaryOp 

Public Functions

inline Sub(const Expr &a, const Expr &b)

class Tan : public popops::expr::UnaryOp 

Public Functions

inline Tan(const Expr &a)

class Tanh : public popops::expr::UnaryOp 

Public Functions

inline Tanh(const Expr &a)

class TernaryOp : public popops::expr::ExprType<TernaryOp>

#include <Expr.hpp>

A class to represent expressions with ternary operators.

Subclassed by popops::expr::Clamp, popops::expr::Select

Public Functions

inline TernaryOp(TernaryOpType type, const Expr &a, const Expr &b, const Expr &c)

TernaryOp(TernaryOp&&) = default

TernaryOp &operator=(TernaryOp&&) = default

inline TernaryOp(const TernaryOp &other)

inline TernaryOp &operator=(const TernaryOp &other)

inline TernaryOpType getOpType() const

inline const Expr &getArg0() const

inline const Expr &getArg1() const

inline const Expr &getArg2() const

inline virtual std::unique_ptr<Expr> clone() const override

virtual std::string name(const std::vector<poplar::Tensor> &inputs) const override

inline std::string exprName(const std::vector<poplar::Tensor> &inputs) const

virtual bool deepEquals(const Expr &other) const override

virtual void print(std::ostream &os, unsigned indent = 0, bool prettyPrint = true) const override

Private Members

TernaryOpType type

std::unique_ptr<Expr> a

std::unique_ptr<Expr> b

std::unique_ptr<Expr> c

class Trunc : public popops::expr::UnaryOp 

Public Functions

inline Trunc(const Expr &a)

class UnaryOp : public popops::expr::ExprType<UnaryOp>

#include <Expr.hpp>

A class to represent expressions with unary operators.

Subclassed by popops::expr::Abs, popops::expr::Asin, popops::expr::BitwiseNot, popops::expr::Cbrt, popops::expr::Ceil, popops::expr::Cos, popops::expr::Erf, popops::expr::Exp, popops::expr::Exp2, popops::expr::Expm1, popops::expr::Floor, popops::expr::GeluErf, popops::expr::Inv, popops::expr::IsFinite, popops::expr::IsInf, popops::expr::IsNaN, popops::expr::Log, popops::expr::Log1p, popops::expr::NearbyInt, popops::expr::Neg, popops::expr::Not, popops::expr::Round, popops::expr::Rsqrt, popops::expr::Sigmoid, popops::expr::Signum, popops::expr::Sin, popops::expr::Sqrt, popops::expr::Square, popops::expr::Tan, popops::expr::Tanh, popops::expr::Trunc

Public Functions

inline UnaryOp(UnaryOpType type, const Expr &a)

UnaryOp(UnaryOp&&) = default

UnaryOp &operator=(UnaryOp&&) = default

inline UnaryOp(const UnaryOp &other)

inline UnaryOp &operator=(const UnaryOp &other)

inline UnaryOpType getOpType() const

inline const Expr &getArg() const

inline virtual std::unique_ptr<Expr> clone() const override

virtual std::string name(const std::vector<poplar::Tensor> &inputs) const override

inline std::string exprName(const std::vector<poplar::Tensor> &inputs) const

virtual bool deepEquals(const Expr &other) const override

virtual void print(std::ostream &os, unsigned indent = 0, bool prettyPrint = true) const override

Private Members

UnaryOpType type

std::unique_ptr<Expr> a

class VarianceToInvStdDev : public popops::expr::BinaryOp 

Public Functions

inline VarianceToInvStdDev(const Expr &a, const Expr &b)

Search help

Expr