Comparison.h File Reference

#include "cker/Shape.h"
#include "cker/Types.h"
#include "cker/Utils.h"

Go to the source code of this file.

Namespaces
namespace	nnfw
namespace	nnfw::cker

Macros
#define	TFLITE_COMPARISON_OP(name)

Typedefs
template<typename T >
using	nnfw::cker::ComparisonFn = bool(*)(T, T)

Functions
template<typename T >
bool	nnfw::cker::EqualFn (T lhs, T rhs)
template<typename T >
bool	nnfw::cker::NotEqualFn (T lhs, T rhs)
template<typename T >
bool	nnfw::cker::GreaterFn (T lhs, T rhs)
template<typename T >
bool	nnfw::cker::GreaterEqualFn (T lhs, T rhs)
template<typename T >
bool	nnfw::cker::LessFn (T lhs, T rhs)
template<typename T >
bool	nnfw::cker::LessEqualFn (T lhs, T rhs)
template<typename T , ComparisonFn< T > F>
void	nnfw::cker::ComparisonImpl (const Shape &input1_shape, const T *input1_data, const Shape &input2_shape, const T *input2_data, const Shape &output_shape, bool *output_data)
template<ComparisonFn< float > F>
void	nnfw::cker::Comparison (const Shape &input1_shape, const float *input1_data, const Shape &input2_shape, const float *input2_data, const Shape &output_shape, bool *output_data)
template<typename T , ComparisonFn< int32_t > F>
void	nnfw::cker::ComparisonWithScaling (ComparisonParams &params, const Shape &input1_shape, const T *input1_data, const Shape &input2_shape, const T *input2_data, const Shape &output_shape, bool *output_data)
template<typename T , ComparisonFn< T > F>
void	nnfw::cker::BroadcastComparison4DSlowImpl (const Shape &unextended_input1_shape, const T *input1_data, const Shape &unextended_input2_shape, const T *input2_data, const Shape &unextended_output_shape, bool *output_data)
template<typename T , ComparisonFn< T > F>
void	nnfw::cker::BroadcastComparison4DSlow (const Shape &input1_shape, const T *input1_data, const Shape &input2_shape, const T *input2_data, const Shape &output_shape, bool *output_data)
template<typename T , ComparisonFn< int32_t > F>
void	nnfw::cker::BroadcastComparison4DSlowWithScaling (ComparisonParams &params, const Shape &input1_shape, const T *input1_data, const Shape &input2_shape, const T *input2_data, const Shape &output_shape, bool *output_data)
	nnfw::cker::TFLITE_COMPARISON_OP (Equal)
	nnfw::cker::TFLITE_COMPARISON_OP (NotEqual)
	nnfw::cker::TFLITE_COMPARISON_OP (Greater)
	nnfw::cker::TFLITE_COMPARISON_OP (GreaterEqual)
	nnfw::cker::TFLITE_COMPARISON_OP (Less)
	nnfw::cker::TFLITE_COMPARISON_OP (LessEqual)

Macro Definition Documentation

TFLITE_COMPARISON_OP

#define TFLITE_COMPARISON_OP

(

name

)

Definition at line 178 of file Comparison.h.

  {                                                                                                \
    Comparison<name##Fn>(input1_shape, input1_data, input2_shape, input2_data, output_shape,       \
                         output_data);                                                             \
  }                                                                                                \
  template <typename T>                                                                            \
  inline void name##NoScaling(const Shape &input1_shape, const T *input1_data,                     \
                              const Shape &input2_shape, const T *input2_data,                     \
                              const Shape &output_shape, bool *output_data)                        \
  {                                                                                                \
    ComparisonImpl<T, name##Fn>(input1_shape, input1_data, input2_shape, input2_data,              \
                                output_shape, output_data);                                        \
  }                                                                                                \
  template <typename T>                                                                            \
  inline void name##WithScaling(                                                                   \
    ComparisonParams &params, const Shape &input1_shape, const T *input1_data,                     \
    const Shape &input2_shape, const T *input2_data, const Shape &output_shape, bool *output_data) \
  {                                                                                                \
    ComparisonWithScaling<T, name##Fn>(params, input1_shape, input1_data, input2_shape,            \
                                       input2_data, output_shape, output_data);                    \
  }                                                                                                \
  template <typename T>                                                                            \
  inline void Broadcast4DSlow##name##NoScaling(const Shape &input1_shape, const T *input1_data,    \
                                               const Shape &input2_shape, const T *input2_data,    \
                                               const Shape &output_shape, bool *output_data)       \
  {                                                                                                \
    BroadcastComparison4DSlowImpl<T, name##Fn>(input1_shape, input1_data, input2_shape,            \
                                               input2_data, output_shape, output_data);            \
  }                                                                                                \
  template <typename T>                                                                            \
  inline void Broadcast4DSlow##name(const Shape &input1_shape, const T *input1_data,               \
                                    const Shape &input2_shape, const T *input2_data,               \
                                    const Shape &output_shape, bool *output_data)                  \
  {                                                                                                \
    BroadcastComparison4DSlow<T, name##Fn>(input1_shape, input1_data, input2_shape, input2_data,   \
                                           output_shape, output_data);                             \
  }                                                                                                \
  template <typename T>                                                                            \
  inline void Broadcast4DSlow##name##WithScaling(                                                  \
    ComparisonParams &params, const Shape &input1_shape, const T *input1_data,                     \
    const Shape &input2_shape, const T *input2_data, const Shape &output_shape, bool *output_data) \
  {                                                                                                \
    BroadcastComparison4DSlowWithScaling<T, name##Fn>(                                             \
      params, input1_shape, input1_data, input2_shape, input2_data, output_shape, output_data);    \
  }