{

public function testPadConstant1D(): void

{

$a = NDArray::array([1, 2, 3], DType::Int64);

$result = $a->pad(2);

$this->assertSame([7], $result->shape());

$this->assertSame([0, 0, 1, 2, 3, 0, 0], $result->toArray());

}

public function testPadConstant2DWithPerAxisWidth(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Int64);

$result = $a->pad([[1, 0], [0, 1]], PadMode::Constant, 9);

$this->assertSame([3, 3], $result->shape());

$this->assertSame([

[9, 9, 9],

[1, 2, 9],

[3, 4, 9],

], $result->toArray());

}

public function testPadSymmetric1D(): void

{

$a = NDArray::array([1, 2, 3], DType::Int64);

$result = $a->pad([2, 1], PadMode::Symmetric);

$this->assertSame([6], $result->shape());

$this->assertSame([2, 1, 1, 2, 3, 3], $result->toArray());

}

public function testPadReflect1D(): void

{

$a = NDArray::array([1, 2, 3], DType::Int64);

$result = $a->pad([2, 1], PadMode::Reflect);

$this->assertSame([6], $result->shape());

$this->assertSame([3, 2, 1, 2, 3, 2], $result->toArray());

}

public function testPadBool(): void

{

$a = NDArray::array([[true, false]], DType::Bool);

$result = $a->pad([[0, 1], [1, 0]], PadMode::Constant, false);

$this->assertSame([[false, true, false], [false, false, false]], $result->toArray());

}

public function testPadOnView(): void

{

$a = NDArray::array([

[1, 2, 3],

[4, 5, 6],

[7, 8, 9],

], DType::Int64);

$view = $a->slice(['::2', '1:']); // [[2,3], [8,9]]

$result = $view->pad(1, PadMode::Reflect);

$this->assertSame([4, 4], $result->shape());

$this->assertSame([

[9, 8, 9, 8],

[3, 2, 3, 2],

[9, 8, 9, 8],

[3, 2, 3, 2],

], $result->toArray());

}

public function testReshape1DTo2D(): void

{

$a = NDArray::array([1, 2, 3, 4, 5, 6], DType::Float64);

$result = $a->reshape([2, 3]);

$this->assertSame([2, 3], $result->shape());

$this->assertEqualsWithDelta([[1, 2, 3], [4, 5, 6]], $result->toArray(), 0.0001);

}

public function testReshape2DTo1D(): void

{

$a = NDArray::array([[1, 2, 3], [4, 5, 6]], DType::Float64);

$result = $a->reshape([6]);

$this->assertSame([6], $result->shape());

$this->assertEqualsWithDelta([1, 2, 3, 4, 5, 6], $result->toArray(), 0.0001);

}

public function testReshape3D(): void

{

$a = NDArray::array([1, 2, 3, 4, 5, 6, 7, 8], DType::Float64);

$result = $a->reshape([2, 2, 2]);

$this->assertSame([2, 2, 2], $result->shape());

}

public function testReshapeInfersNegativeDimensionForArray(): void

{

$a = NDArray::array([1, 2, 3, 4, 5, 6], DType::Float64);

$result = $a->reshape([2, -1]);

$this->assertSame([2, 3], $result->shape());

$this->assertEqualsWithDelta([[1, 2, 3], [4, 5, 6]], $result->toArray(), 0.0001);

}

public function testReshapeInfersNegativeDimensionForView(): void

{

$a = NDArray::arange(0, 12)->reshape([4, 3]);

$view = $a->slice(['1:3', ':']);

$result = $view->reshape([-1]);

$this->assertSame([6], $result->shape());

$this->assertEqualsWithDelta([3, 4, 5, 6, 7, 8], $result->toArray(), 0.0001);

$this->assertTrue($result->isView());

$result->setAt(0, 999);

$this->assertEqualsWithDelta(999, $a->getAt(3), 0.0001);

}

public function testReshapeRejectsMultipleNegativeDimensions(): void

