ElementWise.hpp

Go to the documentation of this file.

// Copyright (c) 2017 Graphcore Ltd. All rights reserved.
#ifndef popops_ElementWise_hpp
#define popops_ElementWise_hpp
 
#include <poplar/Graph.hpp>
#include <poplar/OptionFlags.hpp>
#include <poplar/Program.hpp>
#include <popops/Expr.hpp>
#include <poputil/DebugInfo.hpp>
#include <string>
 
namespace poputil {
template <>
poplar::ProfileValue toProfileValue(const popops::expr::UnaryOpType &op);
template <>
poplar::ProfileValue toProfileValue(const popops::expr::BinaryOpType &op);
template <>
poplar::ProfileValue toProfileValue(const popops::expr::TernaryOpType &op);
} // namespace poputil
 
namespace popops {
 
// Elementwise operations.
 
/* Variance conversion operations can be created using the map functions,
 *  but that requires the input and output to be of the same type.
 *  It can be an advantage to maintain variance in full precision and
 *  inverse standard deviation in half precision. These supplementary functions
 *  make that possible.
 */
poplar::Tensor
varianceToInvStdDev(poplar::Graph &graph, const poplar::Tensor &src,
                    const poplar::Tensor &epsilon,
                    poplar::program::Sequence &prog,
                    const poplar::Type dstType = poplar::HALF,
                    const poplar::DebugContext &debugContext = {});
 
poplar::Tensor
varianceToInvStdDev(poplar::Graph &graph, const poplar::Tensor &src,
                    const float epsilon, poplar::program::Sequence &prog,
                    const poplar::Type dstType = poplar::HALF,
                    const poplar::DebugContext &debugContext = {});
poplar::Tensor
invStdDevToVariance(poplar::Graph &graph, const poplar::Tensor &src,
                    const poplar::Tensor &epsilon,
                    poplar::program::Sequence &prog,
                    const poplar::Type dstType = poplar::FLOAT,
                    const poplar::DebugContext &debugContext = {});
 
poplar::Tensor
invStdDevToVariance(poplar::Graph &graph, const poplar::Tensor &src,
                    const float epsilon, poplar::program::Sequence &prog,
                    const poplar::Type dstType = poplar::FLOAT,
                    const poplar::DebugContext &debugContext = {});
/*[INTERNAL]
 *    * `enableVectorBroadcastOptimisations` (true, false) [=true]
 *
 *      This option is only applicable if `expr` is a binary operation. If true,
 *      vector broadcasts are optimised by attempting to find the most efficient
 *      way to perform the binary operation on each tile.
 *
 *    * `forceGenerateCodelet` (true, false) [=false]
 *
 *      Always generates codelets regardless of the expression and input
 *      tensors. Intended for testing only.
 *
 *    * `enableExpressionOptimizations' (true, false_ [=true])
 *
 *      Optimize expressions to simplify them where possible.
 */
poplar::Tensor map(poplar::Graph &graph, const expr::Expr &expr,
                   const std::vector<poplar::Tensor> &ts,
                   poplar::program::Sequence &prog,
                   const poplar::DebugContext &debugContext = {},
                   const poplar::OptionFlags &options = {});
 
inline poplar::Tensor map(poplar::Graph &graph, expr::UnaryOpType op,
                          const poplar::Tensor &t,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
 
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(op, t, options));
  auto output =
      map(graph, expr::UnaryOp(op, expr::_1), {t}, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline poplar::Tensor map(poplar::Graph &graph, expr::BinaryOpType op,
                          const poplar::Tensor &a, const poplar::Tensor &b,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(op, a, b, options));
  auto output = map(graph, expr::BinaryOp(op, expr::_1, expr::_2), {a, b}, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
 
inline poplar::Tensor map(poplar::Graph &graph, expr::TernaryOpType op,
                          const poplar::Tensor &a, const poplar::Tensor &b,
                          const poplar::Tensor &c,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(op, a, b, c, options));
  auto output = map(graph, expr::TernaryOp(op, expr::_1, expr::_2, expr::_3),
                    {a, b, c}, prog, {di}, options);
  di.addOutput(output);
  return output;
}
void mapInPlace(poplar::Graph &graph, const expr::Expr &expr,
                const std::vector<poplar::Tensor> &ts,
                poplar::program::Sequence &prog,
                const poplar::DebugContext &debugContext = {},
                const poplar::OptionFlags &options = {});
 
inline void mapInPlace(poplar::Graph &graph, expr::UnaryOpType op,
                       const poplar::Tensor &t, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(op, t, options));
 
  mapInPlace(graph, expr::UnaryOp(op, expr::_1), {t}, prog, {di}, options);
}
 
inline void mapInPlace(poplar::Graph &graph, expr::BinaryOpType op,
                       const poplar::Tensor &a, const poplar::Tensor &b,
                       poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(op, a, b, options));
 
  mapInPlace(graph, expr::BinaryOp(op, expr::_1, expr::_2), {a, b}, prog, {di},
             options);
}
 
inline void mapInPlace(poplar::Graph &graph, expr::TernaryOpType op,
                       const poplar::Tensor &a, const poplar::Tensor &b,
                       const poplar::Tensor &c, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(op, a, b, c, options));
 
  mapInPlace(graph, expr::TernaryOp(op, expr::_1, expr::_2, expr::_3),
             {a, b, c}, prog, {di}, options);
}
void mapWithOutput(poplar::Graph &graph, const expr::Expr &expr,
                   const std::vector<poplar::Tensor> &ts,
                   const poplar::Tensor &out, poplar::program::Sequence &prog,
                   const poplar::DebugContext &debugContext = {},
                   const poplar::OptionFlags &options = {});
 
inline void mapWithOutput(poplar::Graph &graph, expr::UnaryOpType op,
                          const poplar::Tensor &in, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(op, in, out, options));
 
  mapWithOutput(graph, expr::UnaryOp(op, expr::_1), {in}, out, prog, {di},
                options);
}
 
inline void mapWithOutput(poplar::Graph &graph, expr::BinaryOpType op,
                          const poplar::Tensor &a, const poplar::Tensor &b,
                          const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(op, a, b, out, options));
 
  mapWithOutput(graph, expr::BinaryOp(op, expr::_1, expr::_2), {a, b}, out,
                prog, {di}, options);
}
 
inline void mapWithOutput(poplar::Graph &graph, expr::TernaryOpType op,
                          const poplar::Tensor &a, const poplar::Tensor &b,
                          const poplar::Tensor &c, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext,
                                 DI_ARGS(op, a, b, c, out, options));
 
  mapWithOutput(graph, expr::TernaryOp(op, expr::_1, expr::_2, expr::_3),
                {a, b, c}, out, prog, {di}, options);
}
 
void outputGeneratedCodelet(const poplar::Target &target,
                            const expr::Expr &expr,
                            const std::vector<poplar::Tensor> &ts,
                            const poplar::OptionFlags &options,
                            std::ostream &os);
 
// Unary operations
 
inline poplar::Tensor abs(poplar::Graph &graph, const poplar::Tensor &A,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::ABSOLUTE, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void absInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::ABSOLUTE, A, prog, {di}, options);
}
 
