externals/linux/include/tensorflow/cc/ops/linalg_ops.h

// This file is MACHINE GENERATED! Do not edit.

#ifndef TENSORFLOW_CC_OPS_LINALG_OPS_H_
#define TENSORFLOW_CC_OPS_LINALG_OPS_H_

// This file is MACHINE GENERATED! Do not edit.

#include "tensorflow/cc/framework/ops.h"
#include "tensorflow/cc/framework/scope.h"
#include "tensorflow/core/framework/tensor.h"
#include "tensorflow/core/framework/tensor_shape.h"
#include "tensorflow/core/framework/types.h"
#include "tensorflow/core/lib/gtl/array_slice.h"

namespace tensorflow {
namespace ops {

/// @defgroup linalg_ops Linalg Ops
/// @{

/// Computes the Cholesky decomposition of one or more square matrices.
///
/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
/// form square matrices.
///
/// The input has to be symmetric and positive definite. Only the lower-triangular
/// part of the input will be used for this operation. The upper-triangular part
/// will not be read.
///
/// The output is a tensor of the same shape as the input
/// containing the Cholesky decompositions for all input submatrices `[..., :, :]`.
///
/// **Note**: The gradient computation on GPU is faster for large matrices but
/// not for large batch dimensions when the submatrices are small. In this
/// case it might be faster to use the CPU.
///
/// Arguments:
/// * scope: A Scope object
/// * input: Shape is `[..., M, M]`.
///
/// Returns:
/// * `Output`: Shape is `[..., M, M]`.
class Cholesky {
 public:
  Cholesky(const ::tensorflow::Scope& scope, ::tensorflow::Input input);
  operator ::tensorflow::Output() const { return output; }
  operator ::tensorflow::Input() const { return output; }
  ::tensorflow::Node* node() const { return output.node(); }

  Operation operation;
  ::tensorflow::Output output;
};

/// Computes the reverse mode backpropagated gradient of the Cholesky algorithm.
///
/// For an explanation see "Differentiation of the Cholesky algorithm" by
/// Iain Murray http://arxiv.org/abs/1602.07527.
///
/// Arguments:
/// * scope: A Scope object
/// * l: Output of batch Cholesky algorithm l = cholesky(A). Shape is `[..., M, M]`.
/// Algorithm depends only on lower triangular part of the innermost matrices of
/// this tensor.
/// * grad: df/dl where f is some scalar function. Shape is `[..., M, M]`.
/// Algorithm depends only on lower triangular part of the innermost matrices of
/// this tensor.
///
/// Returns:
/// * `Output`: Symmetrized version of df/dA . Shape is `[..., M, M]`
class CholeskyGrad {
 public:
  CholeskyGrad(const ::tensorflow::Scope& scope, ::tensorflow::Input l,
             ::tensorflow::Input grad);
  operator ::tensorflow::Output() const { return output; }
  operator ::tensorflow::Input() const { return output; }
  ::tensorflow::Node* node() const { return output.node(); }

  Operation operation;
  ::tensorflow::Output output;
};

/// Computes the sign and the log of the absolute value of the determinant of
///
/// one or more square matrices.
///
/// The input is a tensor of shape `[N, M, M]` whose inner-most 2 dimensions
/// form square matrices. The outputs are two tensors containing the signs and
/// absolute values of the log determinants for all N input submatrices
/// `[..., :, :]` such that the determinant = sign*exp(log_abs_determinant).
/// The log_abs_determinant is computed as det(P)*sum(log(diag(LU))) where LU
/// is the LU decomposition of the input and P is the corresponding
/// permutation matrix.
///
/// Arguments:
/// * scope: A Scope object
/// * input: Shape is `[N, M, M]`.
///
/// Returns:
/// * `Output` sign: The signs of the log determinants of the inputs. Shape is `[N]`.
/// * `Output` log_abs_determinant: The logs of the absolute values of the determinants
/// of the N input matrices.  Shape is `[N]`.
class LogMatrixDeterminant {
 public:
  LogMatrixDeterminant(const ::tensorflow::Scope& scope, ::tensorflow::Input
                     input);

  Operation operation;
  ::tensorflow::Output sign;
  ::tensorflow::Output log_abs_determinant;
};

/// Computes the determinant of one or more square matrices.
///
/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
/// form square matrices. The output is a tensor containing the determinants
/// for all input submatrices `[..., :, :]`.
///
/// Arguments:
/// * scope: A Scope object
/// * input: Shape is `[..., M, M]`.
///
/// Returns:
/// * `Output`: Shape is `[...]`.
class MatrixDeterminant {
 public:
  MatrixDeterminant(const ::tensorflow::Scope& scope, ::tensorflow::Input input);
  operator ::tensorflow::Output() const { return output; }
  operator ::tensorflow::Input() const { return output; }
  ::tensorflow::Node* node() const { return output.node(); }

