Tessero\NDArray

__construct(Tessero\Native\Buffer $buffer, Tessero\DType $dtype, array $shape, ?array $strides = null, int $offset = 0)

empty(array|int $shape, Tessero\DType|string $dtype = …): self

zeros(array|int $shape, Tessero\DType|string $dtype = …): self

ones(array|int $shape, Tessero\DType|string $dtype = …): self

full(array|int $shape, int|float|bool $value, Tessero\DType|string|null $dtype = null): self

arange(int|float $start, int|float|null $stop = null, int|float $step = 1, Tessero\DType|string|null $dtype = null): self

linspace(float $start, float $stop, int $num = 50, bool $endpoint = true): self

eye(int $n, ?int $m = null, int $k = 0, Tessero\DType|string $dtype = …): self

array(mixed $data, Tessero\DType|string|null $dtype = null): self

Build an array from PHP data: a scalar, a (nested) list, or another NDArray (copied). Passing $dtype skips type inference, which is the faster path for big inputs.

fromFlat(array $flat, array $shape, Tessero\DType|string $dtype = …): self

complex(mixed $real, mixed $imag = null): self

Complex array from real and imaginary parts (arrays or nested lists of equal shape).

fromBytes(string $bytes, Tessero\DType|string $dtype, ?array $shape = null): self

Wrap raw little-endian bytes (copied).

asArray(mixed $value, Tessero\DType|string|null $dtype = null): self

memmap(string $filename, string $mode = 'r+', ?array $shape = null, Tessero\DType|string $dtype = …, int $offset = 0): self

An array backed by a memory-mapped file (numpy.memmap): nothing is read up front; the OS pages data in on access. Modes: 'r' read-only, 'r+' read/write (extends a short file), 'w+' create or truncate, 'c' copy-on-write. Without $shape the file (after $offset) is one 1-D array. Views share the mapping; results of computations are ordinary arrays. Same arguments and errors as ext-tessero.

openMemmap(string $path, string $mode = 'r+', ?array $shape = null, Tessero\DType|string $dtype = …, bool $fortranOrder = false): self

A memory-mapped .npy file (numpy.lib.format.open_memmap): 'w+' creates it with a header for $shape and $dtype; 'r', 'r+' and 'c' read shape and dtype from the file.

load(string $path, ?string $mmapMode = null): self

Read a .npy file (numpy.load); with $mmapMode ('r', 'r+', 'c') the data is memory-mapped instead of read.

save(string $path): void

Write this array to a .npy file (numpy.save), C order.

flush(bool $sync = false): self

Write a memory map's dirty pages back to its file: scheduled (default) or synchronous with $sync. No-op for other arrays.

isMemmap(): bool

True for memory-mapped arrays and views of them.

isReadonly(): bool

True for arrays over read-only memory (memmap mode 'r').

filename(): ?string

The mapped file's resolved path, or null.

shape(): array

strides(): array

dtype(): Tessero\DType

ndim(): int

size(): int

nbytes(): int

buffer(): Tessero\Native\Buffer

The native block this array (or view) reads; shared by all views of it. Advanced use only.

ptr(): FFI\CData

char* to the first element, for passing to C in the same statement.

isContiguous(): bool

isFortranContiguous(): bool

count(): int

toArray(): mixed

Nested PHP array (scalar for 0-d). Complex elements become [re, im] pairs.

toList(): array

Flat C-order list of values (complex: interleaved re, im).

toBytes(): string

Raw little-endian bytes in C order.

item(int ...$index): array|int|float|bool

One element as a PHP scalar ([re, im] for complex).

toJson(): string

JSON text written directly by libtessero from the strided memory (no PHP arrays in between): about 10x faster than json_encode($a->toArray()) on large arrays. Floats use the shortest round-trip form; NaN/Inf become null.

meta(): FFI\CData

C-side metadata (tsr_array) describing this view, for kernels that take whole arrays. Like ptr(), the embedded data pointer is valid only while this array is alive.