inline void absWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::ABSOLUTE, A, out, prog, {di},
                options);
}
inline poplar::Tensor asin(poplar::Graph &graph, const poplar::Tensor &A,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::ASIN, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void asinInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                        poplar::program::Sequence &prog,
                        const poplar::DebugContext &debugContext = {},
                        const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::ASIN, A, prog, {di}, options);
}
 
inline void asinWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                           const poplar::Tensor &out,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::ASIN, A, out, prog, {di}, options);
}
 
inline poplar::Tensor bitwiseNot(poplar::Graph &graph, const poplar::Tensor &A,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output =
      map(graph, expr::UnaryOpType::BITWISE_NOT, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void bitwiseNotInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                              poplar::program::Sequence &prog,
                              const poplar::DebugContext &debugContext = {},
                              const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::BITWISE_NOT, A, prog, {di}, options);
}
 
inline void bitwiseNotWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                 const poplar::Tensor &out,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::BITWISE_NOT, A, out, prog, {di},
                options);
}
 
inline poplar::Tensor cbrt(poplar::Graph &graph, const poplar::Tensor &A,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::CBRT, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void cbrtInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                        poplar::program::Sequence &prog,
                        const poplar::DebugContext &debugContext = {},
                        const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::CBRT, A, prog, {di}, options);
}
 
inline void cbrtWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                           const poplar::Tensor &out,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::CBRT, A, out, prog, {di}, options);
}
 
inline poplar::Tensor geluErf(poplar::Graph &graph, const poplar::Tensor &A,
                              poplar::program::Sequence &prog,
                              const poplar::DebugContext &debugContext = {},
                              const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::GELU_ERF, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void geluErfInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::GELU_ERF, A, prog, {di}, options);
}
 
inline void geluErfWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                              const poplar::Tensor &out,
                              poplar::program::Sequence &prog,
                              const poplar::DebugContext &debugContext = {},
                              const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::GELU_ERF, A, out, prog, {di},
                options);
}
 
inline poplar::Tensor ceil(poplar::Graph &graph, const poplar::Tensor &A,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::CEIL, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void ceilInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                        poplar::program::Sequence &prog,
                        const poplar::DebugContext &debugContext = {},
                        const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::CEIL, A, prog, {di}, options);
}
 
inline void ceilWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                           const poplar::Tensor &out,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::CEIL, A, out, prog, {di}, options);
}
 
inline poplar::Tensor
countLeadingZeros(poplar::Graph &graph, const poplar::Tensor &A,
                  poplar::program::Sequence &prog,
                  const poplar::DebugContext &debugContext = {},
                  const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::COUNT_LEADING_ZEROS, A, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void
countLeadingZerosInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::COUNT_LEADING_ZEROS, A, prog, {di},
             options);
}
 
inline void
countLeadingZerosWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                            const poplar::Tensor &out,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::COUNT_LEADING_ZEROS, A, out, prog,
                {di}, options);
}
 
inline poplar::Tensor cos(poplar::Graph &graph, const poplar::Tensor &A,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
  auto output = map(graph, expr::UnaryOpType::COS, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void cosInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
  mapInPlace(graph, expr::UnaryOpType::COS, A, prog, {di}, options);
}
 
inline void cosWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
  mapWithOutput(graph, expr::UnaryOpType::COS, A, out, prog, {di}, options);
}
 
inline poplar::Tensor erf(poplar::Graph &graph, const poplar::Tensor &A,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
  auto output = map(graph, expr::UnaryOpType::ERF, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void erfInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
  mapInPlace(graph, expr::UnaryOpType::ERF, A, prog, {di}, options);
}
 
inline void erfWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
  mapWithOutput(graph, expr::UnaryOpType::ERF, A, out, prog, {di}, options);
}
 
inline poplar::Tensor exp(poplar::Graph &graph, const poplar::Tensor &A,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
  auto output = map(graph, expr::UnaryOpType::EXPONENT, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void expInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
  mapInPlace(graph, expr::UnaryOpType::EXPONENT, A, prog, {di}, options);
}
 
inline void expWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
  mapWithOutput(graph, expr::UnaryOpType::EXPONENT, A, out, prog, {di},
                options);
}
 
inline poplar::Tensor expm1(poplar::Graph &graph, const poplar::Tensor &A,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
  auto output =
      map(graph, expr::UnaryOpType::EXPONENT_MINUS_ONE, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void expm1InPlace(poplar::Graph &graph, const poplar::Tensor &A,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
  mapInPlace(graph, expr::UnaryOpType::EXPONENT_MINUS_ONE, A, prog, {di},
             options);
}
 
inline void expm1WithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                            const poplar::Tensor &out,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
  mapWithOutput(graph, expr::UnaryOpType::EXPONENT_MINUS_ONE, A, out, prog,
                {di}, options);
}
 
inline poplar::Tensor floor(poplar::Graph &graph, const poplar::Tensor &A,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
  auto output = map(graph, expr::UnaryOpType::FLOOR, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void floorInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
  mapInPlace(graph, expr::UnaryOpType::FLOOR, A, prog, {di}, options);
}
 
inline void floorWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                            const poplar::Tensor &out,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
  mapWithOutput(graph, expr::UnaryOpType::FLOOR, A, out, prog, {di}, options);
}
 
inline poplar::Tensor inv(poplar::Graph &graph, const poplar::Tensor &A,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
  auto output = map(graph, expr::UnaryOpType::INVERSE, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void invInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
  mapInPlace(graph, expr::UnaryOpType::INVERSE, A, prog, {di}, options);
}
 
inline void invWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
  mapWithOutput(graph, expr::UnaryOpType::INVERSE, A, out, prog, {di}, options);
}
 
inline poplar::Tensor log(poplar::Graph &graph, const poplar::Tensor &A,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output =
      map(graph, expr::UnaryOpType::LOGARITHM, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void logInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::LOGARITHM, A, prog, {di}, options);
}
 
inline void logWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::LOGARITHM, A, out, prog, {di},
                options);
}
 
inline poplar::Tensor log1p(poplar::Graph &graph, const poplar::Tensor &A,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output =
      map(graph, expr::UnaryOpType::LOGARITHM_ONE_PLUS, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void log1pInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::LOGARITHM_ONE_PLUS, A, prog, {di},
             options);
}
 
inline void log1pWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                            const poplar::Tensor &out,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::LOGARITHM_ONE_PLUS, A, out, prog,
                {di}, options);
}
 
inline poplar::Tensor logicalNot(poplar::Graph &graph, const poplar::Tensor &A,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output =
      map(graph, expr::UnaryOpType::LOGICAL_NOT, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void logicalNotInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                              poplar::program::Sequence &prog,
                              const poplar::DebugContext &debugContext = {},
                              const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::LOGICAL_NOT, A, prog, {di}, options);
}
 
inline void logicalNotWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                 const poplar::Tensor &out,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::LOGICAL_NOT, A, out, prog, {di},
                options);
}
 
inline poplar::Tensor neg(poplar::Graph &graph, const poplar::Tensor &A,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::NEGATE, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void negInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::NEGATE, A, prog, {di}, options);
}
 
inline void negWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::NEGATE, A, out, prog, {di}, options);
}
 