{

$a = NDArray::array([1, 2, 3, 4], DType::Float64);

$this->expectException(ShapeException::class);

$this->expectExceptionMessage('one unknown dimension');

$a->reshape([-1, -1]);

}

public function testReshapeRejectsNonIntegerInferredDimension(): void

{

$a = NDArray::array([1, 2, 3, 4, 5], DType::Float64);

$this->expectException(ShapeException::class);

$this->expectExceptionMessage('inferred dimension would not be an integer');

$a->reshape([2, -1]);

}

public function testReshapeRejectsInvalidNegativeDimension(): void

{

$a = NDArray::array([1, 2, 3, 4], DType::Float64);

$this->expectException(ShapeException::class);

$this->expectExceptionMessage('dimensions must be non-negative or -1');

$a->reshape([2, -2]);

}

public function testReshapePreservesDtype(): void

{

$a = NDArray::array([1, 2, 3, 4], DType::Int32);

$result = $a->reshape([2, 2]);

$this->assertSame(DType::Int32, $result->dtype());

}

public function testTranspose2D(): void

{

$a = NDArray::array([[1, 2, 3], [4, 5, 6]], DType::Float64);

$result = $a->transpose();

$this->assertSame([3, 2], $result->shape());

$this->assertEqualsWithDelta([[1, 4], [2, 5], [3, 6]], $result->toArray(), 0.0001);

}

public function testTransposePreservesData(): void

{

$a = NDArray::array([[1, 2], [3, 4], [5, 6]], DType::Float64);

$result = $a->transpose();

$this->assertSame([2, 3], $result->shape());

$this->assertEqualsWithDelta([[1, 3, 5], [2, 4, 6]], $result->toArray(), 0.0001);

}

public function testTransposeThenClamp(): void

{

$a = NDArray::array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]);

$tr = $a->transpose();

$result = $tr->clamp(3.0, 7.0);

$this->assertSame([3, 3], $result->shape());

for ($i = 0; $i < 3; ++$i) {

for ($j = 0; $j < 3; ++$j) {

$expected = max(3.0, min(7.0, $tr->get($i, $j)));

$this->assertEqualsWithDelta($expected, $result->get($i, $j), 0.0001);

}

}

}

public function testSwapAxes2D(): void

{

$a = NDArray::array([[1, 2, 3], [4, 5, 6]], DType::Float64);

$result = $a->swapaxes(0, 1);

$this->assertSame([3, 2], $result->shape());

$this->assertEqualsWithDelta([[1, 4], [2, 5], [3, 6]], $result->toArray(), 0.0001);

}

public function testSwapAxesThenFlatten(): void

{

$a = NDArray::array([[1, 2, 3], [4, 5, 6]], DType::Float64);

$result = $a->swapaxes(0, 1)->flatten();

$this->assertSame([6], $result->shape());

$this->assertEqualsWithDelta([1, 4, 2, 5, 3, 6], $result->toArray(), 0.0001);

}

public function testSwapAxesReturnsView(): void

{

$a = NDArray::array([[1, 2, 3], [4, 5, 6]], DType::Float64);

$result = $a->swapaxes(0, 1);

// Verify it's a view

$this->assertTrue($result->isView());

// Verify modification affects original

$result->setAt(0, 999);

$this->assertEqualsWithDelta(999, $a->getAt(0), 0.0001);

}

public function testSwapAxes3D(): void

{

$a = NDArray::arange(24)->reshape([2, 3, 4]);

$result = $a->swapaxes(0, 2);

$this->assertSame([4, 3, 2], $result->shape());

}

public function testSwapAxesNegativeIndices(): void

{

$a = NDArray::array([[1, 2], [3, 4], [5, 6]], DType::Float64);

$result = $a->swapaxes(0, -1);

$this->assertSame([2, 3], $result->shape());

$this->assertEqualsWithDelta([[1, 3, 5], [2, 4, 6]], $result->toArray(), 0.0001);

}

public function testSwapAxesSameAxisNoOp(): void