  Operation operation;
  ::tensorflow::Output output;
};

/// Computes the inverse of one or more square invertible matrices or their
///
/// adjoints (conjugate transposes).
///
/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
/// form square matrices. The output is a tensor of the same shape as the input
/// containing the inverse for all input submatrices `[..., :, :]`.
///
/// The op uses LU decomposition with partial pivoting to compute the inverses.
///
/// If a matrix is not invertible there is no guarantee what the op does. It
/// may detect the condition and raise an exception or it may simply return a
/// garbage result.
///
/// Arguments:
/// * scope: A Scope object
/// * input: Shape is `[..., M, M]`.
///
/// Returns:
/// * `Output`: Shape is `[..., M, M]`.
///
/// @compatibility(numpy)
/// Equivalent to np.linalg.inv
/// @end_compatibility
class MatrixInverse {
 public:
  /// Optional attribute setters for MatrixInverse
  struct Attrs {
    /// Defaults to false
    TF_MUST_USE_RESULT Attrs Adjoint(bool x) {
      Attrs ret = *this;
      ret.adjoint_ = x;
      return ret;
    }

    bool adjoint_ = false;
  };
  MatrixInverse(const ::tensorflow::Scope& scope, ::tensorflow::Input input);
  MatrixInverse(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
              const MatrixInverse::Attrs& attrs);
  operator ::tensorflow::Output() const { return output; }
  operator ::tensorflow::Input() const { return output; }
  ::tensorflow::Node* node() const { return output.node(); }

  static Attrs Adjoint(bool x) {
    return Attrs().Adjoint(x);
  }

  Operation operation;
  ::tensorflow::Output output;
};

/// Solves systems of linear equations.
///
/// `Matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
/// form square matrices. `Rhs` is a tensor of shape `[..., M, K]`. The `output` is
/// a tensor shape `[..., M, K]`.  If `adjoint` is `False` then each output matrix
/// satisfies `matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`.
/// If `adjoint` is `True` then each output matrix satisfies
/// `adjoint(matrix[..., :, :]) * output[..., :, :] = rhs[..., :, :]`.
///
/// Arguments:
/// * scope: A Scope object
/// * matrix: Shape is `[..., M, M]`.
/// * rhs: Shape is `[..., M, K]`.
///
/// Optional attributes (see `Attrs`):
/// * adjoint: Boolean indicating whether to solve with `matrix` or its (block-wise)
/// adjoint.
///
/// Returns:
/// * `Output`: Shape is `[..., M, K]`.
class MatrixSolve {
 public:
  /// Optional attribute setters for MatrixSolve
  struct Attrs {
    /// Boolean indicating whether to solve with `matrix` or its (block-wise)
    /// adjoint.
    ///
    /// Defaults to false
    TF_MUST_USE_RESULT Attrs Adjoint(bool x) {
      Attrs ret = *this;
      ret.adjoint_ = x;
      return ret;
    }

    bool adjoint_ = false;
  };
  MatrixSolve(const ::tensorflow::Scope& scope, ::tensorflow::Input matrix,
            ::tensorflow::Input rhs);
  MatrixSolve(const ::tensorflow::Scope& scope, ::tensorflow::Input matrix,
            ::tensorflow::Input rhs, const MatrixSolve::Attrs& attrs);
  operator ::tensorflow::Output() const { return output; }
  operator ::tensorflow::Input() const { return output; }
  ::tensorflow::Node* node() const { return output.node(); }

  static Attrs Adjoint(bool x) {
    return Attrs().Adjoint(x);
  }