inline poplar::Tensor popcount(poplar::Graph &graph, const poplar::Tensor &A,
                               poplar::program::Sequence &prog,
                               const poplar::DebugContext &debugContext = {},
                               const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::POPCOUNT, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void popcountInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::POPCOUNT, A, prog, {di}, options);
}
 
inline void popcountWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                               const poplar::Tensor &out,
                               poplar::program::Sequence &prog,
                               const poplar::DebugContext &debugContext = {},
                               const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::POPCOUNT, A, out, prog, {di},
                options);
}
 
inline poplar::Tensor signum(poplar::Graph &graph, const poplar::Tensor &A,
                             poplar::program::Sequence &prog,
                             const poplar::DebugContext &debugContext = {},
                             const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::SIGNUM, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void signumInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::SIGNUM, A, prog, {di}, options);
}
 
inline void signumWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                             const poplar::Tensor &out,
                             poplar::program::Sequence &prog,
                             const poplar::DebugContext &debugContext = {},
                             const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::SIGNUM, A, out, prog, {di}, options);
}
 
inline poplar::Tensor sin(poplar::Graph &graph, const poplar::Tensor &A,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::SIN, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void sinInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::SIN, A, prog, {di}, options);
}
 
inline void sinWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::SIN, A, out, prog, {di}, options);
}
 
inline poplar::Tensor tan(poplar::Graph &graph, const poplar::Tensor &A,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::TAN, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void tanInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::TAN, A, prog, {di}, options);
}
 
inline void tanWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::TAN, A, out, prog, {di}, options);
}
 
inline poplar::Tensor tanh(poplar::Graph &graph, const poplar::Tensor &A,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::TANH, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void tanhInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                        poplar::program::Sequence &prog,
                        const poplar::DebugContext &debugContext = {},
                        const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::TANH, A, prog, {di}, options);
}
 
inline void tanhWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                           const poplar::Tensor &out,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::TANH, A, out, prog, {di}, options);
}
 
inline poplar::Tensor round(poplar::Graph &graph, const poplar::Tensor &A,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::ROUND, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void roundInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::ROUND, A, prog, {di}, options);
}
 
inline void roundWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                            const poplar::Tensor &out,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::ROUND, A, out, prog, {di}, options);
}
 
inline poplar::Tensor sqrt(poplar::Graph &graph, const poplar::Tensor &A,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::SQRT, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void sqrtInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                        poplar::program::Sequence &prog,
                        const poplar::DebugContext &debugContext = {},
                        const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::SQRT, A, prog, {di}, options);
}
 
inline void sqrtWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                           const poplar::Tensor &out,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::SQRT, A, out, prog, {di}, options);
}
 
inline poplar::Tensor square(poplar::Graph &graph, const poplar::Tensor &A,
                             poplar::program::Sequence &prog,
                             const poplar::DebugContext &debugContext = {},
                             const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::SQUARE, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void squareInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::SQUARE, A, prog, {di}, options);
}
 
inline void squareWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                             const poplar::Tensor &out,
                             poplar::program::Sequence &prog,
                             const poplar::DebugContext &debugContext = {},
                             const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::SQUARE, A, out, prog, {di}, options);
}
 
inline poplar::Tensor sigmoid(poplar::Graph &graph, const poplar::Tensor &A,
                              poplar::program::Sequence &prog,
                              const poplar::DebugContext &debugContext = {},
                              const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::SIGMOID, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void sigmoidInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::SIGMOID, A, prog, {di}, options);
}
 
inline void sigmoidWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                              const poplar::Tensor &out,
                              poplar::program::Sequence &prog,
                              const poplar::DebugContext &debugContext = {},
                              const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::SIGMOID, A, out, prog, {di}, options);
}
 
inline poplar::Tensor rsqrt(poplar::Graph &graph, const poplar::Tensor &A,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output = map(graph, expr::UnaryOpType::RSQRT, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void rsqrtInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  mapInPlace(graph, expr::UnaryOpType::RSQRT, A, prog, {di}, options);
}
 
inline void rsqrtWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                            const poplar::Tensor &out,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
 
  mapWithOutput(graph, expr::UnaryOpType::RSQRT, A, out, prog, {di}, options);
}
 
inline poplar::Tensor isFinite(poplar::Graph &graph, const poplar::Tensor &A,
                               poplar::program::Sequence &prog,
                               const poplar::DebugContext &debugContext = {},
                               const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, options));
 
  auto output =
      map(graph, expr::UnaryOpType::IS_FINITE, A, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void isFiniteWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                               const poplar::Tensor &out,
                               poplar::program::Sequence &prog,
                               const poplar::DebugContext &debugContext = {},
                               const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, out, options));
  mapWithOutput(graph, expr::UnaryOpType::IS_FINITE, A, out, prog, {di},
                options);
}
 
template <typename constType>
inline void checkTypes(poplar::Type elementType, constType) {
  if (elementType != poplar::equivalent_device_type<constType>().value) {
    throw std::runtime_error("Type mismatch between Binary op Tensor "
                             "and constant");
  }
}
 
template <> inline void checkTypes<float>(poplar::Type elementType, float) {
  if (elementType != poplar::FLOAT && elementType != poplar::HALF) {
    throw std::runtime_error("Type mismatch between Binary op Tensor "
                             "and constant");
  }
  return;
}
 
template <> inline void checkTypes<double>(poplar::Type elementType, double) {
  if (elementType != poplar::FLOAT && elementType != poplar::HALF) {
    throw std::runtime_error("Type mismatch between Binary op Tensor "
                             "and constant");
  }
  return;
}
// Binary operations
 
inline poplar::Tensor add(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output = map(graph, expr::BinaryOpType::ADD, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor add(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::ADD, A, BTensor, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor add(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::ADD, ATensor, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
inline void addInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const poplar::Tensor &B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::ADD, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void addInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const constType B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::ADD, A, BTensor, prog, {di}, options);
}
inline void addWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::ADD, A, B, out, prog, {di}, options);
}
 
template <typename constType>
inline void addWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::ADD, A, BTensor, out, prog, {di},
                options);
}
 
