134 lines
3.9 KiB
C++
134 lines
3.9 KiB
C++
/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://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.
|
|
==============================================================================*/
|
|
|
|
#ifndef TENSORFLOW_COMPILER_XLA_CLIENT_LIB_MATH_H_
|
|
#define TENSORFLOW_COMPILER_XLA_CLIENT_LIB_MATH_H_
|
|
|
|
#include "tensorflow/compiler/xla/client/xla_builder.h"
|
|
|
|
namespace xla {
|
|
|
|
// Determines whether operand is +/-inf or nan.
|
|
//
|
|
// Raises an error if called on integral or complex values.
|
|
XlaOp IsPosInf(XlaOp operand);
|
|
XlaOp IsNegInf(XlaOp operand);
|
|
XlaOp IsInf(XlaOp operand);
|
|
XlaOp IsNan(XlaOp operand);
|
|
|
|
// Determines whether operand is equal to -0.
|
|
//
|
|
// Raises an error for integral or complex values.
|
|
XlaOp IsNegZero(XlaOp operand);
|
|
|
|
// Returns the next number after 'from' in the direction of 'to' the same way
|
|
// std::nextafter(from, to) would.
|
|
XlaOp NextAfter(XlaOp from, XlaOp to);
|
|
|
|
// Computes the square of 'operand'.
|
|
XlaOp Square(XlaOp operand);
|
|
|
|
// Computes the reciprocal of 'operand'.
|
|
XlaOp Reciprocal(XlaOp operand);
|
|
|
|
// Computes an approximation of the error function complement (1 - erf(x)).
|
|
XlaOp Erfc(XlaOp x);
|
|
|
|
// Computes an approximation of the error function.
|
|
XlaOp Erf(XlaOp x);
|
|
|
|
// Computes an approximation of the inverse of the error function.
|
|
XlaOp ErfInv(XlaOp x);
|
|
|
|
// Computes an approximation of the lgamma function.
|
|
XlaOp Lgamma(XlaOp input);
|
|
|
|
// Computes an approximation of the digamma function.
|
|
XlaOp Digamma(XlaOp input);
|
|
|
|
// Computes an approximation of the incomplete gamma function.
|
|
XlaOp Igamma(XlaOp a, XlaOp x);
|
|
|
|
// Computes an approximation of the derivative of the incomplete gamma function
|
|
// with respect to a.
|
|
XlaOp IgammaGradA(XlaOp a, XlaOp x);
|
|
|
|
// Computes an approximation of the derivative of a sample `x` from a `Gamma(a,
|
|
// 1)` distribution with respect to a.
|
|
XlaOp RandomGammaGrad(XlaOp a, XlaOp x);
|
|
|
|
// Computes an approximation of the complementary incomplete gamma function.
|
|
XlaOp Igammac(XlaOp a, XlaOp x);
|
|
|
|
// Computes the Polygamma of two arguments.
|
|
XlaOp Polygamma(XlaOp n, XlaOp x);
|
|
|
|
// Computes the Riemann zeta function of two arguments.
|
|
XlaOp Zeta(XlaOp x, XlaOp q);
|
|
|
|
// Rounds the given number to even when the number is equidistant between two
|
|
// integers.
|
|
XlaOp RoundToEven(XlaOp x);
|
|
|
|
// Trigonometric functions
|
|
|
|
// Computes the arc cosine of 'x'.
|
|
XlaOp Acos(XlaOp x);
|
|
|
|
// Computes the arc sine of 'x'.
|
|
XlaOp Asin(XlaOp x);
|
|
|
|
// Computes the arc tangent of 'x'.
|
|
XlaOp Atan(XlaOp x);
|
|
|
|
// Computes the tangent of 'x'.
|
|
XlaOp Tan(XlaOp x);
|
|
|
|
// Hyperbolic trigonometric functions
|
|
|
|
// Computes the inverse hyperbolic cosine of 'x'.
|
|
XlaOp Acosh(XlaOp x);
|
|
|
|
// Computes the inverse hyperbolic sine of 'x'.
|
|
XlaOp Asinh(XlaOp x);
|
|
|
|
// Computes the inverse hyperbolic tangent of 'x'.
|
|
XlaOp Atanh(XlaOp x);
|
|
|
|
// Computes the hyperbolic cosine of 'x'.
|
|
XlaOp Cosh(XlaOp x);
|
|
|
|
// Computes the hyperbolic sine of 'x'.
|
|
XlaOp Sinh(XlaOp x);
|
|
|
|
// Applies a complex conjugation operation if 'a' is complex and 'conjugate'
|
|
// is true, otherwise returns its argument.
|
|
xla::XlaOp MaybeConjugate(xla::XlaOp x, bool conjugate);
|
|
|
|
// Computes the Modified Bessel function of the first kind of the zeroth order
|
|
// at x.
|
|
XlaOp BesselI0e(XlaOp x);
|
|
|
|
// Computes the Modified Bessel function of the first kind of the first order
|
|
// at x.
|
|
XlaOp BesselI1e(XlaOp x);
|
|
|
|
// Computes the Regularized Incomplete Beta function.
|
|
XlaOp RegularizedIncompleteBeta(XlaOp a, XlaOp b, XlaOp x);
|
|
|
|
} // namespace xla
|
|
|
|
#endif // TENSORFLOW_COMPILER_XLA_CLIENT_LIB_MATH_H_
|