sliceNative(string $spec): self

Basic indexing with the spec parsed by libtessero (same grammar as offsetGet): one call into C, no PHP string handling. Returns a view.

jsonSerialize(): mixed

copy(): self

contiguous(): self

This array if already C-contiguous, else a contiguous copy.

astype(Tessero\DType|string $dtype, bool $copy = false): self

view(Tessero\DType|string $dtype): self

Reinterpret the same bytes as another dtype of equal itemsize (bool <-> uint8).

isWritable(): bool

False for arrays over read-only memory (a memory map opened with mode 'r').

assign(mixed $src): self

Copy (and cast) the values of $src, broadcast to this array's shape, into this array (which may be a view).

reshape(array|int ...$shape): self

ravel(): self

flatten(): self

transpose(?array $axes = null): self

t(): self

Matrix transpose (reverses all axes).

swapAxes(int $a, int $b): self

moveAxis(int $source, int $destination): self

expandDims(int $axis): self

squeeze(?int $axis = null): self

broadcastTo(array $shape): self

slice(string|int|null ...$specs): self

Basic indexing, one spec per axis: int select (drops the axis; negative counts from the end) 'a:b:c' slice, any part optional ('::-1' reverses, ':' keeps) '...' fill the remaining axes with ':' null insert a new axis of length 1 (numpy.newaxis) Always returns a view.

get(int ...$index): mixed

Element or sub-array at integer indices (scalar when all axes are indexed).

take(mixed $indices, ?int $axis = null): self

Gather along an axis (numpy.take). Indices may be negative. With $axis null the array is flattened first.

put(mixed $indices, mixed $values, ?int $axis = null): self

Scatter values along an axis in place (numpy.put_along_axis for whole slices).

filter(self $mask): self

Elements where $mask is true, as a 1-D array (a[mask]).

setWhere(self $mask, mixed $values): self

a[mask] = values (a scalar, or one value per true element).

flatNonzero(): self

Flat indices of non-zero elements (numpy.flatnonzero).

getIterator(): Traversable

add(mixed $b, ?self $out = null): self

sub(mixed $b, ?self $out = null): self

mul(mixed $b, ?self $out = null): self

div(mixed $b, ?self $out = null): self

pow(mixed $b, ?self $out = null): self

mod(mixed $b, ?self $out = null): self

floorDiv(mixed $b, ?self $out = null): self

maximum(mixed $b, ?self $out = null): self

minimum(mixed $b, ?self $out = null): self

atan2(mixed $b, ?self $out = null): self

hypot(mixed $b, ?self $out = null): self

eq(mixed $b): self

ne(mixed $b): self

lt(mixed $b): self

le(mixed $b): self

gt(mixed $b): self

ge(mixed $b): self

logicalAnd(mixed $b): self

logicalOr(mixed $b): self

logicalXor(mixed $b): self

rsub(mixed $a): self

Reflected forms for scalar - array expressions.

rdiv(mixed $a): self

rpow(mixed $a): self

neg(?self $out = null): self

abs(?self $out = null): self

square(?self $out = null): self

sign(?self $out = null): self

sqrt(?self $out = null): self

exp(?self $out = null): self

log(?self $out = null): self

log10(?self $out = null): self

log2(?self $out = null): self

expm1(?self $out = null): self

log1p(?self $out = null): self

sin(?self $out = null): self

cos(?self $out = null): self

tan(?self $out = null): self

arcsin(?self $out = null): self

arccos(?self $out = null): self

arctan(?self $out = null): self

sinh(?self $out = null): self

cosh(?self $out = null): self

tanh(?self $out = null): self

floor(?self $out = null): self

ceil(?self $out = null): self

rint(?self $out = null): self

reciprocal(?self $out = null): self

isnan(): self

isfinite(): self

isinf(): self

invert(): self