template <typename constType>
inline void addWithOutput(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::ADD, ATensor, B, out, prog, {di},
                options);
}
inline poplar::Tensor atan2(poplar::Graph &graph, const poplar::Tensor &A,
                            const poplar::Tensor &B,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::ATAN2, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor atan2(poplar::Graph &graph, const poplar::Tensor &A,
                            const constType B, poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::ATAN2, A, BTensor, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor atan2(poplar::Graph &graph, const constType A,
                            const poplar::Tensor &B,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::ATAN2, ATensor, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
inline void atan2InPlace(poplar::Graph &graph, const poplar::Tensor &A,
                         const poplar::Tensor &B,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::ATAN2, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void atan2InPlace(poplar::Graph &graph, const poplar::Tensor &A,
                         const constType B, poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::ATAN2, A, BTensor, prog, {di}, options);
}
inline void atan2WithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                            const poplar::Tensor &B, const poplar::Tensor &out,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::ATAN2, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void atan2WithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                            const constType B, const poplar::Tensor &out,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::ATAN2, A, BTensor, out, prog, {di},
                options);
}
 
template <typename constType>
inline void atan2WithOutput(poplar::Graph &graph, const constType A,
                            const poplar::Tensor &B, const poplar::Tensor &out,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::ATAN2, ATensor, B, out, prog, {di},
                options);
}
inline poplar::Tensor bitwiseAnd(poplar::Graph &graph, const poplar::Tensor &A,
                                 const poplar::Tensor &B,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::BITWISE_AND, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor bitwiseAnd(poplar::Graph &graph, const poplar::Tensor &A,
                                 const constType B,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::BITWISE_AND, A, BTensor, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
template <typename constType>
inline poplar::Tensor bitwiseAnd(poplar::Graph &graph, const constType A,
                                 const poplar::Tensor &B,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::BITWISE_AND, ATensor, B, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
inline void bitwiseAndInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                              const poplar::Tensor &B,
                              poplar::program::Sequence &prog,
                              const poplar::DebugContext &debugContext = {},
                              const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::BITWISE_AND, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void bitwiseAndInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                              const constType B,
                              poplar::program::Sequence &prog,
                              const poplar::DebugContext &debugContext = {},
                              const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::BITWISE_AND, A, BTensor, prog, {di},
             options);
}
inline void bitwiseAndWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                 const poplar::Tensor &B,
                                 const poplar::Tensor &out,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::BITWISE_AND, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void bitwiseAndWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                 const constType B, const poplar::Tensor &out,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::BITWISE_AND, A, BTensor, out, prog,
                {di}, options);
}
template <typename constType>
inline void bitwiseAndWithOutput(poplar::Graph &graph, const constType A,
                                 const poplar::Tensor &B,
                                 const poplar::Tensor &out,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::BITWISE_AND, ATensor, B, out, prog,
                {di}, options);
}
inline poplar::Tensor bitwiseOr(poplar::Graph &graph, const poplar::Tensor &A,
                                const poplar::Tensor &B,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::BITWISE_OR, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor bitwiseOr(poplar::Graph &graph, const poplar::Tensor &A,
                                const constType B,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::BITWISE_OR, A, BTensor, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor bitwiseOr(poplar::Graph &graph, const constType A,
                                const poplar::Tensor &B,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::BITWISE_OR, ATensor, B, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
inline void bitwiseOrInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                             const poplar::Tensor &B,
                             poplar::program::Sequence &prog,
                             const poplar::DebugContext &debugContext = {},
                             const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::BITWISE_OR, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void bitwiseOrInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                             const constType B, poplar::program::Sequence &prog,
                             const poplar::DebugContext &debugContext = {},
                             const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::BITWISE_OR, A, BTensor, prog, {di},
             options);
}
inline void bitwiseOrWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                const poplar::Tensor &B,
                                const poplar::Tensor &out,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::BITWISE_OR, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void bitwiseOrWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                const constType B, const poplar::Tensor &out,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::BITWISE_OR, A, BTensor, out, prog,
                {di}, options);
}
 
template <typename constType>
inline void bitwiseOrWithOutput(poplar::Graph &graph, const constType A,
                                const poplar::Tensor &B,
                                const poplar::Tensor &out,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::BITWISE_OR, ATensor, B, out, prog,
                {di}, options);
}
inline poplar::Tensor bitwiseXor(poplar::Graph &graph, const poplar::Tensor &A,
                                 const poplar::Tensor &B,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::BITWISE_XOR, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor bitwiseXor(poplar::Graph &graph, const poplar::Tensor &A,
                                 const constType B,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::BITWISE_XOR, A, BTensor, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor bitwiseXor(poplar::Graph &graph, const constType A,
                                 const poplar::Tensor &B,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::BITWISE_XOR, ATensor, B, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
inline void bitwiseXorInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                              const poplar::Tensor &B,
                              poplar::program::Sequence &prog,
                              const poplar::DebugContext &debugContext = {},
                              const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::BITWISE_XOR, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void bitwiseXorInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                              const constType B,
                              poplar::program::Sequence &prog,
                              const poplar::DebugContext &debugContext = {},
                              const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::BITWISE_XOR, A, BTensor, prog, {di},
             options);
}
inline void bitwiseXorWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                 const poplar::Tensor &B,
                                 const poplar::Tensor &out,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::BITWISE_XOR, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void bitwiseXorWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                 const constType B, const poplar::Tensor &out,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::BITWISE_XOR, A, BTensor, out, prog,
                {di}, options);
}
 
template <typename constType>
inline void bitwiseXorWithOutput(poplar::Graph &graph, const constType A,
                                 const poplar::Tensor &B,
                                 const poplar::Tensor &out,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::BITWISE_XOR, ATensor, B, out, prog,
                {di}, options);
}
inline poplar::Tensor bitwiseXnor(poplar::Graph &graph, const poplar::Tensor &A,
                                  const poplar::Tensor &B,
                                  poplar::program::Sequence &prog,
                                  const poplar::DebugContext &debugContext = {},
                                  const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::BITWISE_XNOR, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor bitwiseXnor(poplar::Graph &graph, const poplar::Tensor &A,
                                  const constType B,
                                  poplar::program::Sequence &prog,
                                  const poplar::DebugContext &debugContext = {},
                                  const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::BITWISE_XNOR, A, BTensor, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor bitwiseXnor(poplar::Graph &graph, const constType A,
                                  const poplar::Tensor &B,
                                  poplar::program::Sequence &prog,
                                  const poplar::DebugContext &debugContext = {},
                                  const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::BITWISE_XNOR, ATensor, B, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void bitwiseXnorInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                               const poplar::Tensor &B,
                               poplar::program::Sequence &prog,
                               const poplar::DebugContext &debugContext = {},
                               const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::BITWISE_XNOR, A, B, prog, {di},
             options);
}
 
template <typename constType>
inline void bitwiseXnorInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                               const constType B,
                               poplar::program::Sequence &prog,
                               const poplar::DebugContext &debugContext = {},
                               const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::BITWISE_XNOR, A, BTensor, prog, {di},
             options);
}
inline void bitwiseXnorWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                  const poplar::Tensor &B,
                                  const poplar::Tensor &out,
                                  poplar::program::Sequence &prog,
                                  const poplar::DebugContext &debugContext = {},
                                  const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::BITWISE_XNOR, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void bitwiseXnorWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                  const constType B, const poplar::Tensor &out,
                                  poplar::program::Sequence &prog,
                                  const poplar::DebugContext &debugContext = {},
                                  const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::BITWISE_XNOR, A, BTensor, out, prog,
                {di}, options);
}
 
template <typename constType>
inline void bitwiseXnorWithOutput(poplar::Graph &graph, const constType A,
                                  const poplar::Tensor &B,
                                  const poplar::Tensor &out,
                                  poplar::program::Sequence &prog,
                                  const poplar::DebugContext &debugContext = {},
                                  const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::BITWISE_XNOR, ATensor, B, out, prog,
                {di}, options);
}
 
inline poplar::Tensor div(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::DIVIDE, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor div(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::DIVIDE, A, BTensor, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor div(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::DIVIDE, ATensor, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
inline void divInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const poplar::Tensor &B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::DIVIDE, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void divInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const constType B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::DIVIDE, A, BTensor, prog, {di},
             options);
}
inline void divWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::DIVIDE, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void divWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::DIVIDE, A, BTensor, out, prog, {di},
                options);
}
 
