/*******************************************************************************
* Copyright (c) 2015-2018 Skymind, Inc.
*
* This program and the accompanying materials are made available under the
* terms of the Apache License, Version 2.0 which is available at
* https://www.apache.org/licenses/LICENSE-2.0.
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
* SPDX-License-Identifier: Apache-2.0
******************************************************************************/
//
// @author raver119@gmail.com
//
#ifndef LIBND4J_HEADERS_BROADCASTABLE_H
#define LIBND4J_HEADERS_BROADCASTABLE_H
#include <ops/declarable/BroadcastableOp.h>
#include <ops/declarable/headers/common.h>
#include <ops/declarable/generic/helpers/BroadcastHelper.h>
namespace nd4j {
namespace ops {
// TODO: make broadcastables separate class
/**
* This is one of auto-broadcastable operations. It accepts 2 operands, and operation is applied based on their shapes:
* 1) if shapes are equal that's pairwise operation, result will have the same shape.
* 2) if shape X is scalar and shape Y is array - result will have shape equal to Y.
* 3) if shape X is array and shape Y is scalar - result will have shape equal to X.
* 4) if shape X and Y are both arrays, but shapes aren't equal - result shape will be broadcast result.
*
* This operation returns Z = Max(X, Y)
*/
#if NOT_EXCLUDED(OP_maximum)
DECLARE_BROADCASTABLE_OP(maximum, 0, 0);
DECLARE_CUSTOM_OP(maximum_bp, 3, 2, false, 0, 0);
#endif
/**
* This is one of auto-broadcastable operations. It accepts 2 operands, and operation is applied based on their shapes:
* 1) if shapes are equal that's pairwise operation, result will have the same shape.
* 2) if shape X is scalar and shape Y is array - result will have shape equal to Y.
* 3) if shape X is array and shape Y is scalar - result will have shape equal to X.
* 4) if shape X and Y are both arrays, but shapes aren't equal - result shape will be broadcast result.
*
* This operation returns Z = Min(X, Y)
*/
#if NOT_EXCLUDED(OP_minimum)
DECLARE_BROADCASTABLE_OP(minimum, 0, 0);
DECLARE_CUSTOM_OP(minimum_bp, 3, 2, false, 0, 0);
#endif
/**
* This is one of auto-broadcastable operations. It accepts 2 operands, and operation is applied based on their shapes:
* 1) if shapes are equal that's pairwise operation, result will have the same shape.
* 2) if shape X is scalar and shape Y is array - result will have shape equal to Y.
* 3) if shape X is array and shape Y is scalar - result will have shape equal to X.
* 4) if shape X and Y are both arrays, but shapes aren't equal - result shape will be broadcast result.
*
* This operation returns Z = Add(X, Y)
*/
#if NOT_EXCLUDED(OP_add)
DECLARE_BROADCASTABLE_OP(add, 0, 0);
DECLARE_CUSTOM_OP(add_bp, 3, 2, false, 0, 0);
#endif
/**
* This is one of auto-broadcastable operations. It accepts 2 operands, and operation is applied based on their shapes:
* 1) if shapes are equal that's pairwise operation, result will have the same shape.
* 2) if shape X is scalar and shape Y is array - result will have shape equal to Y.
* 3) if shape X is array and shape Y is scalar - result will have shape equal to X.
* 4) if shape X and Y are both arrays, but shapes aren't equal - result shape will be broadcast result.
*
* This operation returns Z = Subtract(X, Y)
*/
#if NOT_EXCLUDED(OP_subtract)
DECLARE_BROADCASTABLE_OP(subtract, 0, 0);
DECLARE_CUSTOM_OP(subtract_bp, 3, 2, false, 0, 0);
#endif
/**
* This is one of auto-broadcastable operations. It accepts 2 operands, and operation is applied based on their shapes:
* 1) if shapes are equal that's pairwise operation, result will have the same shape.
* 2) if shape X is scalar and shape Y is array - result will have shape equal to Y.
* 3) if shape X is array and shape Y is scalar - result will have shape equal to X.
* 4) if shape X and Y are both arrays, but shapes aren't equal - result shape will be broadcast result.
*
* This operation returns Z = Subtract(Y, X)
*/
#if NOT_EXCLUDED(OP_reversesubtract)
DECLARE_BROADCASTABLE_OP(reversesubtract, 0, 0);
DECLARE_CUSTOM_OP(reversesubtract_bp, 3, 2, false, 0, 0);
#endif
/**
* This is one of auto-broadcastable operations. It accepts 2 operands, and operation is applied based on their shapes:
* 1) if shapes are equal that's pairwise operation, result will have the same shape.
* 2) if shape X is scalar and shape Y is array - result will have shape equal to Y.
* 3) if shape X is array and shape Y is scalar - result will have shape equal to X.
* 4) if shape X and Y are both arrays, but shapes aren't equal - result shape will be broadcast result.
*
* This operation returns Z = ReverseMod(X, Y) == Mod(Y, X)
*/
#if NOT_EXCLUDED(OP_reversemod)
DECLARE_BROADCASTABLE_OP(reversemod, 0, 0);
DECLARE_CUSTOM_OP(reversemod_bp, 3, 2, true, 0, 0);
#endif
/**
* This is one of auto-broadcastable operations. It accepts 2 operands, and operation is applied based on their shapes:
* 1) if shapes are equal that's pairwise operation, result will have the same shape.
* 2) if shape X is scalar and shape Y is array - result will have shape equal to Y.
* 3) if shape X is array and shape Y is scalar - result will have shape equal to X.
* 4) if shape X and Y are both arrays, but shapes aren't equal - result shape will be broadcast result.
*
* This operation returns Z = Subtract(X, Y) * Subtract(X, Y)
*/
#if NOT_EXCLUDED(OP_squaredsubtract)
DECLARE_BROADCASTABLE_OP(squaredsubtract, 0, 0)
DECLARE_CUSTOM_OP(squaredsubtract_bp, 3, 2, false, 0, 0);
#endif
/**
* This is one of auto-broadcastable operations. It accepts 2 operands, and operation is applied based on their shapes:
* 1) if shapes are equal that's pairwise operation, result will have the same shape.
* 2) if shape X is scalar and shape Y is array - result will have shape equal to Y.
* 3) if shape X is array and shape Y is scalar - result will have shape equal to X.
* 4) if shape X and Y are both arrays, but shapes aren't equal - result shape will be broadcast result.
*
* This operation returns Z = Multiply(X, Y)
*/
#if NOT_EXCLUDED(OP_multiply)
DECLARE_BROADCASTABLE_OP(multiply, 0, 0);
DECLARE_CUSTOM_OP(multiply_bp, 3, 2, false, 0, 0);
#endif
/**
* This is one of auto-broadcastable operations. It accepts 2 operands, and operation is applied based on their shapes:
* 1) if shapes are equal that's pairwise operation, result will have the same shape.
* 2) if shape X is scalar and shape Y is array - result will have shape equal to Y.
* 3) if shape X is array and shape Y is scalar - result will have shape equal to X.
* 4) if shape X and Y are both arrays, but shapes aren't equal - result shape will be broadcast result.
*
* This operation returns Z = Divide(X, Y)
*/
#if NOT_EXCLUDED(OP_divide)
DECLARE_BROADCASTABLE_OP(divide, 0, 0);
DECLARE_CUSTOM_OP(divide_bp, 3, 2, false, 0, 0);
#endif
/**
* This is one of auto-broadcastable operations. It accepts 2 operands, and operation is applied based on their shapes:
* 1) if shapes are equal that's pairwise operation, result will have the same shape.
* 2) if shape X is scalar and shape Y is array - result will have shape equal to Y.
* 3) if shape X is array and shape Y is scalar - result will have shape equal to X.
* 4) if shape X and Y are both arrays, but shapes aren't equal - result shape will be broadcast result.
*
* This operation returns Z = Divide(X, Y) with exception, 0 if Y = 0
*/
#if NOT_EXCLUDED(OP_divide_no_nan)
DECLARE_BROADCASTABLE_OP(divide_no_nan, 0, 0);
#endif
/**
* This is one of auto-broadcastable operations. It accepts 2 operands, and operation is applied based on their shapes:
* 1) if shapes are equal that's pairwise operation, result will have the same shape.
* 2) if shape X is scalar and shape Y is array - result will have shape equal to Y.
* 3) if shape X is array and shape Y is scalar - result will have shape equal to X.
* 4) if shape X and Y are both arrays, but shapes aren't equal - result shape will be broadcast result.
*
* This operation returns Z = Divide(Y, x)
*/
#if NOT_EXCLUDED(OP_reversedivide)
DECLARE_BROADCASTABLE_OP(reversedivide, 0, 0);
DECLARE_CUSTOM_OP(reversedivide_bp, 3, 2, false, 0, 0);
#endif
/**
* This is one of auto-broadcastable operations. It accepts 2 operands, and operation is applied based on their shapes:
* 1) if shapes are equal that's pairwise operation, result will have the same shape.
* 2) if shape X is scalar and shape Y is array - result will have shape equal to Y.
* 3) if shape X is array and shape Y is scalar - result will have shape equal to X.
* 4) if shape X and Y are both arrays, but shapes aren't equal - result shape will be broadcast result.
*
* This operation returns Z = FloorMod(X, Y)
*/
#if NOT_EXCLUDED(OP_floormod)
DECLARE_BROADCASTABLE_OP(floormod, 0, 0);
DECLARE_CUSTOM_OP(floormod_bp, 3, 2, true, 0, 0);
#endif
#if NOT_EXCLUDED(OP_mod)
DECLARE_BROADCASTABLE_OP(mod, 0, 0);
DECLARE_CUSTOM_OP(mod_bp, 3, 2, true, 0, 0);
#endif
/**
* This is one of auto-broadcastable operations. It accepts 2 operands, and operation is applied based on their shapes:
* 1) if shapes are equal that's pairwise operation, result will have the same shape.
* 2) if shape X is scalar and shape Y is array - result will have shape equal to Y.
* 3) if shape X is array and shape Y is scalar - result will have shape equal to X.
* 4) if shape X and Y are both arrays, but shapes aren't equal - result shape will be broadcast result.
*
* This operation returns Z = FloorDiv(X, Y)
*/
#if NOT_EXCLUDED(OP_floordiv)
DECLARE_BROADCASTABLE_OP(floordiv, 0, 0)
DECLARE_CUSTOM_OP(floordiv_bp, 2, 1, true, 0, 0)
#endif
/**
* This is one of auto-broadcastable operations. It accepts 2 operands, and operation is applied based on their shapes:
* 1) if shapes are equal that's pairwise operation, result will have the same shape.
* 2) if shape X is scalar and shape Y is array - result will have shape equal to Y.
* 3) if shape X is array and shape Y is scalar - result will have shape equal to X.
* 4) if shape X and Y are both arrays, but shapes aren't equal - result shape will be broadcast result.
*
* This operation returns Z = Divide(X, Y)
*/
#if NOT_EXCLUDED(OP_realdiv)
DECLARE_BROADCASTABLE_OP(realdiv, 0, 0);
DECLARE_CUSTOM_OP(realdiv_bp, 3, 2, false, 0, 0);
#endif
/**
*
*
* @tparam T
*/
DECLARE_BROADCASTABLE_OP(truncatediv, 0, 0);
/**
* This is one of auto-broadcastable operations. It accepts 2 operands, and operation is applied based on their shapes:
* 1) if shapes are equal that's pairwise operation, result will have the same shape.
* 2) if shape X is scalar and shape Y is array - result will have shape equal to Y.
* 3) if shape X is array and shape Y is scalar - result will have shape equal to X.
* 4) if shape X and Y are both arrays, but shapes aren't equal - result shape will be broadcast result.
*
* This operation returns Z = Assign(X, Y)
*/
#if NOT_EXCLUDED(OP_assign)
DECLARE_BROADCASTABLE_OP(assign, 0, 0);
DECLARE_CUSTOM_OP(assign_bp, 3, 2, false, 0, 0);
#endif
#if NOT_EXCLUDED(OP_meshgrid)
DECLARE_CUSTOM_OP(meshgrid, -1, -1, false, 0, 0);
#endif
/**
* This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
* Math is: _x == _y ? (T) 1.0f : (T) 0.0f;
*
*/
#if NOT_EXCLUDED(OP_equals)
DECLARE_BROADCASTABLE_OP(equals, 0, 0);
#endif
/**
* This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
* Math is: _x != _y ? (T) 1.0f : (T) 0.0f;
*/
#if NOT_EXCLUDED(OP_not_equals)
DECLARE_BROADCASTABLE_OP(not_equals, 0, 0);
#endif
/**
* This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
* Math is: _x <= _y ? (T) 1.0f : (T) 0.0f;
*/
#if NOT_EXCLUDED(OP_less_equal)
DECLARE_BROADCASTABLE_OP(less_equal, 0, 0);
#endif
/**
* This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
* Math is: _x >= _y ? (T) 1.0f : (T) 0.0f;
*/
#if NOT_EXCLUDED(OP_greater_equal)
DECLARE_BROADCASTABLE_OP(greater_equal, 0, 0);
#endif
/**
* This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
* Math is: _x < _y ? (T) 1.0f : (T) 0.0f;
*/
#if NOT_EXCLUDED(OP_less)
DECLARE_BROADCASTABLE_OP(less, 0, 0);
#endif
/**
* This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
* Math is: _x > _y ? (T) 1.0f : (T) 0.0f;
*/
#if NOT_EXCLUDED(OP_greater)
DECLARE_BROADCASTABLE_OP(greater, 0, 0);
#endif
/**
*
*/
#if NOT_EXCLUDED(OP_boolean_and)
DECLARE_BROADCASTABLE_OP(boolean_and, 0, 0);
#endif
/**
*
*/
#if NOT_EXCLUDED(OP_boolean_or)
DECLARE_BROADCASTABLE_OP(boolean_or, 0, 0);
#endif
/**
*
*/
#if NOT_EXCLUDED(OP_boolean_xor)
DECLARE_BROADCASTABLE_OP(boolean_xor, 0, 0);
#endif
/**
* This operation performs calculation of percentile of input array along given axises
*
* Input - tensor with rank N > 0
* Output - tensor with rank (N - length(axis)) or scalar if number of Integer arguments is zero
* Float arguments:
* 0: percentile (scalar) in range [0,100] (inclusively)
* 1: interpolation (optional), possible values are 0-"lower", 1-"higher", 2-"nearest"(default)
* 2: keepDims (optional), if it is non zero, then unities are kept in reduced resulting shape of output array, default is 0
* Integer arguments - axis - the sequence of axises to calculate percentile along, if sequence is empty then calculate percentile for whole input tensor and return result as scalar
*
*/
#if NOT_EXCLUDED(OP_percentile)
DECLARE_CUSTOM_OP(percentile, 1, 1, false, 1, -2);
#endif
/**
* Special atan2 op impl for TF's args order
* @tparam T
*/
#if NOT_EXCLUDED(OP_tf_atan2)
DECLARE_BROADCASTABLE_OP(tf_atan2, 0, 0);
#endif
/**
* Broadcastable pow implementation
* @tparam T
*/
#if NOT_EXCLUDED(OP_Pow)
DECLARE_BROADCASTABLE_OP(Pow, 0, 0);
#endif
/**
* Broadcastable igamma implementation
*
* igamma(a, x) = gamma(а, x) / Gamma(a) - Gamma distribution function P(a,x)
* Gamma(a) = int from 0 to infinity { t ^ {a - 1} e^{-t}dt }
* gamma(a, x) = int from 0 to x { t ^ {a - 1} e^{-t}dt }
* @tparam T
*/
#if NOT_EXCLUDED(OP_igamma)
DECLARE_BROADCASTABLE_OP(igamma, 0, 0);
#endif
/**
* Broadcastable igammac implementation
* igammac(a, x) = Gamma(a,x)/Gamma(а) - Gamma distribution function Q(a,x)
* Gamma(a) = int from 0 to infinity { t ^ {a - 1} e^{-t}dt }
* Gamma(a, x) = int from x to infinity { t ^ {a - 1} e^{-t}dt }
* @tparam T
*/
#if NOT_EXCLUDED(OP_igammac)
DECLARE_BROADCASTABLE_OP(igammac, 0, 0);
#endif
}
}
#endif