{

$a = NDArray::array([1, 2, 3]);

$result = $a->swapaxes(0, 0);

// Should return the same object when swapping same axis

$this->assertSame($a, $result);

}

public function testSwapAxesThenClamp(): void

{

$a = NDArray::array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]);

$sw = $a->swapaxes(0, 1);

$result = $sw->clamp(3.0, 7.0);

$this->assertSame([3, 3], $result->shape());

for ($i = 0; $i < 3; ++$i) {

for ($j = 0; $j < 3; ++$j) {

$expected = max(3.0, min(7.0, $sw->get($i, $j)));

$this->assertEqualsWithDelta($expected, $result->get($i, $j), 0.0001);

}

}

}

public function testSliceThenTransposeThenClamp(): void

{

$a = NDArray::array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0]]);

$view = $a->slice(['0:3', '1:4']); // [[2,3,4],[6,7,8],[10,11,12]]

$tr = $view->transpose(); // shape [3,3]

$result = $tr->clamp(4.0, 10.0);

$this->assertSame([3, 3], $result->shape());

for ($i = 0; $i < 3; ++$i) {

for ($j = 0; $j < 3; ++$j) {

$expected = max(4.0, min(10.0, $tr->get($i, $j)));

$this->assertEqualsWithDelta($expected, $result->get($i, $j), 0.0001);

}

}

}

public function testFlatten2D(): void

{

$a = NDArray::array([[1, 2, 3], [4, 5, 6]], DType::Float64);

$result = $a->flatten();

$this->assertSame([6], $result->shape());

$this->assertEqualsWithDelta([1, 2, 3, 4, 5, 6], $result->toArray(), 0.0001);

}

public function testFlatten3D(): void

{

$a = NDArray::array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], DType::Float64);

$result = $a->flatten();

$this->assertSame([8], $result->shape());

$this->assertEqualsWithDelta([1, 2, 3, 4, 5, 6, 7, 8], $result->toArray(), 0.0001);

}

public function testSqueezeAllOnes(): void

{

$a = NDArray::array([[[[1]]]], DType::Float64);

$result = $a->squeeze();

// Should keep at least 1 dimension

$this->assertSame([1], $result->shape());

}

public function testSqueezeSpecificAxis(): void

{

$a = NDArray::zeros([3, 1, 4], DType::Float64);

$result = $a->squeeze([1]);

$this->assertSame([3, 4], $result->shape());

}

public function testSqueezeMultipleAxes(): void

{

$a = NDArray::zeros([1, 3, 1, 4, 1], DType::Float64);

$result = $a->squeeze([0, 2, 4]);

$this->assertSame([3, 4], $result->shape());

}

public function testExpandDimsAtBeginning(): void

{

$a = NDArray::array([1, 2, 3], DType::Float64);

$result = $a->expandDims(0);

$this->assertSame([1, 3], $result->shape());

}

public function testExpandDimsAtEnd(): void

{

$a = NDArray::array([1, 2, 3], DType::Float64);

$result = $a->expandDims(1);

$this->assertSame([3, 1], $result->shape());

}

public function testExpandDimsMiddle(): void

{

$a = NDArray::zeros([2, 3], DType::Float64);

$result = $a->expandDims(1);

$this->assertSame([2, 1, 3], $result->shape());

}

public function testExpandDimsNegativeAxis(): void

{

$a = NDArray::array([1, 2, 3], DType::Float64);

$result = $a->expandDims(-1);

$this->assertSame([3, 1], $result->shape());

}

public function testInsertAxisAtBeginning(): void

{

$a = NDArray::array([1, 2, 3], DType::Float64);

$result = $a->insertaxis(0);

$this->assertSame([1, 3], $result->shape());

$this->assertEqualsWithDelta([[1, 2, 3]], $result->toArray(), 0.0001);

}

public function testInsertAxisAtEnd(): void

{

$a = NDArray::array([1, 2, 3], DType::Float64);

$result = $a->insertaxis(1);

$this->assertSame([3, 1], $result->shape());

$this->assertEqualsWithDelta([[1], [2], [3]], $result->toArray(), 0.0001);

}