template <typename constType>
inline void divWithOutput(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::DIVIDE, ATensor, B, out, prog, {di},
                options);
}
inline poplar::Tensor eq(poplar::Graph &graph, const poplar::Tensor &A,
                         const poplar::Tensor &B,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::EQUAL, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor eq(poplar::Graph &graph, const poplar::Tensor &A,
                         const constType B, poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::EQUAL, A, BTensor, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor eq(poplar::Graph &graph, const constType A,
                         const poplar::Tensor &B,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::EQUAL, ATensor, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
inline void eqInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                      const poplar::Tensor &B, poplar::program::Sequence &prog,
                      const poplar::DebugContext &debugContext = {},
                      const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::EQUAL, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void eqInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                      const constType B, poplar::program::Sequence &prog,
                      const poplar::DebugContext &debugContext = {},
                      const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::EQUAL, A, BTensor, prog, {di}, options);
}
inline void eqWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                         const poplar::Tensor &B, const poplar::Tensor &out,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::EQUAL, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void eqWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                         const constType B, const poplar::Tensor &out,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::EQUAL, A, BTensor, out, prog, {di},
                options);
}
 
template <typename constType>
inline void eqWithOutput(poplar::Graph &graph, const constType A,
                         const poplar::Tensor &B, const poplar::Tensor &out,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::EQUAL, ATensor, B, out, prog, {di},
                options);
}
inline poplar::Tensor gteq(poplar::Graph &graph, const poplar::Tensor &A,
                           const poplar::Tensor &B,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output = map(graph, expr::BinaryOpType::GREATER_THAN_EQUAL, A, B, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor gteq(poplar::Graph &graph, const poplar::Tensor &A,
                           const constType B, poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::GREATER_THAN_EQUAL, A, BTensor,
                    prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor gteq(poplar::Graph &graph, const constType A,
                           const poplar::Tensor &B,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::GREATER_THAN_EQUAL, ATensor, B,
                    prog, {di}, options);
  di.addOutput(output);
  return output;
}
inline void gteqInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                        const poplar::Tensor &B,
                        poplar::program::Sequence &prog,
                        const poplar::DebugContext &debugContext = {},
                        const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::GREATER_THAN_EQUAL, A, B, prog, {di},
             options);
}
 
template <typename constType>
inline void gteqInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                        const constType B, poplar::program::Sequence &prog,
                        const poplar::DebugContext &debugContext = {},
                        const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::GREATER_THAN_EQUAL, A, BTensor, prog,
             {di}, options);
}
inline void gteqWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                           const poplar::Tensor &B, const poplar::Tensor &out,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::GREATER_THAN_EQUAL, A, B, out, prog,
                {di}, options);
}
 
template <typename constType>
inline void gteqWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                           const constType B, const poplar::Tensor &out,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::GREATER_THAN_EQUAL, A, BTensor, out,
                prog, {di}, options);
}
 
template <typename constType>
inline void gteqWithOutput(poplar::Graph &graph, const constType A,
                           const poplar::Tensor &B, const poplar::Tensor &out,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::GREATER_THAN_EQUAL, ATensor, B, out,
                prog, {di}, options);
}
inline poplar::Tensor gt(poplar::Graph &graph, const poplar::Tensor &A,
                         const poplar::Tensor &B,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::GREATER_THAN, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor gt(poplar::Graph &graph, const poplar::Tensor &A,
                         const constType B, poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::GREATER_THAN, A, BTensor, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor gt(poplar::Graph &graph, const constType A,
                         const poplar::Tensor &B,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::GREATER_THAN, ATensor, B, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
inline void gtInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                      const poplar::Tensor &B, poplar::program::Sequence &prog,
                      const poplar::DebugContext &debugContext = {},
                      const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::GREATER_THAN, A, B, prog, {di},
             options);
}
 
template <typename constType>
inline void gtInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                      const constType B, poplar::program::Sequence &prog,
                      const poplar::DebugContext &debugContext = {},
                      const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::GREATER_THAN, A, BTensor, prog, {di},
             options);
}
inline void gtWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                         const poplar::Tensor &B, const poplar::Tensor &out,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::GREATER_THAN, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void gtWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                         const constType B, const poplar::Tensor &out,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::GREATER_THAN, A, BTensor, out, prog,
                {di}, options);
}
 
template <typename constType>
inline void gtWithOutput(poplar::Graph &graph, const constType A,
                         const poplar::Tensor &B, const poplar::Tensor &out,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::GREATER_THAN, ATensor, B, out, prog,
                {di}, options);
}
inline poplar::Tensor
invStdDevToVariance(poplar::Graph &graph, const poplar::Tensor &A,
                    const poplar::Tensor &B, poplar::program::Sequence &prog,
                    const poplar::DebugContext &debugContext = {},
                    const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output = map(graph, expr::BinaryOpType::INV_STD_DEV_TO_VARIANCE, A, B,
                    prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor
invStdDevToVariance(poplar::Graph &graph, const poplar::Tensor &A,
                    const constType B, poplar::program::Sequence &prog,
                    const poplar::DebugContext &debugContext = {},
                    const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::INV_STD_DEV_TO_VARIANCE, A,
                    BTensor, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor
invStdDevToVariance(poplar::Graph &graph, const constType A,
                    const poplar::Tensor &B, poplar::program::Sequence &prog,
                    const poplar::DebugContext &debugContext = {},
                    const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::INV_STD_DEV_TO_VARIANCE, ATensor,
                    B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
inline void
invStdDevToVarianceInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                           const poplar::Tensor &B,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::INV_STD_DEV_TO_VARIANCE, A, B, prog,
             {di}, options);
}
 
template <typename constType>
inline void
invStdDevToVarianceInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                           const constType B, poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::INV_STD_DEV_TO_VARIANCE, A, BTensor,
             prog, {di}, options);
}
inline void invStdDevToVarianceWithOutput(
    poplar::Graph &graph, const poplar::Tensor &A, const poplar::Tensor &B,
    const poplar::Tensor &out, poplar::program::Sequence &prog,
    const poplar::DebugContext &debugContext = {},
    const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::INV_STD_DEV_TO_VARIANCE, A, B, out,
                prog, {di}, options);
}
 
template <typename constType>
inline void
invStdDevToVarianceWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                              const constType B, const poplar::Tensor &out,
                              poplar::program::Sequence &prog,
                              const poplar::DebugContext &debugContext = {},
                              const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::INV_STD_DEV_TO_VARIANCE, A, BTensor,
                out, prog, {di}, options);
}
 
template <typename constType>
inline void invStdDevToVarianceWithOutput(
    poplar::Graph &graph, const constType A, const poplar::Tensor &B,
    const poplar::Tensor &out, poplar::program::Sequence &prog,
    const poplar::DebugContext &debugContext = {},
    const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::INV_STD_DEV_TO_VARIANCE, ATensor, B,
                out, prog, {di}, options);
}
inline poplar::Tensor lteq(poplar::Graph &graph, const poplar::Tensor &A,
                           const poplar::Tensor &B,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output = map(graph, expr::BinaryOpType::LESS_THAN_EQUAL, A, B, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor lteq(poplar::Graph &graph, const poplar::Tensor &A,
                           const constType B, poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::LESS_THAN_EQUAL, A, BTensor,
                    prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor lteq(poplar::Graph &graph, const constType A,
                           const poplar::Tensor &B,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::LESS_THAN_EQUAL, ATensor, B,
                    prog, {di}, options);
  di.addOutput(output);
  return output;
}
inline void lteqInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                        const poplar::Tensor &B,
                        poplar::program::Sequence &prog,
                        const poplar::DebugContext &debugContext = {},
                        const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::LESS_THAN_EQUAL, A, B, prog, {di},
             options);
}
 
