ctf package¶
Submodules¶
ctf.core module¶
-
ctf.core.
MPI_Stop
()¶ Kill all working nodes.
-
ctf.core.
TTTP
(A, mat_list) Compute updates to entries in tensor A based on matrices in mat_list (tensor times tensor products)¶ Compute updates to entries in tensor A based on matrices in mat_list (tensor times tensor products)
- Parameters
- A: tensor_like
Input tensor of arbitrary ndim
- mat_list: list of size A.ndim
Contains either None or matrix of dimensions m-by-k or vector, where m matches the corresponding mode length of A and k is the same for all given matrices (or all are vectors)
- Returns
- B: tensor
A tensor of the same ndim as A, updating by taking products of entries of A with multilinear dot products of columns of given matrices. For ndim=3 and mat_list=[X,Y,Z], this operation is equivalent to einsum(“ijk,ia,ja,ka->ijk”,A,X,Y,Z)
-
ctf.core.
abs
()¶ Calculate the elementwise absolute value of a tensor.
- Parameters
- A: tensor_like
Input tensor.
- Returns
- output: tensor
A tensor containing the absolute value of each element in input tensor. For complex number \(a + bi\), the absolute value is calculated as \(\sqrt{a^2 + b^2}\)
Examples
>>> import ctf >>> a = ctf.astensor([-2, 3]) array([-2, 3]) >>> abs(a) array([2, 3])
-
ctf.core.
all
()¶ Return whether given an axis elements are True.
- Parameters
- A: tensor_like
Input tensor.
- axis: None or int, optional
Currently not supported in CTF Python.
- out: tensor, optional
Currently not supported in CTF Python.
- keepdimsbool, optional
Currently not supported in CTF Python.
- Returns
- output: tensor_like
Output tensor or scalar.
Examples
>>> import ctf >>> a = ctf.astensor([[0, 1], [1, 1]]) >>> ctf.all(a) False
-
ctf.core.
any
()¶ Return whether given an axis any elements are True.
- Parameters
- A: tensor_like
Input tensor.
- axis: None or int, optional
Axis along which logical OR is applied.
- out: tensor_like, optional
Objects which will place the result.
- keepdims: bool, optional
If keepdims is set to True, the reduced axis will remain 1 in shape.
- Returns
- output: tensor_like
Output tensor or scalar.
Examples
>>> import ctf >>> a = ctf.astensor([[0, 0], [1, 1]]) >>> ctf.any(a) True >>> ctf.any(a, axis=0) array([ True, True]) >>> ctf.any(a, axis=1) array([False, True])
-
ctf.core.
arange
()¶ Generate CTF vector with values from start to stop (inclusive) in increments of step
- Parameters
- start: scalar
first element value
- stop: scalar
bound on last element value
- step: scalar
increment between values (default 1)
- dtype: type
datatype (default None, uses type of start)
- Returns
- ——-
- output: tensor (CTF vector)
A vector of length ceil((stop-start)/step) containing values start, start+step, start+2*step, etc.
References
numpy.arange
-
ctf.core.
array
()¶ Create a tensor.
- Parameters
- A: tensor_like
Input tensor like object.
- dtype: data-type, optional
The desired data-type for the tensor. If the dtype is not specified, the dtype will be determined as np.array().
- copy: bool, optional
If copy is true, the object is copied.
- order: {‘K’, ‘A’, ‘C’, ‘F’}, optional
Specify the memory layout for the tensor.
- subok: bool, optional
Currently subok is not supported in ctf.array().
- ndmin: int, optional
Currently ndmin is not supported in ctf.array().
- Returns
- output: tensor
A tensor object with specified requirements.
See also
ctf
ctf.astensor()
Notes
The input of ctf.array() should be tensor or numpy.ndarray
Examples
>>> import ctf >>> import numpy as np >>> a = np.array([1, 2, 3.]) array([1., 2., 3.]) >>> b = ctf.array(a) array([1., 2., 3.])
-
ctf.core.
astensor
()¶ Convert the input data to tensor.
- Parameters
- A: tensor_like
Input data.
- dtype: data-type, optional
Numpy data-type, if it is not specified, the function will return the tensor with same type as np.asarray returned ndarray.
- order: {‘C’, ‘F’}, optional
C or Fortran memory order, default is ‘F’.
- Returns
- output: tensor
A tensor representation of A.
See also
numpy
numpy.asarray()
Examples
>>> import ctf >>> a = ctf.astensor([1,2,3]) >>> a array([1, 2, 3])
-
ctf.core.
ceil
(x, out=None) Elementwise ceiling to integer (output as floating point type)¶ Elementwise ceiling to integer (output as floating point type)
- Parameters
- x: tensor_like
Input tensor.
- Returns
- out: tensor
A tensor of same structure and dtype as x with values ceil(f)
-
ctf.core.
cholesky
()¶ Compute Cholesky factorization of tensor A.
- Parameters
- A: tensor_like
Input matrix
- Returns
- L: tensor
A CTF tensor with 2 dimensions corresponding to lower triangular Cholesky factor of A
-
ctf.core.
conj
()¶ Return the conjugate tensor A element-wisely.
- Parameters
- A: tensor_like
Input tensor.
- Returns
- output: tensor
The element-wise complex conjugate of input tensor A. If tensor A is not complex, just return a copy of A.
Examples
>>> import ctf >>> a = ctf.astensor([2+3j, 3-2j]) array([2.+3.j, 3.-2.j]) >>> ctf.conj(a) array([2.-3.j, 3.+2.j])
-
class
ctf.core.
contract_term
¶ Bases:
ctf.core.term
- Attributes
- dtype
Methods
conv_type
scale
-
conv_type
()¶
-
ctf.core.
copy
()¶ Return a copy of tensor A.
- Parameters
- A: tensor
Input tensor.
- Returns
- output: tensor
A tensor representation of A.
Examples
>>> a = ctf.astensor([1,2,3]) >>> a array([1, 2, 3]) >>> b = ctf.copy(a) >>> b array([1, 2, 3]) >>> id(a) == id(b) False
-
ctf.core.
diag
()¶ Return the diagonal tensor of A.
- Parameters
- A: tensor_like
Input tensor with 1 or 2 dimensions. If A is 1-D tensor, return a 2-D tensor with A on diagonal.
- k: int, optional
k=0 is the diagonal. k<0, diagnals below the main diagonal. k>0, diagonals above the main diagonal.
- sp: bool, optional
If sp is true, the returned tensor is sparse.
- Returns
- output: tensor
Diagonal tensor of A.
See also
ctf
ctf.diagonal() ctf.triu() ctf.tril() ctf.trace() ctf.spdiag()
Notes
When the input tensor is sparse, returned tensor will also be sparse.
Examples
>>> import ctf >>> a = ctf.ones([3,]) >>> ctf.diag(a, k=1) array([[0., 1., 0., 0.], [0., 0., 1., 0.], [0., 0., 0., 1.]]) >>> b = ctf.zeros([4,4]) >>> ctf.diag(b) array([0., 0., 0., 0.])
-
ctf.core.
diagonal
()¶ Return the diagonal of tensor A if A is 2D. If A is a higher order square tensor (same shape for every dimension), return diagonal of tensor determined by axis1=0, axis2=1.
- Parameters
- A: tensor_like
Input tensor.
- offset: int, optional
Default is 0 which indicates the main diagonal.
- axis1: int, optional
Default is 0 which indicates the first axis of 2-D tensor where diagonal is taken.
- axis2: int, optional
Default is 1 which indicates the second axis of 2-D tensor where diagonal is taken.
- Returns
- output: tensor
Diagonal of input tensor.
Notes
ctf.diagonal only supports diagonal of square tensor with order more than 2.
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3], [4,5,6], [7,8,9]]) >>> ctf.diagonal(a) array([1, 5, 9])
-
ctf.core.
dot
()¶ Return the dot product of two tensors A and B.
- Parameters
- A: tensor_like
First input tensor.
- B: tensor_like
Second input tensor.
- out: tensor
Currently not supported in CTF Python.
- Returns
- output: tensor
Dot product of two tensors.
See also
numpy
numpy.dot()
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3], [4,5,6], [7,8,9]]) >>> b = ctf.astensor([1,1,1]) >>> ctf.dot(a, b) array([ 6, 15, 24])
-
ctf.core.
eigh
()¶ Compute eigenvalues of eigenvectors of A, assuming that it is symmetric or Hermitian
- Parameters
- A: tensor_like
Input matrix
- Returns
- D: tensor
CTF vector containing eigenvalues of A
- X: tensor
CTF matrix containing all eigenvectors of A
-
ctf.core.
einsum
()¶ Einstein summation on operands.
- Parameters
- subscripts: str
Subscripts for summation.
- operands: list of tensor
List of tensors.
- out: tensor or None
If the out is not None, calculated result will stored into out tensor.
- dtype: data-type, optional
Numpy data-type of returned tensor, dtype of returned tensor will be specified by operand tensors.
- order: {‘C’, ‘F’, ‘A’, ‘K’}, optional
Currently not supported by CTF Python.
- casting: {‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, optional
Currently not supported by CTF Python.
- out_scale: scalar, optional
Scales output prior to accumulation of contraction, by default is zero (as in numpy)
- Returns
- output: tensor
See also
numpy
numpy.einsum()
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3], [4,5,6], [7,8,9]]) >>> ctf.einsum("ii->i", a) array([1, 5, 9])
-
ctf.core.
empty
()¶ Return the tensor with specified shape and dtype without initialization. Currently not supported by CTF Python, this function same with the ctf.zeros().
- Parameters
- shape: int or tuple of int
Shape of the empty tensor.
- dtype: data-type, optional
Output data-type for the empty tensor.
- order: {‘C’, ‘F’}, optional, default: ‘F’
Currently not supported by CTF Python.
- sp: {True, False}, optional, default: ‘False’
Whether to represent tensor in a sparse format.
- Returns
- output: tensor_like
Output tensor.
Examples
>>> import ctf >>> import numpy as np >>> a = ctf.empty([3,4], dtype=np.int64) >>> a array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])
-
ctf.core.
empty_like
()¶ Return uninitialized tensor of with same shape and dtype of tensor A. Currently in CTF Python is same with ctf.zero_like.
- Parameters
- A: tensor_like
Input tensor where the output tensor shape and dtype defined as.
- dtype: data-type, optional
Output data-type for the empty tensor.
- Returns
- output: tensor_like
Output tensor.
See also
ctf
ctf.zeros_like()
Examples
>>> import ctf >>> a = ctf.zeros([3,4], dtype=np.int64) >>> b = ctf.empty_like(a) >>> b array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])
-
ctf.core.
exp
()¶ Exponential of all elements in input tensor A.
- Parameters
- A: tensor_like
Input tensor or tensor like array.
- out: tensor, optional
Crrently not supported by CTF Python.
- where: array_like, optional
Crrently not supported by CTF Python.
- casting: same_kind or unsafe
Default same_kind.
- order: optional
Crrently not supported by CTF Python.
- dtype: data-type, optional
Output data-type for the exp result.
- subok: bool
Crrently not supported by CTF Python.
- Returns
- output: tensor_like
Output tensor for the exponential.
See also
numpy
numpy.exp()
Examples
>>> import ctf >>> a = ctf.astensor([1,2,3]) >>> ctf.exp(a) array([ 2.71828183, 7.3890561 , 20.08553692])
-
ctf.core.
eye
()¶ Return a 2D tensor with ones on the diagonal and zeros elsewhere.
- Parameters
- n: int
Number of rows.
- m: int, optional
Number of columns, default set to n.
- k: int, optional
Diagonal index, specify ones on main diagonal, upper diagonal or lower diagonal.
- dtype: data-type, optional
Numpy data-type of returned tensor, default np.float64.
- sp: bool, optional
If true the returned tensor will be sparse, default sp=False.
- Returns
- output: tensor
Examples
>>> import ctf >>> e = ctf.eye(3,m=4,k=-1) >>> e array([[0., 0., 0., 0.], [1., 0., 0., 0.], [0., 1., 0., 0.]])
-
ctf.core.
floor
()¶ Elementwise round to integer by dropping decimal fraction (output as floating point type). Uses c-style round-to-greatest rule to break-tiies as opposed to numpy’s round to nearest even
- Parameters
- x: tensor_like
Input tensor.
- Returns
- out: tensor
A tensor of same structure and dtype as x with values rounded C-style to int
-
ctf.core.
from_nparray
()¶ Convert the numpy array to tensor.
- Parameters
- A: ndarray
Input numpy array.
- Returns
- output: tensor
Tensor representation of input numpy array.
See also
ctf
ctf.astensor()
Examples
>>> import ctf >>> import numpy as np >>> a = np.array([1,2,3]) >>> b = ctf.from_nparray(a) >>> b array([1, 2, 3]) >>> type(b) <class 'ctf.core.tensor'>
-
ctf.core.
hstack
()¶ Stack the tensor in column-wise.
- Parameters
- in_tup: tuple of tensors
Input tensor.
- Returns
- output: tensor_like
Output horizontally stacked tensor.
Examples
>>> import ctf >>> a = ctf.astensor([1,2,3]) >>> b = ctf.astensor([4,5,6]) >>> ctf.hstack((a, b)) array([1, 2, 3, 4, 5, 6])
-
ctf.core.
identity
()¶ Return a squared 2-D tensor where the main diagonal contains ones and elsewhere zeros.
- Parameters
- n: int
Number of rows.
- dtype: data-type, optional
Numpy data-type of returned tensor, default np.float64.
- Returns
- output: tensor
See also
ctf
ctf.eye()
Examples
>>> import ctf >>> a = ctf.identity(3) >>> a array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]])
-
ctf.core.
imag
()¶ Return the image part of the tensor elementwisely.
- Parameters
- A: tensor_like
Input tensor.
- Returns
- output: tensor
A tensor with real part of the input tensor.
See also
numpy
numpy.imag()
Notes
The input should be a CTF tensor.
Examples
>>> import ctf >>> a = ctf.astensor([1+2j, 3+4j, 5+6j, 7+8j]) >>> a array([1.+2.j, 3.+4.j, 5.+6.j, 7.+8.j]) >>> ctf.imag(a) array([2., 4., 6., 8.])
-
class
ctf.core.
itensor
¶ Bases:
ctf.core.term
- Attributes
- dtype
- string
- tsr
Methods
svd
()Compute Single Value Decomposition of a given transposition/matricization of tensor A.
conv_type
scale
scl
-
conv_type
()¶
-
scl
()¶
-
string
¶
-
svd
()¶ Compute Single Value Decomposition of a given transposition/matricization of tensor A.
- Parameters
- U_string: char string
Indices indexing left singular vectors, should be subset of the string of this itensor plus an auxiliary index
- VT_string: char string
Indices indexing right singular vectors, should be subset of the string of this itensor, plus same auxiliary index as in U
- threshold: real double precision or None, optional
threshold for truncating singular values of the SVD, determines rank, if threshold ia also used, rank will be set to minimum of rank and number of singular values above threshold
- niter: int or None, optional, default 1
number of orthogonal iterations to perform (higher gives better accuracy)
- oversamp: int or None, optional, default 5
oversampling parameter
- Returns
- U: tensor
A unitary CTF tensor with dimensions len(U_string).
- S: tensor
A 1-D tensor with singular values.
- VT: tensor
A unitary CTF tensor with dimensions len(VT_string)+1.
-
tsr
¶
-
ctf.core.
kron
()¶ Kronecker product of A and B, generalized to arbitrary order by taking Kronecker product along all modes Tensor of lesser order is padded with lengths of dimension 1.
- Parameters
- A: tensor_like
Input tensor or tensor like array.
- B: tensor_like
Input tensor or tensor like array.
- Returns
- output: tensor_like
Output tensor with size being the product of sizes of A and B
See also
numpy
numpy.kron()
-
ctf.core.
norm
()¶ Return vector or matrix norm of tensor A. If A a matrix, compute induced (1/2/infinity)-matrix norms or Frobenius norm, if A has one or more than three dimensions, treat as vector
- Parameters
- A: tensor_like
Input tensor with 1, 2, or more dimensions.
- ord: {int 1, 2, inf}, optional
Order of the norm.
- Returns
- output: tensor
Norm of tensor A.
Examples
>>> import ctf >>> import ctf.linalg as la >>> a = ctf.astensor([3,4.]) >>> la.vecnorm(a) 5.0
-
ctf.core.
ones
()¶ Return a tensor filled with ones with specified shape and dtype.
- Parameters
- shape: int or sequence of ints
Shape of the returned tensor.
- dtype: numpy data-type, optional
The data-type for the tensor.
- order: {‘C’, ‘F’}, optional
Not support by current CTF Python.
- Returns
- output: tensor
Tensor with specified shape and dtype.
Examples
>>> import ctf >>> a = ctf.ones([2, 2]) >>> a array([[1., 1.], [1., 1.]])
-
ctf.core.
power
()¶ Elementwisely raise tensor A to powers from the tensor B.
- Parameters
- A: tensor_like
Bases tensor.
- B: tensor_like
Exponents tensor
- Returns
- output: tensor
The output tensor containing elementwise bases A raise to exponents of B.
Examples
>>> import ctf >>> a = ctf.astensor([2., 3]) array([2., 3.]) >>> b = ctf.astensor([2., 3]) array([2., 3.]) >>> ctf.power(a, b) array([ 4., 27.])
-
ctf.core.
qr
()¶ Compute QR factorization of matrix A.
- Parameters
- A: tensor_like
Input matrix
- Returns
- Q: tensor
A CTF tensor with 2 dimensions and orthonormal columns.
- R: tensor
An upper triangular 2-D CTF tensor.
-
ctf.core.
ravel
()¶ Return flattened CTF tensor of input tensor A.
- Parameters
- A: tensor_like
Input tensor.
- order: {‘C’,’F’, ‘A’, ‘K’}, optional
Currently not supported by current CTF Python.
- Returns
- output: tensor_like
Flattened tensor.
Examples
>>> import ctf >>> a = ctf.astensor([1,2,3,4,5,6,7,8]).reshape(2,2,2) >>> a array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) >>> ctf.ravel(a) array([1, 2, 3, 4, 5, 6, 7, 8])
-
ctf.core.
real
()¶ Return the real part of the tensor elementwisely.
- Parameters
- A: tensor_like
Input tensor.
- Returns
- output: tensor
A tensor with real part of the input tensor.
See also
numpy
numpy.real()
Notes
The input should be a CTF tensor.
Examples
>>> import ctf >>> a = ctf.astensor([1+2j, 3+4j, 5+6j, 7+8j]) >>> a array([1.+2.j, 3.+4.j, 5.+6.j, 7.+8.j]) >>> ctf.real(a) array([1., 3., 5., 7.])
-
ctf.core.
reshape
()¶ Reshape the input tensor A to new shape.
- Parameters
- A: tensor_like
Input tensor.
- newshape: tuple of ints or int
New shape where the input tensor is shaped to.
- order: {‘C’, ‘F’}, optional
Currently not supported by CTF Python.
- Returns
- output: tensor
Tensor with new shape of A.
See also
ctf
ctf.tensor.reshape()
Examples
>>> import ctf a = ctf.astensor([1,2,3,4]) >>> ctf.reshape(a, (2, 2)) array([[1, 2], [3, 4]])
-
ctf.core.
rint
(x, out=None) Elementwise round to nearest integer (output as floating point type)¶ Elementwise round to nearest integer (output as floating point type)
- Parameters
- x: tensor_like
Input tensor.
- Returns
- out: tensor
A tensor of same structure and dtype as x with values rounded to nearest integer
-
ctf.core.
solve_tri
(L, B, lower, from_left, transp_L)¶ - Parameters
- L: tensor_like
Triangular matrix encoding equations
- B: tensor_like
Right or left hand sides
- lower: bool
if true L is lower triangular, if false upper
- from_left: bool
if true solve LX = B, if false, solve XL=B
- transp_L: bool
if true solve L^TX = B or XL^T=B
- Returns
- X: tensor
CTF matrix containing solutions to triangular equations, same shape as B
-
ctf.core.
spdiag
()¶ Return the sparse diagonal tensor of A.
- Parameters
- A: tensor_like
Input tensor with 1 or 2 dimensions. If A is 1-D tensor, return a 2-D tensor with A on diagonal.
- k: int, optional
k=0 is the diagonal. k<0, diagnals below the main diagonal. k>0, diagonals above the main diagonal.
- Returns
- output: tensor
Sparse diagonal tensor of A.
Notes
Same with ctf.diag(A,k,sp=True)
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3], [4,5,6], [7,8,9]]) >>> ctf.spdiag(a) array([1, 5, 9])
-
ctf.core.
speye
()¶ Return a sparse 2D tensor with ones on the diagonal and zeros elsewhere.
- Parameters
- n: int
Number of rows.
- m: int, optional
Number of columns, default set to n.
- k: int, optional
Diagonal index, specify ones on main diagonal, upper diagonal or lower diagonal.
- dtype: data-type, optional
Numpy data-type of returned tensor, default np.float64.
- Returns
- output: tensor
See also
ctf
ctf.eye()
Examples
>>> import ctf >>> e = ctf.speye(3,m=4,k=-1) >>> e array([[0., 0., 0., 0.], [1., 0., 0., 0.], [0., 1., 0., 0.]])
-
ctf.core.
sum
()¶ Sum of elements in tensor or along specified axis.
- Parameters
- A: tensor_like
Input tensor.
- axis: None, int or tuple of ints
Axis or axes where the sum of elements is performed.
- dtype: data-type, optional
Data-type for the output tensor.
- out: tensor, optional
Alternative output tensor.
- keepdims: None, bool, optional
If set to true, axes summed over will remain size one.
- Returns
- output: tensor_like
Output tensor.
See also
numpy
numpy.sum()
Examples
>>> import ctf >>> a = ctf.ones([3,4], dtype=np.int64) >>> ctf.sum(a) 12
-
class
ctf.core.
sum_term
¶ Bases:
ctf.core.term
- Attributes
- dtype
Methods
conv_type
scale
-
conv_type
()¶
-
ctf.core.
svd
()¶ Compute Single Value Decomposition of matrix A.
- Parameters
- A: tensor_like
Input tensor 2 dimensions.
- rank: int or None, optional
Target rank for SVD, default rank=None, implying full rank.
- threshold: real double precision or None, optional
Threshold for truncation of singular values. Either rank or threshold must be set to None.
- Returns
- U: tensor
A unitary CTF tensor with 2 dimensions.
- S: tensor
A 1-D tensor with singular values.
- VT: tensor
A unitary CTF tensor with 2 dimensions.
-
ctf.core.
svd_rand
()¶ Uses randomized method (orthogonal iteration) to calculate a low-rank singular value decomposition, M = U x S x VT. Is faster, especially for low-rank, but less robust than typical svd.
- Parameters
- A: tensor_like
Input matrix
- rank: int
Target SVD rank
- niter: int or None, optional, default 1
number of orthogonal iterations to perform (higher gives better accuracy)
- oversamp: int or None, optional, default 5
oversampling parameter
- VT_guess: initial guess for first rank+oversamp singular vectors (matrix with orthogonal columns is also good), on output is final iterate (with oversamp more columns than VT)
- Returns
- U: tensor
A unitary CTF tensor with 2 dimensions.
- S: tensor
A 1-D tensor with singular values.
- VT: tensor
A unitary CTF tensor with 2 dimensions.
-
ctf.core.
take
()¶ Take elements from a tensor along axis.
- Parameters
- A: tensor_like
Input tensor.
- indices: tensor_like
Indices of the values wnat to be extracted.
- axis: int, optional
Select values from which axis, default None.
- out: tensor
Currently not supported in CTF Python take().
- mode: {‘raise’, ‘wrap’, ‘clip’}, optional
Currently not supported in CTF Python take().
- Returns
- output: tensor or scalar
Elements extracted from the input tensor.
See also
numpy
numpy.take()
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3], [4,5,6], [7,8,9]]) >>> ctf.take(a, [0, 1, 2]) array([1, 2, 3])
-
class
ctf.core.
tensor
¶ Bases:
object
The class for CTF Python tensor.
- Attributes
- nbytes: int
The number of bytes for the tensor.
- size: int
Total number of elements in the tensor.
- ndim: int
Number of dimensions.
- sp: int
0 indicates the tensor is not sparse tensor, 1 means the tensor is CTF sparse tensor.
- strides: tuple
Tuple of bytes for each dimension to traverse the tensor.
- shape: tuple
Tuple of each dimension.
- dtype: data-type
Numpy data-type, indicating the type of tensor.
- itemsize: int
One element in bytes.
- order: {‘F’,’C’}
Bytes memory order for the tensor.
- sym: ndarray
Symmetry description of the tensor, sym[i] describes symmetry relation SY/AS/SH of mode i to mode i+1 NS (0) is nonsymmetric, SY (1) is symmetric, AS (2) is antisymmetric, SH (3) is symmetric with zero diagonal
Methods
T:
Transpose of tensor.
all:
Whether all elements give an axis for a tensor is true.
astype:
Copy the tensor to specified type.
conj:
Return the self conjugate tensor element-wisely.
copy:
Copy the tensor to a new tensor.
diagonal:
Return the diagonal of the tensor if it is 2D. If the tensor is a higher order square tensor (same shape for every dimension), return diagonal of tensor determined by axis1=0, axis2=1.
dot:
Return the dot product with tensor other.
fill_random:
Fill random elements to the tensor.
fill_sp_random:
Fill random elements to a sparse tensor.
from_nparray:
Convert numpy ndarray to CTF tensor.
get_dims:
Return the dims/shape of tensor.
get_type:
Return the dtype of tensor.
i:
Core function on summing the ctensor.
imag:
Return imaginary part of a tensor or set its imaginary part to new value.
norm1:
1-norm of the tensor.
norm2:
2-norm of the tensor.
norm_infty:
Infinity-norm of the tensor.
permute:
Permute the tensor.
prnt:
Function to print the non-zero elements and their indices of a tensor.
ravel:
Return the flattened tensor.
read:
Helper function on reading a tensor.
read_all:
Helper function on reading a tensor.
read_local:
Helper function on reading a tensor.
read_local_nnz:
Helper function on reading a tensor.
real:
Return real part of a tensor or set its real part to new value.
reshape:
Return a new tensor with reshaped shape.
sample:
Extract a sample of the entries (if sparse of the current nonzeros) by keeping each entry with probability p. Also transforms tensor into sparse format if not already.
set_all:
Set all elements in a tensor to a value.
set_zero:
Set all elements in a tensor to 0.
sum:
Sum of elements in tensor or along specified axis.
take:
Take elements from a tensor along axis.
tensordot:
Return the tensor dot product of two tensors along axes.
to_nparray:
Convert the tensor to numpy array.
trace:
Return the sum over the diagonal of the tensor.
transpose:
Return the transposed tensor with specified order of axes.
write:
Helper function on writing a tensor.
write_all:
Helper function on writing a tensor.
-
T
()¶ Permute the dimensions of the input tensor.
- Returns
- output: tensor
Tensor with permuted axes.
See also
ctf
ctf.transpose
Examples
>>> import ctf >>> a = ctf.zeros([3,4,5]) >>> a.shape (3, 4, 5) >>> a.T().shape (5, 4, 3)
-
all
()¶ Return whether given an axis elements are True.
- Parameters
- axis: None or int, optional
Currently not supported in CTF Python.
- out: tensor, optional
Currently not supported in CTF Python.
- keepdimsbool, optional
Currently not supported in CTF Python.
- Returns
- output: tensor_like
Output tensor or scalar.
See also
ctf
ctf.all
Examples
>>> import ctf >>> a = ctf.astensor([[0, 1], [1, 1]]) >>> a.all() False
-
astype
()¶ Copy the tensor to specified type.
- Parameters
- dtype: data-type
Numpy data-type.
- order: {‘F’, ‘C’}
Bytes order for the tensor.
- casting: {‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, optional
Control the casting. Please refer to numpy.ndarray.astype, please refer to numpy.ndarray.astype for more information.
- Returns
- output: tensor
Copied tensor with specified data-type.
See also
numpy
numpy.ndarray.astype
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3], [4,5,6], [7,8,9]]) >>> a.dtype <class 'numpy.int64'> >>> a.astype(np.float64).dtype <class 'numpy.float64'>
-
conj
()¶ Return the self conjugate tensor element-wisely.
- Returns
- output: tensor
The element-wise complex conjugate of the tensor. If the tensor is not complex, just return a copy.
Examples
>>> import ctf >>> a = ctf.astensor([2+3j, 3-2j]) >>> a array([2.+3.j, 3.-2.j]) >>> a.conj() array([2.-3.j, 3.+2.j])
-
copy
()¶ Copy the tensor to a new tensor.
- Returns
- output: tensor_like
Output copied tensor.
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3],[4,5,6]]) >>> b = a.copy() >>> id(a) == id(b) False >>> a == b array([[ True, True, True], [ True, True, True]])
-
diagonal
()¶ Return the diagonal of the tensor if it is 2D. If the tensor is a higher order square tensor (same shape for every dimension), return diagonal of tensor determined by axis1=0, axis2=1.
- Parameters
- offset: int, optional
Default is 0 which indicates the main diagonal.
- axis1: int, optional
Default is 0 which indicates the first axis of 2-D tensor where diagonal is taken.
- axis2: int, optional
Default is 1 which indicates the second axis of 2-D tensor where diagonal is taken.
- Returns
- output: tensor
Diagonal of input tensor.
Notes
ctf.diagonal only supports diagonal of square tensor with order more than 2.
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3], [4,5,6], [7,8,9]]) >>> a.diagonal() array([1, 5, 9])
-
dot
()¶ Return the dot product with tensor other.
- Parameters
- other: tensor_like
The other input tensor.
- out: tensor
Currently not supported in CTF Python.
- Returns
- output: tensor
Dot product of two tensors.
See also
numpy
numpy.dot()
ctf
ctf.dot()
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3], [4,5,6], [7,8,9]]) >>> b = ctf.astensor([1,1,1]) >>> a.dot(b) array([ 6, 15, 24])
-
dtype
¶ Attribute dtype. Numpy data-type, indicating the type of tensor.
-
fill_random
()¶ Fill random elements to the tensor.
- Parameters
- mn: int or float
The range of random number from, default 0.
- mx: int or float
The range of random number to, default 1.
See also
ctf
ctf.tensor.fill_sp_random()
Examples
>>> import ctf >>> a = ctf.zeros([2, 2]) >>> a array([[0., 0.], [0., 0.]]) >>> a.fill_random(3,5) >>> a array([[3.31908598, 4.34013067], [4.5355426 , 4.6763659 ]])
-
fill_sp_random
()¶ Fill random elements to a sparse tensor.
- Parameters
- mn: int or float
The range of random number from, default 0.
- mx: int or float
The range of random number to, default 1.
- frac_sp: float
The percent of non-zero elements.
See also
ctf
ctf.tensor.fill_random()
Examples
>>> import ctf >>> a = ctf.tensor([3, 3], sp=1) >>> a.fill_sp_random(frac_sp=0.2) >>> a array([[0.96985989, 0. , 0. ], [0. , 0. , 0.10310342], [0. , 0. , 0. ]])
-
from_nparray
()¶ Convert numpy ndarray to CTF tensor.
- Returns
- output: tensor
CTF tensor of the numpy ndarray.
Examples
>>> import ctf >>> import numpy as np >>> a = np.asarray([1.,2.,3.]) >>> b = ctf.zeros([3, ]) >>> b.from_nparray(a) >>> b array([1., 2., 3.])
-
get_dims
()¶ Return the dims/shape of tensor.
- Returns
- output: tuple
Dims or shape of the tensor.
-
get_type
()¶ Return the dtype of tensor.
- Returns
- output: data-type
Dtype of the tensor.
-
i
()¶ Core function on summing the ctensor.
- Parameters
- string: string
Dimensions for summation.
- Returns
- output: tensor_like
Output tensor or scalar.
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3],[4,5,6]]) >>> a.i("ij") << a.i("ij") >>> a array([[ 2, 4, 6], [ 8, 10, 12]])
-
imag
()¶ Return imaginary part of a tensor or set its imaginary part to new value.
- Returns
- value: tensor_like
The value tensor set imaginary to the original tensor, current only support value tensor with dtype np.float64 or np.complex128. Default is none.
See also
ctf
ctf.reshape()
Examples
>>> import ctf >>> a = ctf.astensor([1+2j, 3+4j]) >>> b = ctf.astensor([5,6], dtype=np.float64) >>> a.imag(value = b) >>> a array([5.+2.j, 6.+4.j])
-
item
()¶ get value of scalar stored in size 1 tensor
- Returns
- output: scalar
-
itemsize
¶ Attribute itemsize. One element in bytes.
-
nbytes
¶ Attribute nbytes. The number of bytes for the tensor.
-
ndim
¶ Attribute ndim. Number of dimensions.
-
nnz_tot
¶ Total number of nonzeros in tensor
-
norm1
()¶ 1-norm of the tensor.
- Returns
- output: scalar
1-norm of the tensor.
Examples
>>> import ctf >>> a = ctf.ones([3,4], dtype=np.float64) >>> a.norm1() 12.0
-
norm2
()¶ 2-norm of the tensor.
- Returns
- output: scalar np.float64
2-norm of the tensor.
Examples
>>> import ctf >>> a = ctf.ones([3,4], dtype=np.float64) >>> a.norm2() 3.4641016151377544
-
norm_infty
()¶ Infinity norm of the tensor.
- Returns
- output: scalar
Infinity norm of the tensor.
Examples
>>> import ctf >>> a = ctf.ones([3,4], dtype=np.float64) >>> a.norm_infty() 1.0
-
order
¶ Attribute order. Bytes memory order for the tensor.
-
permute
(self, tensor A, p_A=None, p_B=None, a=None, b=None)¶ - Permute the tensor along each mode, so that
self[p_B[0,i_1],….,p_B[self.ndim-1,i_ndim]] = A[i_1,….,i_ndim]
- or
B[i_1,….,i_ndim] = A[p_A[0,i_1],….,p_A[self.ndim-1,i_ndim]]
exactly one of p_A or p_B should be provided.
- Parameters
- A: CTF tensor
Tensor whose data will be permuted.
- p_A: list of arrays
List of length A.ndim, the ith item of which is an array of slength A.shape[i], with values specifying the permutation target of that index or -1 to denote that this index should be projected away.
- p_B: list of arrays
List of length self.ndim, the ith item of which is an array of slength Aselfshape[i], with values specifying the permutation target of that index or -1 to denote that this index should not be permuted to.
- a: scalar
Scaling for values in a (default 1)
- b: scalar
Scaling for values in self (default 0)
-
prnt
()¶ Function to print the non-zero elements and their indices of a tensor.
Examples
>>> import ctf >>> a = ctf.astensor([0,1,2,3,0]) >>> a.prnt() Printing tensor ZYTP01 [1](1, <1>) [2](2, <2>) [3](3, <3>)
-
ravel
()¶ Return the flattened tensor.
- Returns
- output: tensor_like
Output flattened tensor.
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3],[4,5,6]]) >>> a.ravel() array([1, 2, 3, 4, 5, 6])
-
read
(inds, vals=None, a=None, b=None)¶ Retrieves and accumulates a set of values to a corresponding set of specified indices (a is scaling for vals and b is scaling for old vlaues in tensor). vals[i] = b*vals[i] + a*T[inds[i]] Each MPI process is expected to read a different subset of values and all MPI processes must participate (even if reading nothing). However, the set of values read may overlap.
- Parameters
- inds: array (1D or 2D)
If 1D array, each index specifies global index, e.g. access T[i,j,k] via i+n*j+n^2*k, if 2D array, a corresponding row would be [i,j,k]
- vals: array
A 1D array specifying values to be accumulated to for each index, if None, this array will be returned
- a: scalar
Scaling factor to apply to data in tensor (default is 1)
- b: scalar
Scaling factor to apply to vals (default is 0)
-
read_all
()¶ reads all values in the tensor
- Parameters
- arr: array (optional, default: None)
preallocated storage for data, of size equal to number of elements in tensor
- unpack: bool (default: True)
whether to read symmetrically-equivallent values or only unique values
- Returns
- ——-
- output: tensor if arr is None, otherwise nothing
- ———-
-
read_all_nnz
()¶ reads all nonzero values in the tensor as key-value pairs where key is the global index
- Parameters
- unpack: bool (default: True)
whether to read symmetrically-equivallent values or only unique values
- Returns
- inds: global indices of each nonzero values
- vals: the nonzero values
-
read_from_file
()¶
-
read_local
()¶ Obtains tensor values stored on this MPI process
- Parameters
- unpack_sym: if true retrieves symmetrically equivalent entries, if alse only the ones unique up to symmetry
- Returns
- inds: array of global indices of nonzeros
- vals: array of values of nonzeros
- ——-
-
read_local_nnz
()¶ Obtains nonzeros of tensor stored on this MPI process
- Parameters
- unpack_sym: if true retrieves symmetrically equivalent entries, if alse only the ones unique up to symmetry
- Returns
- inds: array of global indices of nonzeros
- vals: array of values of nonzeros
- ——-
-
real
()¶ Return real part of a tensor or set its real part to new value.
- Returns
- value: tensor_like
The value tensor set real to the original tensor, current only support value tensor with dtype np.float64 or np.complex128. Default is none.
See also
ctf
ctf.reshape()
Examples
>>> import ctf >>> a = ctf.astensor([1+2j, 3+4j]) >>> b = ctf.astensor([5,6], dtype=np.float64) >>> a.real(value = b) >>> a array([5.+2.j, 6.+4.j])
-
reshape
()¶ Return a new tensor with reshaped shape.
- Returns
- output: tensor_like
Output reshaped tensor.
See also
ctf
ctf.reshape()
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3],[4,5,6]]) >>> a.reshape(6,1) array([[1], [2], [3], [4], [5], [6]])
-
sample
()¶ Extract a sample of the entries (if sparse of the current nonzeros) by keeping each entry with probability p. Also transforms tensor into sparse format if not already.
- Parameters
- p: float
Probability that keep each entry.
- Returns
- output: tensor or scalar
Elements extracted from the input tensor.
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3], [4,5,6], [7,8,9]]) >>> a.sample(0.1) >>> a array([[0, 0, 3], [0, 0, 6], [0, 0, 0]])
-
set_all
()¶ Set all elements in a tensor to a value.
- Parameters
- value: scalar
Value set to a tensor.
Examples
>>> import ctf >>> a = ctf.astensor([1,2,3]) >>> a.set_all(3) >>> a array([3, 3, 3])
-
set_zero
()¶
-
shape
¶ Attribute shape. Tuple of each dimension.
-
size
¶ Attribute size. Total number of elements in the tensor.
-
sp
¶ Attribute sp. 0 indicates the tensor is not sparse tensor, 1 means the tensor is CTF sparse tensor.
-
sparsify
()¶ Make tensor sparse and remove all values with value or absolute value if take_abs=True below threshold.
- Returns
- output: tensor
Sparsified version of the tensor
-
strides
¶ Attribute strides. Tuple of bytes for each dimension to traverse the tensor.
-
sum
()¶ Sum of elements in tensor or along specified axis.
- Parameters
- axis: None, int or tuple of ints
Axis or axes where the sum of elements is performed.
- dtype: data-type, optional
Data-type for the output tensor.
- out: tensor, optional
Alternative output tensor.
- keepdims: None, bool, optional
If set to true, axes summed over will remain size one.
- Returns
- output: tensor_like
Output tensor.
See also
numpy
numpy.sum()
Examples
>>> import ctf >>> a = ctf.ones([3,4], dtype=np.int64) >>> a.sum() 12
-
sym
¶ Attribute sym. ?
-
take
()¶ Take elements from a tensor along axis.
- Parameters
- indices: tensor_like
Indices of the values wnat to be extracted.
- axis: int, optional
Select values from which axis, default None.
- out: tensor
Currently not supported in CTF Python take().
- mode: {‘raise’, ‘wrap’, ‘clip’}, optional
Currently not supported in CTF Python take().
- Returns
- output: tensor or scalar
Elements extracted from the input tensor.
See also
numpy
numpy.take()
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3], [4,5,6], [7,8,9]]) >>> a.take([0, 1, 2]) array([1, 2, 3])
-
tensordot
()¶ Return the tensor dot product of two tensors along axes.
- Parameters
- other: tensor_like
Second input tensor.
- axes: int or array_like
Sum over which axes.
- Returns
- output: tensor
Tensor dot product of two tensors.
See also
numpy
numpy.tensordot()
Examples
>>> import ctf >>> import numpy as np >>> a = np.arange(60.).reshape(3,4,5) >>> b = np.arange(24.).reshape(4,3,2) >>> a = ctf.astensor(a) >>> b = ctf.astensor(b) >>> a.tensordot(b, axes=([1,0],[0,1])) array([[4400., 4730.], [4532., 4874.], [4664., 5018.], [4796., 5162.], [4928., 5306.]])
-
to_nparray
()¶ Convert tensor to numpy ndarray.
- Returns
- output: ndarray
Numpy ndarray of the tensor.
Examples
>>> import ctf >>> a = ctf.ones([3,4], dtype=np.float64) >>> a = ctf.ones([3,4]) >>> a.to_nparray() array([[1., 1., 1., 1.], [1., 1., 1., 1.], [1., 1., 1., 1.]])
-
tot_size
()¶
-
trace
()¶ Return the sum over the diagonal of input tensor.
- Parameters
- offset: int, optional
Default is 0 which indicates the main diagonal.
- axis1: int, optional
Default is 0 which indicates the first axis of 2-D tensor where diagonal is taken.
- axis2: int, optional
Default is 1 which indicates the second axis of 2-D tensor where diagonal is taken.
- dtype: data-type, optional
Numpy data-type, currently not supported in CTF Python trace().
- out: tensor
Currently not supported in CTF Python trace().
- Returns
- output: tensor or scalar
Sum along diagonal of input tensor.
See also
ctf
ctf.trace()
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3], [4,5,6], [7,8,9]]) >>> a.trace() 15
-
transpose
()¶ Return the transposed tensor with specified order of axes.
- Returns
- output: tensor
Tensor with permuted axes.
See also
ctf
ctf.transpose
Examples
>>> import ctf >>> a = ctf.zeros([3,4,5]) >>> a.shape (3, 4, 5) >>> a.transpose([2,1,0]).shape (5, 4, 3)
-
write
(inds, vals, a=None, b=None)¶ Accumulates a set of values to a corresponding set of specified indices (a is scaling for vals and b is scaling for old vlaues in tensor). T[inds[i]] = b*T[inds[i]] + a*vals[i]. Each MPI process is expected to write a different subset of values and all MPI processes must participate (even if writing nothing). However, the set of values written may overlap, in which case they will be accumulated.
- Parameters
- inds: array (1D or 2D)
If 1D array, each index specifies global index, e.g. access T[i,j,k] via i+n*j+n^2*k, if 2D array, a corresponding row would be [i,j,k]
- vals: array
A 1D array specifying values to write for each index
- a: scalar
Scaling factor to apply to vals (default is 1)
- b: scalar
Scaling factor to apply to existing data (default is 0)
-
write_all
()¶ Helper function on writing a tensor.
-
write_to_file
()¶
-
ctf.core.
tensordot
()¶ Return the tensor dot product of two tensors A and B along axes.
- Parameters
- A: tensor_like
First input tensor.
- B: tensor_like
Second input tensor.
- axes: int or array_like
Sum over which axes.
- Returns
- output: tensor
Tensor dot product of two tensors.
See also
numpy
numpy.tensordot()
Examples
>>> import ctf >>> import numpy as np >>> a = np.arange(60.).reshape(3,4,5) >>> b = np.arange(24.).reshape(4,3,2) >>> a = ctf.astensor(a) >>> b = ctf.astensor(b) >>> c = ctf.tensordot(a,b, axes=([1,0],[0,1])) >>> c array([[4400., 4730.], [4532., 4874.], [4664., 5018.], [4796., 5162.], [4928., 5306.]])
-
class
ctf.core.
term
¶ Bases:
object
- Attributes
- dtype
Methods
conv_type
scale
-
conv_type
()¶
-
dtype
¶
-
scale
()¶
-
ctf.core.
to_nparray
()¶ Convert the tensor to numpy array.
- Parameters
- A: tensor_like
Input tensor or tensor like array.
- Returns
- output: ndarray
Numpy ndarray representation of tensor like input A.
See also
numpy
numpy.asarray()
Examples
>>> import ctf >>> import numpy as np >>> a = ctf.zeros([3,4]) >>> b = ctf.to_nparray(a) >>> b array([[0., 0., 0., 0.], [0., 0., 0., 0.], [0., 0., 0., 0.]]) >>> type(b) <class 'numpy.ndarray'>
-
ctf.core.
trace
()¶ Return the sum over the diagonal of input tensor.
- Parameters
- A: tensor_like
Input tensor.
- offset: int, optional
Default is 0 which indicates the main diagonal.
- axis1: int, optional
Default is 0 which indicates the first axis of 2-D tensor where diagonal is taken.
- axis2: int, optional
Default is 1 which indicates the second axis of 2-D tensor where diagonal is taken.
- dtype: data-type, optional
Numpy data-type, currently not supported in CTF Python trace().
- out: tensor
Currently not supported in CTF Python trace().
- Returns
- output: tensor or scalar
Sum along diagonal of input tensor.
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3], [4,5,6], [7,8,9]]) >>> ctf.trace(a) 15
-
ctf.core.
transpose
()¶ Permute the dimensions of the input tensor.
- Parameters
- A: tensor_like
Input tensor.
- axes: list of ints, optional
If axes is None, the dimensions are inversed, otherwise permute the dimensions according to the axes value.
- Returns
- output: tensor
Tensor with permuted axes of A.
Examples
>>> import ctf >>> a = ctf.zeros([3,4,5]) >>> a.shape (3, 4, 5) >>> ctf.transpose(a, axes=[0, 2, 1]).shape (3, 5, 4) >>> ctf.transpose(a).shape (5, 4, 3)
-
ctf.core.
tril
()¶ Return lower triangle of a CTF tensor.
- Parameters
- A: tensor_like
2-D input tensor.
- k: int
Specify last diagonal not zeroed. Default k=0 which indicates elements under the main diagonal are zeroed.
- Returns
- output: tensor
Lower triangular 2-d tensor of input tensor.
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3],[4,5,6],[7,8,9]]) >>> ctf.tril(a, k=1) array([[1, 2, 0], [4, 5, 6], [7, 8, 9]])
-
ctf.core.
triu
()¶ Return upper triangle of a CTF tensor.
- Parameters
- A: tensor_like
2-D input tensor.
- k: int
Specify last diagonal not zeroed. Default k=0 which indicates elements under the main diagonal are zeroed.
- Returns
- output: tensor
Upper triangular 2-d tensor of input tensor.
Examples
>>> import ctf >>> a = ctf.astensor([[1,2,3],[4,5,6],[7,8,9]]) >>> ctf.triu(a, k=-1) array([[1, 2, 3], [4, 5, 6], [0, 8, 9]])
-
ctf.core.
vecnorm
()¶ Return vector (elementwise) norm of tensor A.
- Parameters
- A: tensor_like
Input tensor with 1, 2 or more dimensions.
- ord: {int 1, 2, inf}, optional
Type the norm, 2=Frobenius.
- Returns
- output: tensor
Norm of tensor A.
Examples
>>> import ctf >>> import ctf.linalg as la >>> a = ctf.astensor([3,4.]) >>> la.vecnorm(a) 5.0
-
ctf.core.
vstack
()¶ Stack the tensor in row-wise.
- Parameters
- in_tup: tuple of tensors
Input tensor.
- Returns
- output: tensor_like
Output vertically stacked tensor.
Examples
>>> import ctf >>> a = ctf.astensor([1,2,3]) >>> b = ctf.astensor([4,5,6]) >>> ctf.vstack((a, b)) array([[1, 2, 3], [4, 5, 6]])
-
ctf.core.
zeros
()¶ Return the tensor with specified shape and dtype with all elements filled as zeros.
- Parameters
- shape: int or tuple of int
Shape of the empty tensor.
- dtype: data-type, optional
Output data-type for the empty tensor.
- order: {‘C’, ‘F’}, optional, default: ‘F’
Currently not supported by CTF Python.
- sp: {True, False}, optional, default: ‘False’
Whether to represent tensor in a sparse format.
- Returns
- output: tensor_like
Output tensor.
Examples
>>> import ctf >>> import numpy as np >>> a = ctf.zeros([3,4], dtype=np.int64) >>> a array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])
-
ctf.core.
zeros_like
()¶ Return the tensor of zeros with same shape and dtype of tensor A.
- Parameters
- A: tensor_like
Input tensor where the output tensor shape and dtype defined as.
- dtype: data-type, optional
Output data-type for the empty tensor.
- order: {‘C’, ‘F’}, optional, default: ‘F’
Currently not supported by CTF Python.
- Returns
- output: tensor_like
Output tensor.
Examples
>>> import ctf >>> import numpy as np >>> a = ctf.zeros([3,4], dtype=np.int64) >>> b = ctf.zeros_like(a) >>> b array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])
ctf.random module¶
-
ctf.random.
all_seed
()¶ Seed the random tensor generator with the same seed in all processes.
- Parameters
- seed: int
Seed for random.
-
ctf.random.
random
()¶ Return random float (in half-open interval [0.0, 1.0)) tensor with specified parameters. Result tensor is from the continuous uniform distribution over the interval.
- Parameters
- shape: tensor_like
Input tensor with 1-D or 2-D dimensions. If A is 1-D tensor, return a 2-D tensor with A on diagonal.
- sp: bool, optional
When sp is specified True, the output tensor will be sparse.
- p: float, optional
When sp is True, p specifies the fraction of sparsity for the sparse tensor.
- dtype: data-type, optional
Not supportted in current CTF Python.
- Returns
- output: tensor
Random float tensor.
Examples
>>> import ctf >>> import ctf.random as random >>> random.random([2, 2]) array([[0.95027513, 0.79755613], [0.27834548, 0.55310684]])
-
ctf.random.
seed
()¶ Seed the random tensor generator.
- Parameters
- seed: int
Seed for random. Each process has the seed with seed + get_universe().rank.