public function testInsertAxisInMiddle(): void

{

$a = NDArray::array([[1, 2, 3], [4, 5, 6]], DType::Float64);

$result = $a->insertaxis(1);

$this->assertSame([2, 1, 3], $result->shape());

}

public function testInsertAxisNegativeIndex(): void

{

$a = NDArray::array([1, 2, 3], DType::Float64);

$result = $a->insertaxis(-1);

$this->assertSame([3, 1], $result->shape());

}

public function testMergeAxes2DInto1D(): void

{

$a = NDArray::array([[1, 2], [3, 4], [5, 6]], DType::Float64);

$result = $a->mergeaxes(0, 1);

// Merging axis 0 into axis 1: [3, 2] -> [6]

$this->assertSame([6], $result->shape());

}

public function testMergeAxes3D(): void

{

$a = NDArray::zeros([2, 3, 4], DType::Float64);

$result = $a->mergeaxes(1, 2);

// Merging axis 1 into axis 2: [2, 3, 4] -> [2, 12]

$this->assertSame([2, 12], $result->shape());

}

public function testMergeReturnsView(): void

{

$a = NDArray::array([[1, 2], [3, 4], [5, 6]], DType::Float64);

$result = $a->mergeaxes(0, 1);

// Verify it returns a view

$this->assertTrue($result->isView());

// Verify modification affects original

$result->setAt(0, 999);

$this->assertEqualsWithDelta(999, $a->getAt(0), 0.0001);

}

public function testMergeWithNegativeIndices(): void

{

$a = NDArray::zeros([2, 3, 4], DType::Float64);

$result = $a->mergeaxes(-2, -1); // Same as mergeaxes (1, 2)

$this->assertSame([2, 12], $result->shape());

$this->assertTrue($result->isView());

}

public function testFlip1D(): void

{

$a = NDArray::array([1, 2, 3, 4, 5], DType::Float64);

$result = $a->flip(0);

$this->assertSame([5], $result->shape());

$this->assertEqualsWithDelta([5, 4, 3, 2, 1], $result->toArray(), 0.0001);

}

public function testFlip2D(): void

{

$a = NDArray::array([[1, 2, 3], [4, 5, 6]], DType::Float64);

$result = $a->flip(0);

$this->assertSame([2, 3], $result->shape());

$this->assertEqualsWithDelta([[4, 5, 6], [1, 2, 3]], $result->toArray(), 0.0001);

}

public function testFlipNegativeIndex(): void

{

$a = NDArray::array([1, 2, 3, 4, 5], DType::Float64);

$result = $a->flip(-1);

$this->assertSame([5], $result->shape());

$this->assertEqualsWithDelta([5, 4, 3, 2, 1], $result->toArray(), 0.0001);

}

public function testFlipAllAxes(): void

{

$a = NDArray::array([[1, 2, 3], [4, 5, 6]], DType::Float64);

$result = $a->flip();

$this->assertSame([2, 3], $result->shape());

$this->assertEqualsWithDelta([[6, 5, 4], [3, 2, 1]], $result->toArray(), 0.0001);

}

public function testFlipMultipleAxes(): void

{

$a = NDArray::array([[1, 2, 3], [4, 5, 6]], DType::Float64);

$result = $a->flip([0, 1]);

$this->assertSame([2, 3], $result->shape());

$this->assertEqualsWithDelta([[6, 5, 4], [3, 2, 1]], $result->toArray(), 0.0001);

}

public function testRavel2D(): void

{

$a = NDArray::array([[1, 2, 3], [4, 5, 6]], DType::Float64);

$result = $a->ravel();

$this->assertSame([6], $result->shape());

$this->assertEqualsWithDelta([1, 2, 3, 4, 5, 6], $result->toArray(), 0.0001);

}

public function testPermuteAxes2D(): void