template <typename constType>
inline void lteqInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                        const constType B, poplar::program::Sequence &prog,
                        const poplar::DebugContext &debugContext = {},
                        const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::LESS_THAN_EQUAL, A, BTensor, prog, {di},
             options);
}
inline void lteqWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                           const poplar::Tensor &B, const poplar::Tensor &out,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::LESS_THAN_EQUAL, A, B, out, prog,
                {di}, options);
}
 
template <typename constType>
inline void lteqWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                           const constType B, const poplar::Tensor &out,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::LESS_THAN_EQUAL, A, BTensor, out,
                prog, {di}, options);
}
 
template <typename constType>
inline void lteqWithOutput(poplar::Graph &graph, const constType A,
                           const poplar::Tensor &B, const poplar::Tensor &out,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::LESS_THAN_EQUAL, ATensor, B, out,
                prog, {di}, options);
}
inline poplar::Tensor logicalAnd(poplar::Graph &graph, const poplar::Tensor &A,
                                 const poplar::Tensor &B,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::LOGICAL_AND, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor logicalAnd(poplar::Graph &graph, const poplar::Tensor &A,
                                 const constType B,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::LOGICAL_AND, A, BTensor, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor logicalAnd(poplar::Graph &graph, const constType A,
                                 const poplar::Tensor &B,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::LOGICAL_AND, ATensor, B, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
inline void logicalAndInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                              const poplar::Tensor &B,
                              poplar::program::Sequence &prog,
                              const poplar::DebugContext &debugContext = {},
                              const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::LOGICAL_AND, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void logicalAndInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                              const constType B,
                              poplar::program::Sequence &prog,
                              const poplar::DebugContext &debugContext = {},
                              const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::LOGICAL_AND, A, BTensor, prog, {di},
             options);
}
inline void logicalAndWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                 const poplar::Tensor &B,
                                 const poplar::Tensor &out,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::LOGICAL_AND, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void logicalAndWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                 const constType B, const poplar::Tensor &out,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::LOGICAL_AND, A, BTensor, out, prog,
                {di}, options);
}
 
template <typename constType>
inline void logicalAndWithOutput(poplar::Graph &graph, const constType A,
                                 const poplar::Tensor &B,
                                 const poplar::Tensor &out,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::LOGICAL_AND, ATensor, B, out, prog,
                {di}, options);
}
inline poplar::Tensor logicalOr(poplar::Graph &graph, const poplar::Tensor &A,
                                const poplar::Tensor &B,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::LOGICAL_OR, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor logicalOr(poplar::Graph &graph, const poplar::Tensor &A,
                                const constType B,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::LOGICAL_OR, A, BTensor, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor logicalOr(poplar::Graph &graph, const constType A,
                                const poplar::Tensor &B,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::LOGICAL_OR, ATensor, B, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
inline void logicalOrInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                             const poplar::Tensor &B,
                             poplar::program::Sequence &prog,
                             const poplar::DebugContext &debugContext = {},
                             const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::LOGICAL_OR, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void logicalOrInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                             const constType B, poplar::program::Sequence &prog,
                             const poplar::DebugContext &debugContext = {},
                             const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::LOGICAL_OR, A, BTensor, prog, {di},
             options);
}
inline void logicalOrWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                const poplar::Tensor &B,
                                const poplar::Tensor &out,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::LOGICAL_OR, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void logicalOrWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                const constType B, const poplar::Tensor &out,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::LOGICAL_OR, A, BTensor, out, prog,
                {di}, options);
}
 
template <typename constType>
inline void logicalOrWithOutput(poplar::Graph &graph, const constType A,
                                const poplar::Tensor &B,
                                const poplar::Tensor &out,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::LOGICAL_OR, ATensor, B, out, prog,
                {di}, options);
}
inline poplar::Tensor lt(poplar::Graph &graph, const poplar::Tensor &A,
                         const poplar::Tensor &B,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::LESS_THAN, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor lt(poplar::Graph &graph, const poplar::Tensor &A,
                         const constType B, poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::LESS_THAN, A, BTensor, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor lt(poplar::Graph &graph, const constType A,
                         const poplar::Tensor &B,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::LESS_THAN, ATensor, B, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
inline void ltInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                      const poplar::Tensor &B, poplar::program::Sequence &prog,
                      const poplar::DebugContext &debugContext = {},
                      const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::LESS_THAN, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void ltInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                      const constType B, poplar::program::Sequence &prog,
                      const poplar::DebugContext &debugContext = {},
                      const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::LESS_THAN, A, BTensor, prog, {di},
             options);
}
inline void ltWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                         const poplar::Tensor &B, const poplar::Tensor &out,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::LESS_THAN, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void ltWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                         const constType B, const poplar::Tensor &out,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::LESS_THAN, A, BTensor, out, prog,
                {di}, options);
}
 
template <typename constType>
inline void ltWithOutput(poplar::Graph &graph, const constType A,
                         const poplar::Tensor &B, const poplar::Tensor &out,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::LESS_THAN, ATensor, B, out, prog,
                {di}, options);
}
inline poplar::Tensor max(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::MAXIMUM, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor max(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::MAXIMUM, A, BTensor, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor max(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::MAXIMUM, ATensor, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
inline void maxInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const poplar::Tensor &B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::MAXIMUM, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void maxInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const constType B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::MAXIMUM, A, BTensor, prog, {di},
             options);
}
inline void maxWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::MAXIMUM, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void maxWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::MAXIMUM, A, BTensor, out, prog, {di},
                options);
}
 
template <typename constType>
inline void maxWithOutput(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::MAXIMUM, ATensor, B, out, prog, {di},
                options);
}
inline poplar::Tensor min(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::MINIMUM, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor min(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::MINIMUM, A, BTensor, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor min(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::MINIMUM, ATensor, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
inline void minInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const poplar::Tensor &B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::MINIMUM, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void minInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const constType B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::MINIMUM, A, BTensor, prog, {di},
             options);
}
inline void minWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::MINIMUM, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void minWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::MINIMUM, A, BTensor, out, prog, {di},
                options);
}
 
template <typename constType>
inline void minWithOutoput(poplar::Graph &graph, const constType A,
                           const poplar::Tensor &B, const poplar::Tensor &out,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::MINIMUM, ATensor, B, out, prog, {di},
                options);
}
inline poplar::Tensor mul(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::MULTIPLY, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor mul(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::MULTIPLY, A, BTensor, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor mul(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::MULTIPLY, ATensor, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
inline void mulInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const poplar::Tensor &B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::MULTIPLY, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void mulInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const constType B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::MULTIPLY, A, BTensor, prog, {di},
             options);
}
inline void mulWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::MULTIPLY, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void mulWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::MULTIPLY, A, BTensor, out, prog,
                {di}, options);
}
 