  Operation operation;
  ::tensorflow::Output output;
};

/// Solves one or more linear least-squares problems.
///
/// `matrix` is a tensor of shape `[..., M, N]` whose inner-most 2 dimensions
/// form real or complex matrices of size `[M, N]`. `Rhs` is a tensor of the same
/// type as `matrix` and shape `[..., M, K]`.
/// The output is a tensor shape `[..., N, K]` where each output matrix solves
/// each of the equations
/// `matrix[..., :, :]` * `output[..., :, :]` = `rhs[..., :, :]`
/// in the least squares sense.
///
/// We use the following notation for (complex) matrix and right-hand sides
/// in the batch:
///
/// `matrix`=\\(A \in \mathbb{C}^{m \times n}\\),
/// `rhs`=\\(B  \in \mathbb{C}^{m \times k}\\),
/// `output`=\\(X  \in \mathbb{C}^{n \times k}\\),
/// `l2_regularizer`=\\(\lambda \in \mathbb{R}\\).
///
/// If `fast` is `True`, then the solution is computed by solving the normal
/// equations using Cholesky decomposition. Specifically, if \\(m \ge n\\) then
/// \\(X = (A^H A + \lambda I)^{-1} A^H B\\), which solves the least-squares
/// problem \\(X = \mathrm{argmin}_{Z \in \Re^{n \times k} } ||A Z - B||_F^2 + \lambda ||Z||_F^2\\).
/// If \\(m \lt n\\) then `output` is computed as
/// \\(X = A^H (A A^H + \lambda I)^{-1} B\\), which (for \\(\lambda = 0\\)) is the
/// minimum-norm solution to the under-determined linear system, i.e.
/// \\(X = \mathrm{argmin}_{Z \in \mathbb{C}^{n \times k} } ||Z||_F^2 \\),
/// subject to \\(A Z = B\\). Notice that the fast path is only numerically stable
/// when \\(A\\) is numerically full rank and has a condition number
/// \\(\mathrm{cond}(A) \lt \frac{1}{\sqrt{\epsilon_{mach} } }\\) or \\(\lambda\\) is
/// sufficiently large.
///
/// If `fast` is `False` an algorithm based on the numerically robust complete
/// orthogonal decomposition is used. This computes the minimum-norm
/// least-squares solution, even when \\(A\\) is rank deficient. This path is
/// typically 6-7 times slower than the fast path. If `fast` is `False` then
/// `l2_regularizer` is ignored.
///
/// Arguments:
/// * scope: A Scope object
/// * matrix: Shape is `[..., M, N]`.
/// * rhs: Shape is `[..., M, K]`.
/// * l2_regularizer: Scalar tensor.
///
/// @compatibility(numpy)
/// Equivalent to np.linalg.lstsq
/// @end_compatibility
///
/// Returns:
/// * `Output`: Shape is `[..., N, K]`.
class MatrixSolveLs {
 public:
  /// Optional attribute setters for MatrixSolveLs
  struct Attrs {
    /// Defaults to true
    TF_MUST_USE_RESULT Attrs Fast(bool x) {
      Attrs ret = *this;
      ret.fast_ = x;
      return ret;
    }

    bool fast_ = true;
  };
  MatrixSolveLs(const ::tensorflow::Scope& scope, ::tensorflow::Input matrix,
              ::tensorflow::Input rhs, ::tensorflow::Input l2_regularizer);
  MatrixSolveLs(const ::tensorflow::Scope& scope, ::tensorflow::Input matrix,
              ::tensorflow::Input rhs, ::tensorflow::Input l2_regularizer,
              const MatrixSolveLs::Attrs& attrs);
  operator ::tensorflow::Output() const { return output; }
  operator ::tensorflow::Input() const { return output; }
  ::tensorflow::Node* node() const { return output.node(); }

  static Attrs Fast(bool x) {
    return Attrs().Fast(x);
  }

  Operation operation;
  ::tensorflow::Output output;
};

/// Solves systems of linear equations with upper or lower triangular matrices by
///
/// backsubstitution.
///
/// `matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions form
/// square matrices. If `lower` is `True` then the strictly upper triangular part
/// of each inner-most matrix is assumed to be zero and not accessed.
/// If `lower` is False then the strictly lower triangular part of each inner-most
/// matrix is assumed to be zero and not accessed.
/// `rhs` is a tensor of shape `[..., M, K]`.
///
/// The output is a tensor of shape `[..., M, K]`. If `adjoint` is
/// `True` then the innermost matrices in `output` satisfy matrix equations
/// `matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`.
/// If `adjoint` is `False` then the strictly then the  innermost matrices in
/// `output` satisfy matrix equations
/// `adjoint(matrix[..., i, k]) * output[..., k, j] = rhs[..., i, j]`.
///
/// Arguments:
/// * scope: A Scope object
/// * matrix: Shape is `[..., M, M]`.
/// * rhs: Shape is `[..., M, K]`.
///
/// Optional attributes (see `Attrs`):
/// * lower: Boolean indicating whether the innermost matrices in `matrix` are
/// lower or upper triangular.
/// * adjoint: Boolean indicating whether to solve with `matrix` or its (block-wise)
///          adjoint.
///
/// @compatibility(numpy)
/// Equivalent to scipy.linalg.solve_triangular
/// @end_compatibility
///
/// Returns:
/// * `Output`: Shape is `[..., M, K]`.
class MatrixTriangularSolve {
 public:
  /// Optional attribute setters for MatrixTriangularSolve
  struct Attrs {
    /// Boolean indicating whether the innermost matrices in `matrix` are
    /// lower or upper triangular.
    ///
    /// Defaults to true
    TF_MUST_USE_RESULT Attrs Lower(bool x) {
      Attrs ret = *this;
      ret.lower_ = x;
      return ret;
    }