{

$a = NDArray::array([[1, 2, 3], [4, 5, 6]], DType::Float64);

$result = $a->permute(1, 0);

$this->assertSame([3, 2], $result->shape());

$this->assertEqualsWithDelta([[1, 4], [2, 5], [3, 6]], $result->toArray(), 0.0001);

}

public function testPermuteAxes3D(): void

{

$a = NDArray::array([

[[1, 2], [3, 4], [5, 6]],

[[7, 8], [9, 10], [11, 12]],

], DType::Float64);

// Original shape: [2, 3, 2]

$result = $a->permute(1, 0, 2);

// New shape: [3, 2, 2]

$this->assertSame([3, 2, 2], $result->shape());

$this->assertEqualsWithDelta([

[[1, 2], [7, 8]],

[[3, 4], [9, 10]],

[[5, 6], [11, 12]],

], $result->toArray(), 0.0001);

}

public function testPermuteAxesWithNegativeIndices(): void

{

$a = NDArray::array([[1, 2, 3], [4, 5, 6]], DType::Float64);

$result = $a->permute(-1, -2);

$this->assertSame([3, 2], $result->shape());

$this->assertEqualsWithDelta([[1, 4], [2, 5], [3, 6]], $result->toArray(), 0.0001);

}

public function testPermuteAxesIdentity(): void

{

$a = NDArray::array([[1, 2, 3], [4, 5, 6]], DType::Float64);

$result = $a->permute(0, 1);

$this->assertSame([2, 3], $result->shape());

$this->assertEqualsWithDelta([[1, 2, 3], [4, 5, 6]], $result->toArray(), 0.0001);

}

public function testPermuteAxesThenFlatten(): void

{

$a = NDArray::array([[1, 2, 3], [4, 5, 6]], DType::Float64);

$result = $a->permute(1, 0)->flatten();

$this->assertSame([6], $result->shape());

$this->assertEqualsWithDelta([1, 4, 2, 5, 3, 6], $result->toArray(), 0.0001);

}

public function testPermuteAxesWithInvalidNumberOfAxes(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Float64);

$this->expectException(ShapeException::class);

$a->permute(0, 1, 2); // 3 axes for 2D array

}

public function testPermuteAxesWithDuplicateAxes(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Float64);

$this->expectException(ShapeException::class);

$a->permute(0, 0); // Duplicate axis

}

public function testPermuteAxesWithOutOfBoundsAxis(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Float64);

$this->expectException(ShapeException::class);

$a->permute(0, 5); // Axis 5 is out of bounds

}

// =========================================================================

// Tile Tests

// =========================================================================

public function testTile1DScalar(): void

{

$a = NDArray::array([1, 2, 3], DType::Int64);

$result = $a->tile(2);

$this->assertSame([6], $result->shape());

$this->assertSame([1, 2, 3, 1, 2, 3], $result->toArray());

}

public function testTile1DArray(): void

{

$a = NDArray::array([1, 2], DType::Int64);

$result = $a->tile([3]);

$this->assertSame([6], $result->shape());

$this->assertSame([1, 2, 1, 2, 1, 2], $result->toArray());

}

public function testTile2DRepeatRows(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Int64);

$result = $a->tile([2, 1]);

$this->assertSame([4, 2], $result->shape());

$this->assertSame([

[1, 2],

[3, 4],

[1, 2],

[3, 4],

], $result->toArray());

}

public function testTile2DRepeatCols(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Int64);

$result = $a->tile([1, 2]);

$this->assertSame([2, 4], $result->shape());

$this->assertSame([

[1, 2, 1, 2],

[3, 4, 3, 4],

], $result->toArray());

}

public function testTile2DRepeatBoth(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Int64);

$result = $a->tile([2, 3]);

$this->assertSame([4, 6], $result->shape());

$this->assertSame([

[1, 2, 1, 2, 1, 2],

[3, 4, 3, 4, 3, 4],

[1, 2, 1, 2, 1, 2],

[3, 4, 3, 4, 3, 4],

], $result->toArray());

}

public function testTile3D(): void