Bitwise NOT for integers, logical NOT for bool (numpy.invert).

logicalNot(): self

real(): self

imag(): self

conj(): self

angle(): self

round(int $decimals = 0): self

clip(int|float|null $min = null, int|float|null $max = null): self

sum(array|int|null $axis = null, bool $keepdims = false): mixed

prod(array|int|null $axis = null, bool $keepdims = false): mixed

min(array|int|null $axis = null, bool $keepdims = false): mixed

max(array|int|null $axis = null, bool $keepdims = false): mixed

any(array|int|null $axis = null, bool $keepdims = false): mixed

all(array|int|null $axis = null, bool $keepdims = false): mixed

argmin(?int $axis = null, bool $keepdims = false): mixed

argmax(?int $axis = null, bool $keepdims = false): mixed

mean(array|int|null $axis = null, bool $keepdims = false): mixed

var(array|int|null $axis = null, int $ddof = 0, bool $keepdims = false): mixed

std(array|int|null $axis = null, int $ddof = 0, bool $keepdims = false): mixed

cumsum(?int $axis = null): self

cumprod(?int $axis = null): self

diff(int $n = 1, int $axis = -1): self

n-th discrete difference along an axis (numpy.diff).

sort(int $axis = -1): self

nonzero(): mixed

Indices of the non-zero elements (numpy.ndarray.nonzero).

mT(): mixed

Matrix transpose: swap the last two axes (numpy.ndarray.mT).

trace(int $offset = 0, int $axis1 = 0, int $axis2 = 1): mixed

Sum along a diagonal (numpy.ndarray.trace).

diagonal(int $offset = 0, int $axis1 = 0, int $axis2 = 1): mixed

A diagonal of the matrix (numpy.ndarray.diagonal).

repeat(mixed $repeats, ?int $axis = null): mixed

Repeat elements (numpy.ndarray.repeat).

compress(mixed $condition, ?int $axis = null): mixed

Select elements where a boolean condition is true (numpy.ndarray.compress).

choose(mixed $choices, mixed $mode = 'raise'): mixed

Choose from a set of arrays by index (numpy.ndarray.choose).

fill(mixed $value): self

Fill the array with a scalar value (numpy.ndarray.fill); returns a new same-shape array.

byteswap(bool $inplace = false): self

A copy with each element's bytes reversed (numpy.ndarray.byteswap).

resize(array|int $shape): self

Return a copy resized to the given shape (numpy.ndarray.resize): flattened, zero-padded or truncated.

searchsorted(mixed $v, string $side = 'left'): mixed

Indices where elements of v keep this sorted if inserted (numpy.ndarray.searchsorted).

partition(mixed $kth, int $axis = -1): mixed

A partial sort: a copy with the kth element in final sorted position (numpy.ndarray.partition).

argpartition(mixed $kth, int $axis = -1): mixed

Indices that would partition the array about the kth element (numpy.ndarray.argpartition).

argsort(int $axis = -1): self

matmul(self|array $other): mixed

Matrix product with NumPy's matmul rules: 1-D operands are promoted to row/column vectors, >2-D operands are stacks of matrices with broadcast batch dimensions. float64/float32 use BLAS when one is available.

dot(self|array $other): mixed

numpy.dot for 1-D/2-D operands (alias of matmul there).

where(mixed $cond, mixed $a, mixed $b): self

Element-wise selection: cond ? a : b, with broadcasting.

concatenate(array $arrays, int $axis = 0): self

stack(array $arrays, int $axis = 0): self

allclose(mixed $a, mixed $b, float $rtol = 1.0E-5, float $atol = 1.0E-8, bool $equalNan = false): bool

isclose(mixed $a, mixed $b, float $rtol = 1.0E-5, float $atol = 1.0E-8, bool $equalNan = false): self

broadcastShapes(array ...$shapes): array

cStrides(array $shape, int $itemsize): array

normAxis(int $axis, int $ndim): int