    /// Boolean indicating whether to solve with `matrix` or its (block-wise)
    ///          adjoint.
    ///
    /// @compatibility(numpy)
    /// Equivalent to scipy.linalg.solve_triangular
    /// @end_compatibility
    ///
    /// Defaults to false
    TF_MUST_USE_RESULT Attrs Adjoint(bool x) {
      Attrs ret = *this;
      ret.adjoint_ = x;
      return ret;
    }

    bool lower_ = true;
    bool adjoint_ = false;
  };
  MatrixTriangularSolve(const ::tensorflow::Scope& scope, ::tensorflow::Input
                      matrix, ::tensorflow::Input rhs);
  MatrixTriangularSolve(const ::tensorflow::Scope& scope, ::tensorflow::Input
                      matrix, ::tensorflow::Input rhs, const
                      MatrixTriangularSolve::Attrs& attrs);
  operator ::tensorflow::Output() const { return output; }
  operator ::tensorflow::Input() const { return output; }
  ::tensorflow::Node* node() const { return output.node(); }

  static Attrs Lower(bool x) {
    return Attrs().Lower(x);
  }
  static Attrs Adjoint(bool x) {
    return Attrs().Adjoint(x);
  }

  Operation operation;
  ::tensorflow::Output output;
};

/// Computes the QR decompositions of one or more matrices.
///
/// Computes the QR decomposition of each inner matrix in `tensor` such that
/// `tensor[..., :, :] = q[..., :, :] * r[..., :,:])`
///
/// ```python
/// # a is a tensor.
/// # q is a tensor of orthonormal matrices.
/// # r is a tensor of upper triangular matrices.
/// q, r = qr(a)
/// q_full, r_full = qr(a, full_matrices=True)
/// ```
///
/// Arguments:
/// * scope: A Scope object
/// * input: A tensor of shape `[..., M, N]` whose inner-most 2 dimensions
/// form matrices of size `[M, N]`. Let `P` be the minimum of `M` and `N`.
///
/// Optional attributes (see `Attrs`):
/// * full_matrices: If true, compute full-sized `q` and `r`. If false
/// (the default), compute only the leading `P` columns of `q`.
///
/// Returns:
/// * `Output` q: Orthonormal basis for range of `a`. If `full_matrices` is `False` then
/// shape is `[..., M, P]`; if `full_matrices` is `True` then shape is
/// `[..., M, M]`.
/// * `Output` r: Triangular factor. If `full_matrices` is `False` then shape is
/// `[..., P, N]`. If `full_matrices` is `True` then shape is `[..., M, N]`.
class Qr {
 public:
  /// Optional attribute setters for Qr
  struct Attrs {
    /// If true, compute full-sized `q` and `r`. If false
    /// (the default), compute only the leading `P` columns of `q`.
    ///
    /// Defaults to false
    TF_MUST_USE_RESULT Attrs FullMatrices(bool x) {
      Attrs ret = *this;
      ret.full_matrices_ = x;
      return ret;
    }

    bool full_matrices_ = false;
  };
  Qr(const ::tensorflow::Scope& scope, ::tensorflow::Input input);
  Qr(const ::tensorflow::Scope& scope, ::tensorflow::Input input, const
   Qr::Attrs& attrs);

  static Attrs FullMatrices(bool x) {
    return Attrs().FullMatrices(x);
  }