{

$a = NDArray::array([[[1, 2]], [[3, 4]]], DType::Int64); // Shape [2, 1, 2]

$result = $a->tile([1, 2, 1]);

$this->assertSame([2, 2, 2], $result->shape());

$this->assertSame([

[[1, 2], [1, 2]],

[[3, 4], [3, 4]],

], $result->toArray());

}

public function testTileWithHigherRepsThanDims(): void

{

// When reps has more dims than array, array gets padded with 1s at the beginning

$a = NDArray::array([1, 2], DType::Int64); // 1D

$result = $a->tile([2, 3]); // reps is 2D

$this->assertSame([2, 6], $result->shape());

}

public function testTilePreservesDtype(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Float32);

$result = $a->tile([2, 2]);

$this->assertSame(DType::Float32, $result->dtype());

}

public function testTileFloat64(): void

{

$a = NDArray::array([[1.5, 2.5], [3.5, 4.5]], DType::Float64);

$result = $a->tile([1, 2]);

$this->assertSame([2, 4], $result->shape());

$this->assertEqualsWithDelta([

[1.5, 2.5, 1.5, 2.5],

[3.5, 4.5, 3.5, 4.5],

], $result->toArray(), 0.0001);

}

public function testTileBool(): void

{

$a = NDArray::array([[true, false]], DType::Bool);

$result = $a->tile([2, 1]);

$this->assertSame([2, 2], $result->shape());

$this->assertSame([

[true, false],

[true, false],

], $result->toArray());

}

public function testTileEmptyReps(): void

{

$a = NDArray::array([1, 2, 3], DType::Int64);

$result = $a->tile([]);

// Empty reps should return array unchanged

$this->assertSame([3], $result->shape());

$this->assertSame([1, 2, 3], $result->toArray());

}

public function testTileWithNDArrayReps(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Int64);

$reps = NDArray::array([2, 1], DType::Int64);

$result = $a->tile($reps);

$this->assertSame([4, 2], $result->shape());

}

// =========================================================================

// Repeat Tests

// =========================================================================

public function testRepeat1DScalar(): void

{

$a = NDArray::array([1, 2, 3], DType::Int64);

$result = $a->repeat(2);

$this->assertSame([6], $result->shape());

$this->assertSame([1, 1, 2, 2, 3, 3], $result->toArray());

}

public function testRepeat1DWithArray(): void

{

$a = NDArray::array([1, 2, 3], DType::Int64);

$result = $a->repeat([1, 0, 2]);

$this->assertSame([3], $result->shape());

$this->assertSame([1, 3, 3], $result->toArray());

}

public function testRepeat2DFlattened(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Int64);

$result = $a->repeat(2);

$this->assertSame([8], $result->shape());

$this->assertSame([1, 1, 2, 2, 3, 3, 4, 4], $result->toArray());

}

public function testRepeat2DAxis0(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Int64);

$result = $a->repeat(2, axis: 0);

$this->assertSame([4, 2], $result->shape());

$this->assertSame([

[1, 2],

[1, 2],

[3, 4],

[3, 4],

], $result->toArray());

}

public function testRepeat2DAxis1(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Int64);

$result = $a->repeat(2, axis: 1);

$this->assertSame([2, 4], $result->shape());

$this->assertSame([

[1, 1, 2, 2],

[3, 3, 4, 4],

], $result->toArray());

}

public function testRepeat2DWithArrayAxis0(): void

{

$a = NDArray::array([[1, 2], [3, 4], [5, 6]], DType::Int64);

$result = $a->repeat([2, 1, 3], axis: 0);

$this->assertSame([6, 2], $result->shape());

$this->assertSame([

[1, 2],

[1, 2],

[3, 4],

[5, 6],

[5, 6],

[5, 6],

], $result->toArray());

}

public function testRepeat2DWithArrayAxis1(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Int64);

$result = $a->repeat([1, 2], axis: 1);

$this->assertSame([2, 3], $result->shape());

$this->assertSame([

[1, 2, 2],

[3, 4, 4],

], $result->toArray());

}

public function testRepeat3DAxis0(): void