template <typename constType>
inline void mulWithOutput(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::MULTIPLY, ATensor, B, out, prog,
                {di}, options);
}
inline poplar::Tensor neq(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::NOT_EQUAL, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor neq(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::NOT_EQUAL, A, BTensor, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor neq(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::NOT_EQUAL, ATensor, B, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
inline void neqInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const poplar::Tensor &B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::NOT_EQUAL, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void neqInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const constType B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::NOT_EQUAL, A, BTensor, prog, {di},
             options);
}
inline void neqWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::NOT_EQUAL, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void neqWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::NOT_EQUAL, A, BTensor, out, prog,
                {di}, options);
}
 
template <typename constType>
inline void neqWithOutput(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::NOT_EQUAL, ATensor, B, out, prog,
                {di}, options);
}
inline poplar::Tensor pow(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::POWER, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor pow(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::POWER, A, BTensor, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor pow(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::POWER, ATensor, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
inline void powInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const poplar::Tensor &B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::POWER, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void powInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const constType B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::POWER, A, BTensor, prog, {di}, options);
}
inline void powWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::POWER, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void powWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::POWER, A, BTensor, out, prog, {di},
                options);
}
 
template <typename constType>
inline void powWithOutput(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::POWER, ATensor, B, out, prog, {di},
                options);
}
inline poplar::Tensor rem(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::REMAINDER, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor rem(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::REMAINDER, A, BTensor, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor rem(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::REMAINDER, ATensor, B, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
inline void remInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const poplar::Tensor &B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::REMAINDER, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void remInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const constType B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::REMAINDER, A, BTensor, prog, {di},
             options);
}
inline void remWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::REMAINDER, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void remWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::REMAINDER, A, BTensor, out, prog,
                {di}, options);
}
 
template <typename constType>
inline void remWithOutput(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::REMAINDER, ATensor, B, out, prog,
                {di}, options);
}
inline poplar::Tensor shiftLeft(poplar::Graph &graph, const poplar::Tensor &A,
                                const poplar::Tensor &B,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::SHIFT_LEFT, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor shiftLeft(poplar::Graph &graph, const poplar::Tensor &A,
                                const constType B,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::SHIFT_LEFT, A, BTensor, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor shiftLeft(poplar::Graph &graph, const constType A,
                                const poplar::Tensor &B,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::SHIFT_LEFT, ATensor, B, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
inline void shiftLeftInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                             const poplar::Tensor &B,
                             poplar::program::Sequence &prog,
                             const poplar::DebugContext &debugContext = {},
                             const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::SHIFT_LEFT, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void shiftLeftInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                             const constType B, poplar::program::Sequence &prog,
                             const poplar::DebugContext &debugContext = {},
                             const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::SHIFT_LEFT, A, BTensor, prog, {di},
             options);
}
inline void shiftLeftWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                const poplar::Tensor &B,
                                const poplar::Tensor &out,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::SHIFT_LEFT, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void shiftLeftWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                const constType B, const poplar::Tensor &out,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::SHIFT_LEFT, A, BTensor, out, prog,
                {di}, options);
}
 
template <typename constType>
inline void shiftLeftWithOutput(poplar::Graph &graph, const constType A,
                                const poplar::Tensor &B,
                                const poplar::Tensor &out,
                                poplar::program::Sequence &prog,
                                const poplar::DebugContext &debugContext = {},
                                const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::SHIFT_LEFT, ATensor, B, out, prog,
                {di}, options);
}
inline poplar::Tensor shiftRight(poplar::Graph &graph, const poplar::Tensor &A,
                                 const poplar::Tensor &B,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::SHIFT_RIGHT, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor shiftRight(poplar::Graph &graph, const poplar::Tensor &A,
                                 const constType B,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::SHIFT_RIGHT, A, BTensor, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor shiftRight(poplar::Graph &graph, const constType A,
                                 const poplar::Tensor &B,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::SHIFT_RIGHT, ATensor, B, prog,
                    {di}, options);
  di.addOutput(output);
  return output;
}
inline void shiftRightInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                              const poplar::Tensor &B,
                              poplar::program::Sequence &prog,
                              const poplar::DebugContext &debugContext = {},
                              const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::SHIFT_RIGHT, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void shiftRightInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                              const constType B,
                              poplar::program::Sequence &prog,
                              const poplar::DebugContext &debugContext = {},
                              const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::SHIFT_RIGHT, A, BTensor, prog, {di},
             options);
}
inline void shiftRightWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                 const poplar::Tensor &B,
                                 const poplar::Tensor &out,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::SHIFT_RIGHT, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void shiftRightWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                                 const constType B, const poplar::Tensor &out,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::SHIFT_RIGHT, A, BTensor, out, prog,
                {di}, options);
}
template <typename constType>
inline void shiftRightWithOutput(poplar::Graph &graph, const constType A,
                                 const poplar::Tensor &B,
                                 const poplar::Tensor &out,
                                 poplar::program::Sequence &prog,
                                 const poplar::DebugContext &debugContext = {},
                                 const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::SHIFT_RIGHT, ATensor, B, out, prog,
                {di}, options);
}
 
inline poplar::Tensor
shiftRightSignExtend(poplar::Graph &graph, const poplar::Tensor &A,
                     const poplar::Tensor &B, poplar::program::Sequence &prog,
                     const poplar::DebugContext &debugContext = {},
                     const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output = map(graph, expr::BinaryOpType::SHIFT_RIGHT_SIGN_EXTEND, A, B,
                    prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor
shiftRightSignExtend(poplar::Graph &graph, const poplar::Tensor &A,
                     const constType B, poplar::program::Sequence &prog,
                     const poplar::DebugContext &debugContext = {},
                     const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::SHIFT_RIGHT_SIGN_EXTEND, A,
                    BTensor, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor
shiftRightSignExtend(poplar::Graph &graph, const constType A,
                     const poplar::Tensor &B, poplar::program::Sequence &prog,
                     const poplar::DebugContext &debugContext = {},
                     const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::SHIFT_RIGHT_SIGN_EXTEND, ATensor,
                    B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
inline void
shiftRightSignExtendInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                            const poplar::Tensor &B,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::SHIFT_RIGHT_SIGN_EXTEND, A, B, prog,
             {di}, options);
}
 
template <typename constType>
inline void
shiftRightSignExtendInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                            const constType B, poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::SHIFT_RIGHT_SIGN_EXTEND, A, BTensor,
             prog, {di}, options);
}
inline void shiftRightSignExtendWithOutput(
    poplar::Graph &graph, const poplar::Tensor &A, const poplar::Tensor &B,
    const poplar::Tensor &out, poplar::program::Sequence &prog,
    const poplar::DebugContext &debugContext = {},
    const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::SHIFT_RIGHT_SIGN_EXTEND, A, B, out,
                prog, {di}, options);
}
 
template <typename constType>
inline void
shiftRightSignExtendWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                               const constType B, const poplar::Tensor &out,
                               poplar::program::Sequence &prog,
                               const poplar::DebugContext &debugContext = {},
                               const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::SHIFT_RIGHT_SIGN_EXTEND, A, BTensor,
                out, prog, {di}, options);
}
 
