numpy library

Extensions

ListVarpExtension on List<VARP>

Functions

abs(VARP x) → VARP
absolute(VARP x) → VARP
add(VARP x, VARP y) → VARP
all(VARP a, {List<int> axis = const [], bool keepDims = false}) → VARP
any(VARP a, {List<int> axis = const [], bool keepDims = false}) → VARP
arange<T extends SizedNativeType>({required num stop, num? start, num? step}) → VARP
arange(start, stop, step, dtype=None) Return evenly spaced values within a given interval.
arccos(VARP x) → VARP
arccosh(VARP x) → VARP
arcsin(VARP x) → VARP
arcsinh(VARP x) → VARP
arctan(VARP x) → VARP
arctan2(VARP x, VARP y) → VARP
arctanh(VARP x) → VARP
argmax(VARP x, {int? axis}) → VARP
argmin(VARP x, {int? axis}) → VARP
argsort(VARP x, {int axis = -1, bool descend = false}) → VARP
argwhere(VARP x) → VARP
around(VARP x) → VARP
array<T extends SizedNativeType>(dynamic a, {String order = "K", bool copy = true, int ndim = 0}) → VARP
array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0, like=None) Create an array.
arrayEqual(VARP a1, VARP a2, {bool equalNan = false}) → VARP
arrayEquiv(VARP a1, VARP a2) → VARP
asanyarray<T extends SizedNativeType>(dynamic a, {String order = "K"}) → VARP
asanyarray(a, dtype=None, order=None) Convert the input to an array.
asarray<T extends SizedNativeType>(dynamic a, {String order = "K"}) → VARP
asarray(a, dtype=None, order=None) Convert the input to an array.
ascontiguousarray<T extends SizedNativeType>(dynamic a, {String order = "K"}) → VARP
ascontiguousarray(a, dtype=None, order=None) Return a contiguous array (ndim >= 1) in memory (C order).
asmatrix<T extends SizedNativeType>(dynamic a, {String order = "K"}) → VARP
asmatrix(a, dtype=None) Interpret the input as a matrix.
bitwiseAnd(VARP x, VARP y) → VARP
bitwiseOr(VARP x, VARP y) → VARP
bitwiseXor(VARP x, VARP y) → VARP
broadcast(VARP x, VARP y) → VARP
broadcastTo(VARP x, List<int> shape) → VARP
cbrt(VARP x) → VARP
ceil(VARP x) → VARP
clip(VARP x, double aMin, double aMax) → VARP
concatenate(List<VARP> vars, {int axis = 0}) → VARP
copy<T extends SizedNativeType>(VARP a, {String order = "K"}) → VARP
copy(a, order='K', subok=False) Return an array copy of the given object.
copysign(VARP x, VARP y) → VARP
cos(VARP x) → VARP
cosh(VARP x) → VARP
countNonZero(VARP x, {List<int> axis = const [], bool keepDims = false}) → VARP
cumprod(VARP x, int axis) → VARP
cumsum(VARP x, int axis) → VARP
diag(VARP v, {int k = 0}) → VARP
diagflat(VARP v, {int k = 0}) → VARP
divide(VARP x, VARP y) → VARP
divmod(VARP x, VARP y) → (VARP, VARP)
dot<T extends SizedNativeType>(VARP a, VARP b) → VARP
empty<T extends SizedNativeType>(List<int> shape, {String order = "C"}) → VARP
empty(shape, dtype=float32) Return a new var of given shape and type, without initializing entries.
emptyLike<T extends SizedNativeType>(VARP prototype, {String order = "K", bool subOk = true, List<int>? shape}) → VARP
empty_like(prototype, dtype=None, order='K', subok=True, shape=None) Return a new var with the same shape and type as a given var.
equal(VARP a, VARP b) → VARP
exp(VARP x) → VARP
exp2(VARP x) → VARP
expandDims(VARP x, List<int> axis) → VARP
expm1(VARP x) → VARP
eye<T extends SizedNativeType>(int N, {int? M, int k = 0, String order = "C"}) → VARP
eye(N, M=None, k=0, dtype=float32, order='C') Return a 2-D var with ones on the diagonal and zeros elsewhere.
fabs(VARP x) → VARP
fix(VARP x) → VARP
flatnonzero(VARP x) → VARP
floor(VARP x) → VARP
floorDiv(VARP x, VARP y) → VARP
full<T extends SizedNativeType>(List<int> shape, dynamic fillValue, {String order = "C"}) → VARP
full(shape, fill_value, dtype=None, order='C') Return a new var of given shape and type, filled with fill_value.
fullLike<T extends SizedNativeType>(VARP a, num fillValue, {String order = "K", List<int>? shape}) → VARP
full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None) Return a full var with the same shape and type as a given var.
geomspace<T extends SizedNativeType>(num start, num stop, {int count = 50}) → VARP
greater(VARP a, VARP b) → VARP
greaterEqual(VARP a, VARP b) → VARP
histogram(VARP x, {int bins = 10, (int, int)? range}) → (VARP, VARP)
hypot(VARP x, VARP y) → VARP
identity<T extends SizedNativeType>(int n) → VARP
identity(n, dtype=float32) Return the identity var. The identity var is a square array with ones on the main diagonal.
inner(VARP a, VARP b) → VARP
ldexp(VARP x, VARP y) → VARP
less(VARP a, VARP b) → VARP
lessEqual(VARP a, VARP b) → VARP
linspace<T extends SizedNativeType>(num start, num stop, {int count = 50}) → VARP
log(VARP x) → VARP
log10(VARP x) → VARP
log1p(VARP x) → VARP
log2(VARP x) → VARP
logaddexp(VARP x, VARP y) → VARP
logaddexp2(VARP x, VARP y) → VARP
logspace<T extends SizedNativeType>(num start, num stop, {int count = 50, double base = 10.0}) → VARP
mat<T extends SizedNativeType>(dynamic data) → VARP
matmul(VARP a, VARP b) → VARP
matrix<T extends SizedNativeType>(dynamic data) → VARP
max(VARP x, {List<int> axis = const [], bool keepDims = false}) → VARP
maximum(VARP x, VARP y) → VARP
mean(VARP x, {List<int> axis = const [], bool keepDims = false}) → VARP
median(VARP x, {int axis = -1, bool keepDims = false}) → VARP
meshgrid<T extends SizedNativeType>(VARP x, VARP y) → VARP
min(VARP x, {List<int> axis = const [], bool keepDims = false}) → VARP
minimum(VARP x, VARP y) → VARP
mod(VARP x, VARP y) → VARP
moveaxis(VARP a, List<int> source, List<int> destination) → VARP
msort(VARP x) → VARP
multiply(VARP x, VARP y) → VARP
negative(VARP x) → VARP
nonzero(VARP x) → (VARP, VARP?)
norm(VARP x, {dynamic ord, dynamic axis, bool keepDims = false}) → VARP
notEqual(VARP a, VARP b) → VARP
ones<T extends SizedNativeType>(List<int> shape, {String order = "C"}) → VARP
ones(shape, dtype=None, order='C') Return a new array of given shape and type, filled with ones.
onesLike<T extends SizedNativeType>(VARP a, {String order = "K", List<int>? shape}) → VARP
ones_like(a, dtype=None, order='K', subok=True, shape=None) Return an array of ones with the same shape and type as a given array.
outer(VARP a, VARP b) → VARP
pad(VARP x, List<int> padWidth, {PadValueMode mode = F.PadValueMode.CONSTANT}) → VARP
positive(VARP x) → VARP
power(VARP x, VARP y) → VARP
prod(VARP x, {List<int> axis = const [], bool keepDims = false}) → VARP
ptp(VARP x, {List<int> axis = const []}) → VARP
randint(int low, {int? high, List<int> size = const [], int seed0 = 0, int seed1 = 0}) → VARP
random(List<int> shape, {double low = 0.0, double high = 1.0, int seed0 = 0, int seed1 = 0}) → VARP
ravel(VARP a) → VARP
reciprocal(VARP x) → VARP
repeat(VARP x, int reps) → VARP
reshape(VARP a, List<int> newShape, {DimensionFormat format = DimensionFormat.NCHW}) → VARP
rint(VARP x) → VARP
rollaxis(VARP a, int axis, {int start = 0}) → VARP
round(VARP x) → VARP
scalar<T extends SizedNativeType>(num value, {HalideType? dtype}) → VARP
shape(VARP a) → List<int>
sign(VARP x) → VARP
signbit(VARP x) → VARP
sin(VARP x) → VARP
sinc(VARP x) → VARP
sinh(VARP x) → VARP
solve(VARP a, VARP b) → VARP
sort(VARP x, {int axis = -1, bool descend = false}) → VARP
split(VARP arr, List<int> indicesOrSections, {int axis = 0}) → List<VARP>
sqrt(VARP x) → VARP
square(VARP x) → VARP
squeeze(VARP x, {List<int> axis = const []}) → VARP
std(VARP x, {List<int> axis = const [], bool keepDims = false}) → VARP
subtract(VARP x, VARP y) → VARP
sum(VARP x, {List<int> axis = const [], bool keepDims = false}) → VARP
svd(VARP a, {bool fullMatrices = true, bool computeUV = true, bool hermitian = false}) → (VARP, VARP, VARP)
swapaxes(VARP a, int axis1, int axis2) → VARP
tan(VARP x) → VARP
tanh(VARP x) → VARP
tile(VARP x, List<int> reps) → VARP
transpose(VARP a, {List<int>? axes}) → VARP
tri(VARP N, {int? M, int k = 0}) → VARP
tril(VARP v, {int k = 0}) → VARP
triu(VARP v, {int k = 0}) → VARP
trueDiv(VARP x, VARP y) → VARP
trunc(VARP x) → VARP
vander(VARP x, {int? n}) → VARP
variance(VARP x, {List<int> axis = const [], bool keepDims = false}) → VARP
vdot(VARP a, VARP b) → VARP
where(VARP condition, {VARP? x, VARP? y}) → VARP
zeros<T extends SizedNativeType>(List<int> shape, {String order = "C"}) → VARP
zeros(shape, dtype=None, order='C') Return a new array of given shape and type, filled with zeros.
zerosLike<T extends SizedNativeType>(VARP a, {String order = "K", List<int>? shape}) → VARP
zeros_like(a, dtype=None, order='K', subok=True, shape=None) Return an array of zeros with the same shape and type as a given array.