{

$a = NDArray::array([[[1, 2]], [[3, 4]]], DType::Int64); // Shape [2, 1, 2]

$result = $a->repeat(2, axis: 0);

$this->assertSame([4, 1, 2], $result->shape());

}

public function testRepeat3DAxis1(): void

{

$a = NDArray::array([[[1, 2]], [[3, 4]]], DType::Int64); // Shape [2, 1, 2]

$result = $a->repeat(2, axis: 1);

$this->assertSame([2, 2, 2], $result->shape());

$this->assertSame([

[[1, 2], [1, 2]],

[[3, 4], [3, 4]],

], $result->toArray());

}

public function testRepeatPreservesDtype(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Float32);

$result = $a->repeat(2, axis: 0);

$this->assertSame(DType::Float32, $result->dtype());

}

public function testRepeatFloat64(): void

{

$a = NDArray::array([[1.5, 2.5], [3.5, 4.5]], DType::Float64);

$result = $a->repeat(2, axis: 1);

$this->assertSame([2, 4], $result->shape());

$this->assertEqualsWithDelta([

[1.5, 1.5, 2.5, 2.5],

[3.5, 3.5, 4.5, 4.5],

], $result->toArray(), 0.0001);

}

public function testRepeatBool(): void

{

$a = NDArray::array([[true, false]], DType::Bool);

$result = $a->repeat(2, axis: 0);

$this->assertSame([2, 2], $result->shape());

$this->assertSame([

[true, false],

[true, false],

], $result->toArray());

}

public function testRepeatWithNDArrayRepeats(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Int64);

$repeats = NDArray::array([2, 1], DType::Int64);

$result = $a->repeat($repeats, axis: 1);

$this->assertSame([2, 3], $result->shape());

$this->assertSame([

[1, 1, 2],

[3, 3, 4],

], $result->toArray());

}

public function testRepeatOnceReturnsSame(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Int64);

$result = $a->repeat(1, axis: 0);

$this->assertSame([2, 2], $result->shape());

$this->assertSame([

[1, 2],

[3, 4],

], $result->toArray());

}

// =========================================================================

// Static Convenience Methods Tests

// =========================================================================

public function testTileArrayWithPlainArray(): void

{

$result = NDArray::tileArray([1, 2, 3], 2);

$this->assertSame([6], $result->shape());

$this->assertSame([1, 2, 3, 1, 2, 3], $result->toArray());

}

public function testTileArrayWithNDArray(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Int64);

$result = NDArray::tileArray($a, [2, 1]);

$this->assertSame([4, 2], $result->shape());

$this->assertSame([

[1, 2],

[3, 4],

[1, 2],

[3, 4],

], $result->toArray());

}

public function testTileArrayReturnsNDArray(): void

{

$result = NDArray::tileArray([1, 2], 2);

$this->assertInstanceOf(NDArray::class, $result);

}

public function testRepeatArrayWithPlainArray(): void

{

$result = NDArray::repeatArray([1, 2, 3], 2);

$this->assertSame([6], $result->shape());

$this->assertSame([1, 1, 2, 2, 3, 3], $result->toArray());

}

public function testRepeatArrayWithNDArray(): void

{

$a = NDArray::array([[1, 2], [3, 4]], DType::Int64);

$result = NDArray::repeatArray($a, 2, axis: 0);

$this->assertSame([4, 2], $result->shape());

$this->assertSame([

[1, 2],

[1, 2],

[3, 4],

[3, 4],

], $result->toArray());

}

public function testRepeatArrayWithAxisParameter(): void

{

$result = NDArray::repeatArray([[1, 2], [3, 4]], 2, axis: 1);

$this->assertSame([2, 4], $result->shape());

$this->assertSame([

[1, 1, 2, 2],

[3, 3, 4, 4],

], $result->toArray());

}

public function testRepeatArrayReturnsNDArray(): void

{

$result = NDArray::repeatArray([1, 2], 2);

$this->assertInstanceOf(NDArray::class, $result);

}

// =========================================================================