  Operation operation;
  ::tensorflow::Output q;
  ::tensorflow::Output r;
};

/// Computes the eigen decomposition of one or more square self-adjoint matrices.
///
/// Computes the eigenvalues and (optionally) eigenvectors of each inner matrix in
/// `input` such that `input[..., :, :] = v[..., :, :] * diag(e[..., :])`. The eigenvalues
/// are sorted in non-decreasing order.
///
/// ```python
/// # a is a tensor.
/// # e is a tensor of eigenvalues.
/// # v is a tensor of eigenvectors.
/// e, v = self_adjoint_eig(a)
/// e = self_adjoint_eig(a, compute_v=False)
/// ```
///
/// Arguments:
/// * scope: A Scope object
/// * input: `Tensor` input of shape `[N, N]`.
///
/// Optional attributes (see `Attrs`):
/// * compute_v: If `True` then eigenvectors will be computed and returned in `v`.
/// Otherwise, only the eigenvalues will be computed.
///
/// Returns:
/// * `Output` e: Eigenvalues. Shape is `[N]`.
/// * `Output` v: Eigenvectors. Shape is `[N, N]`.
class SelfAdjointEig {
 public:
  /// Optional attribute setters for SelfAdjointEig
  struct Attrs {
    /// If `True` then eigenvectors will be computed and returned in `v`.
    /// Otherwise, only the eigenvalues will be computed.
    ///
    /// Defaults to true
    TF_MUST_USE_RESULT Attrs ComputeV(bool x) {
      Attrs ret = *this;
      ret.compute_v_ = x;
      return ret;
    }

    bool compute_v_ = true;
  };
  SelfAdjointEig(const ::tensorflow::Scope& scope, ::tensorflow::Input input);
  SelfAdjointEig(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
               const SelfAdjointEig::Attrs& attrs);

  static Attrs ComputeV(bool x) {
    return Attrs().ComputeV(x);
  }

  Operation operation;
  ::tensorflow::Output e;
  ::tensorflow::Output v;
};

/// Computes the singular value decompositions of one or more matrices.
///
/// Computes the SVD of each inner matrix in `input` such that
/// `input[..., :, :] = u[..., :, :] * diag(s[..., :, :]) * transpose(v[..., :, :])`
///
/// ```python
/// # a is a tensor containing a batch of matrices.
/// # s is a tensor of singular values for each matrix.
/// # u is the tensor containing of left singular vectors for each matrix.
/// # v is the tensor containing of right singular vectors for each matrix.
/// s, u, v = svd(a)
/// s, _, _ = svd(a, compute_uv=False)
/// ```
///
/// Arguments:
/// * scope: A Scope object
/// * input: A tensor of shape `[..., M, N]` whose inner-most 2 dimensions
/// form matrices of size `[M, N]`. Let `P` be the minimum of `M` and `N`.
///
/// Optional attributes (see `Attrs`):
/// * compute_uv: If true, left and right singular vectors will be
/// computed and returned in `u` and `v`, respectively.
/// If false, `u` and `v` are not set and should never referenced.
/// * full_matrices: If true, compute full-sized `u` and `v`. If false
/// (the default), compute only the leading `P` singular vectors.
/// Ignored if `compute_uv` is `False`.
///
/// Returns:
/// * `Output` s: Singular values. Shape is `[..., P]`.
/// * `Output` u: Left singular vectors. If `full_matrices` is `False` then shape is
/// `[..., M, P]`; if `full_matrices` is `True` then shape is
/// `[..., M, M]`. Undefined if `compute_uv` is `False`.
/// * `Output` v: Left singular vectors. If `full_matrices` is `False` then shape is
/// `[..., N, P]`. If `full_matrices` is `True` then shape is `[..., N, N]`.
/// Undefined if `compute_uv` is false.
class Svd {
 public:
  /// Optional attribute setters for Svd
  struct Attrs {
    /// If true, left and right singular vectors will be
    /// computed and returned in `u` and `v`, respectively.
    /// If false, `u` and `v` are not set and should never referenced.
    ///
    /// Defaults to true
    TF_MUST_USE_RESULT Attrs ComputeUv(bool x) {
      Attrs ret = *this;
      ret.compute_uv_ = x;
      return ret;
    }

    /// If true, compute full-sized `u` and `v`. If false
    /// (the default), compute only the leading `P` singular vectors.
    /// Ignored if `compute_uv` is `False`.
    ///
    /// Defaults to false
    TF_MUST_USE_RESULT Attrs FullMatrices(bool x) {
      Attrs ret = *this;
      ret.full_matrices_ = x;
      return ret;
    }

    bool compute_uv_ = true;
    bool full_matrices_ = false;
  };
  Svd(const ::tensorflow::Scope& scope, ::tensorflow::Input input);
  Svd(const ::tensorflow::Scope& scope, ::tensorflow::Input input, const
    Svd::Attrs& attrs);

  static Attrs ComputeUv(bool x) {
    return Attrs().ComputeUv(x);
  }
  static Attrs FullMatrices(bool x) {
    return Attrs().FullMatrices(x);
  }

  Operation operation;
  ::tensorflow::Output s;
  ::tensorflow::Output u;
  ::tensorflow::Output v;
};

/// @}

}  // namespace ops
}  // namespace tensorflow

#endif  // TENSORFLOW_CC_OPS_LINALG_OPS_H_