template <typename constType>
inline void shiftRightSignExtendWithOutput(
    poplar::Graph &graph, const constType A, const poplar::Tensor &B,
    const poplar::Tensor &out, poplar::program::Sequence &prog,
    const poplar::DebugContext &debugContext = {},
    const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::SHIFT_RIGHT_SIGN_EXTEND, ATensor, B,
                out, prog, {di}, options);
}
inline poplar::Tensor sub(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output =
      map(graph, expr::BinaryOpType::SUBTRACT, A, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor sub(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::SUBTRACT, A, BTensor, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor sub(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output =
      map(graph, expr::BinaryOpType::SUBTRACT, ATensor, B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
inline void subInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const poplar::Tensor &B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::SUBTRACT, A, B, prog, {di}, options);
}
 
template <typename constType>
inline void subInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                       const constType B, poplar::program::Sequence &prog,
                       const poplar::DebugContext &debugContext = {},
                       const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::SUBTRACT, A, BTensor, prog, {di},
             options);
}
inline void subWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::SUBTRACT, A, B, out, prog, {di},
                options);
}
 
template <typename constType>
inline void subWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                          const constType B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::SUBTRACT, A, BTensor, out, prog,
                {di}, options);
}
 
template <typename constType>
inline void subWithOutput(poplar::Graph &graph, const constType A,
                          const poplar::Tensor &B, const poplar::Tensor &out,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::SUBTRACT, ATensor, B, out, prog,
                {di}, options);
}
inline poplar::Tensor
varianceToInvStdDev(poplar::Graph &graph, const poplar::Tensor &A,
                    const poplar::Tensor &B, poplar::program::Sequence &prog,
                    const poplar::DebugContext &debugContext = {},
                    const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  auto output = map(graph, expr::BinaryOpType::VARIANCE_TO_INV_STD_DEV, A, B,
                    prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor
varianceToInvStdDev(poplar::Graph &graph, const poplar::Tensor &A,
                    const constType B, poplar::program::Sequence &prog,
                    const poplar::DebugContext &debugContext = {},
                    const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  auto output = map(graph, expr::BinaryOpType::VARIANCE_TO_INV_STD_DEV, A,
                    BTensor, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
template <typename constType>
inline poplar::Tensor
varianceToInvStdDev(poplar::Graph &graph, const constType A,
                    const poplar::Tensor &B, poplar::program::Sequence &prog,
                    const poplar::DebugContext &debugContext = {},
                    const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  auto output = map(graph, expr::BinaryOpType::VARIANCE_TO_INV_STD_DEV, ATensor,
                    B, prog, {di}, options);
  di.addOutput(output);
  return output;
}
inline void
varianceToInvStdDevInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                           const poplar::Tensor &B,
                           poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  mapInPlace(graph, expr::BinaryOpType::VARIANCE_TO_INV_STD_DEV, A, B, prog,
             {di}, options);
}
 
template <typename constType>
inline void
varianceToInvStdDevInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                           const constType B, poplar::program::Sequence &prog,
                           const poplar::DebugContext &debugContext = {},
                           const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapInPlace(graph, expr::BinaryOpType::VARIANCE_TO_INV_STD_DEV, A, BTensor,
             prog, {di}, options);
}
inline void varianceToInvStdDevWithOutput(
    poplar::Graph &graph, const poplar::Tensor &A, const poplar::Tensor &B,
    const poplar::Tensor &out, poplar::program::Sequence &prog,
    const poplar::DebugContext &debugContext = {},
    const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  mapWithOutput(graph, expr::BinaryOpType::VARIANCE_TO_INV_STD_DEV, A, B, out,
                prog, {di}, options);
}
 
template <typename constType>
inline void
varianceToInvStdDevWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                              const constType B, const poplar::Tensor &out,
                              poplar::program::Sequence &prog,
                              const poplar::DebugContext &debugContext = {},
                              const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(A.elementType(), B);
  const auto BTensor = graph.addConstant(A.elementType(), {}, B, {di});
  graph.setTileMapping(BTensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::VARIANCE_TO_INV_STD_DEV, A, BTensor,
                out, prog, {di}, options);
}
 
template <typename constType>
inline void varianceToInvStdDevWithOutput(
    poplar::Graph &graph, const constType A, const poplar::Tensor &B,
    const poplar::Tensor &out, poplar::program::Sequence &prog,
    const poplar::DebugContext &debugContext = {},
    const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, out, options));
 
  checkTypes(B.elementType(), A);
  const auto ATensor = graph.addConstant(B.elementType(), {}, A, {di});
  graph.setTileMapping(ATensor, 0);
  mapWithOutput(graph, expr::BinaryOpType::VARIANCE_TO_INV_STD_DEV, ATensor, B,
                out, prog, {di}, options);
}
// Ternary operations
 
inline poplar::Tensor select(poplar::Graph &graph, const poplar::Tensor &A,
                             const poplar::Tensor &B, const poplar::Tensor &C,
                             poplar::program::Sequence &prog,
                             const poplar::DebugContext &debugContext = {},
                             const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, C, options));
  auto output =
      map(graph, expr::TernaryOpType::SELECT, A, B, C, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void selectInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                          const poplar::Tensor &B, const poplar::Tensor &C,
                          poplar::program::Sequence &prog,
                          const poplar::DebugContext &debugContext = {},
                          const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, C, options));
  mapInPlace(graph, expr::TernaryOpType::SELECT, A, B, C, prog, {di}, options);
}
 
inline void selectWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                             const poplar::Tensor &B, const poplar::Tensor &C,
                             const poplar::Tensor &out,
                             poplar::program::Sequence &prog,
                             const poplar::DebugContext &debugContext = {},
                             const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, C, out, options));
  mapWithOutput(graph, expr::TernaryOpType::SELECT, A, B, C, out, prog, {di},
                options);
}
 
inline poplar::Tensor clamp(poplar::Graph &graph, const poplar::Tensor &A,
                            const poplar::Tensor &B, const poplar::Tensor &C,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, C, options));
 
  auto output =
      map(graph, expr::TernaryOpType::CLAMP, A, B, C, prog, {di}, options);
  di.addOutput(output);
  return output;
}
 
inline void clampInPlace(poplar::Graph &graph, const poplar::Tensor &A,
                         const poplar::Tensor &B, const poplar::Tensor &C,
                         poplar::program::Sequence &prog,
                         const poplar::DebugContext &debugContext = {},
                         const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, C, options));
 
  mapInPlace(graph, expr::TernaryOpType::CLAMP, A, B, C, prog, {di}, options);
}
 
inline void clampWithOutput(poplar::Graph &graph, const poplar::Tensor &A,
                            const poplar::Tensor &B, const poplar::Tensor &C,
                            const poplar::Tensor &out,
                            poplar::program::Sequence &prog,
                            const poplar::DebugContext &debugContext = {},
                            const poplar::OptionFlags &options = {}) {
  poputil::PoplibsOpDebugInfo di(debugContext, DI_ARGS(A, B, C, out, options));
 
  mapWithOutput(graph, expr::TernaryOpType::CLAMP, A, B, C, out, prog, {di},
                options);
}
 
} // end namespace popops
 
#endif // popops_ElementWise_hpp