Array Creation Functions

Functions for creating arrays.

Example

import numpycore as np

# From data
arr = np.array([1, 2, 3])
mat = np.array([[1, 2], [3, 4]])

# Zeros and ones
zeros = np.zeros((3, 3))
ones = np.ones((2, 4))
full = np.full((2, 3), 7)

# Ranges
arange = np.arange(0, 10, 2)
linspace = np.linspace(0, 1, 100)

From Data

Function	Description	Example
array(object, dtype)	Create array from list/tuple/array
asarray(a)	Convert input to array	View
asanyarray(a)	Convert to array (pass through subclasses)	View
ascontiguousarray(a)	Return contiguous array	View
copy(a)	Return array copy

Zeros and Ones

Function	Description	Example
zeros(shape, dtype)	Array of zeros	View
ones(shape, dtype)	Array of ones	View
empty(shape, dtype)	Uninitialized array	View
full(shape, fill_value)	Array filled with value	View
zeros_like(a)	Zeros with same shape as a	View
ones_like(a)	Ones with same shape as a	View
empty_like(a)	Empty with same shape as a	View
full_like(a, fill_value)	Filled with same shape as a	View

Numerical Ranges

Function	Description	Example
arange(start, stop, step)	Evenly spaced values within interval	View
linspace(start, stop, num)	Evenly spaced numbers over interval	View
logspace(start, stop, num)	Numbers spaced evenly on log scale
geomspace(start, stop, num)	Numbers spaced evenly on geometric scale

Matrix Creation

Function	Description	Example
eye(N, M, k)	2-D array with ones on diagonal	View
identity(n)	Identity matrix	View
diag(v, k)	Diagonal array or extract diagonal
diagflat(v, k)	Create 2-D array with diagonal
tri(N, M, k)	Array with ones at and below diagonal
tril(m, k)	Lower triangle of array
triu(m, k)	Upper triangle of array
vander(x, N)	Vandermonde matrix

Grid Creation

Function	Description	Example
meshgrid(*xi)	Coordinate matrices from vectors	View
mgrid	Dense multi-dimensional meshgrid
ogrid	Open multi-dimensional meshgrid
indices(dimensions)	Grid of indices	View

Code Examples

The following examples are extracted from the test suite.

asarray (test_array_conversion.py:35)

    print("Warning: NumPy not available. Skipping comparison tests.")

def test_asarray():
    """Test asarray function with various input types"""
    print("="*70)
    print("Testing asarray()")
    print("="*70)

    # Test 1: Python list
    print("\n[Test 1] asarray from Python list")
    result = numpycore.asarray([1, 2, 3, 4, 5])
    print(f"  numpycore.asarray([1, 2, 3, 4, 5]): {result}")
    print(f"  Shape: {result.shape}, dtype: {result.dtype}")
    assert result.shape == (5,), f"Expected shape (5,), got {result.shape}"
    if HAS_NUMPY:
        np_result = np.asarray([1, 2, 3, 4, 5])
        assert np.allclose(result, np_result), "Results don't match NumPy"
    print("  [OK] Python list")

    # Test 2: 2D Python list
    print("\n[Test 2] asarray from 2D Python list")

asanyarray (test_array_conversion.py:98)

    print("="*70)

def test_asanyarray():
    """Test asanyarray function"""
    print("\n" + "="*70)
    print("Testing asanyarray()")
    print("="*70)

    # Test 1: Basic array
    print("\n[Test 1] asanyarray from list")
    result = numpycore.asanyarray([1, 2, 3, 4])
    print(f"  numpycore.asanyarray([1, 2, 3, 4]): {result}")
    assert result.shape == (4,), f"Expected shape (4,), got {result.shape}"
    print("  [OK] asanyarray from list")

    # Test 2: 2D array
    print("\n[Test 2] asanyarray from 2D list")
    result = numpycore.asanyarray([[1, 2], [3, 4], [5, 6]])
    print(f"  numpycore.asanyarray([[1, 2], [3, 4], [5, 6]]): shape={result.shape}")
    assert result.shape == (3, 2), f"Expected shape (3, 2), got {result.shape}"
    print("  [OK] asanyarray from 2D list")

ascontiguousarray (test_array_conversion.py:122)

    print("="*70)

def test_ascontiguousarray():
    """Test ascontiguousarray function"""
    print("\n" + "="*70)
    print("Testing ascontiguousarray()")
    print("="*70)

    # Test 1: Basic array
    print("\n[Test 1] ascontiguousarray from list")
    result = numpycore.ascontiguousarray([[1, 2, 3], [4, 5, 6]])
    print(f"  numpycore.ascontiguousarray([[1, 2, 3], [4, 5, 6]]): shape={result.shape}")
    print(f"  Result is C-contiguous: {result.flags['C_CONTIGUOUS']}")
    assert result.flags['C_CONTIGUOUS'], "Result should be C-contiguous"
    print("  [OK] C-contiguous array")

    # Test 2: With dtype
    print("\n[Test 2] ascontiguousarray with dtype")
    result = numpycore.ascontiguousarray([1, 2, 3, 4], dtype='float64')
    print(f"  numpycore.ascontiguousarray([1, 2, 3, 4], dtype='float64'): {result}")
    assert result.dtype == np.float64, f"Expected float64, got {result.dtype}"

zeros (test_advanced_linalg_and_numerical.py:63)

# ============================================================================
# Linear Algebra Tests
# ============================================================================

def test_solve():
    """Test np.linalg.solve() for solving linear systems Ax = b"""
    # Create a simple 2x2 system: [[2, 1], [1, 3]] @ x = [1, 2]
    np_A = test_bind.np.array([[2.0, 1.0], [1.0, 3.0]])
    np_b = test_bind.np.array([1.0, 2.0])

    nc_A = test_bind.numpycore.zeros([2, 2])
    nc_A.itemset(0, 2.0)
    nc_A.itemset(1, 1.0)
    nc_A.itemset(2, 1.0)
    nc_A.itemset(3, 3.0)

    nc_b = test_bind.numpycore.zeros([2])
    nc_b.itemset(0, 1.0)
    nc_b.itemset(1, 2.0)

    np_result = test_bind.np.linalg.solve(np_A, np_b)

ones (test_2d_3d_operations.py:15)

def assert_arrays_equal(np_result, nc_result, test_name):
    if not test_bind.np.allclose(test_bind.np.asarray(np_result), test_bind.np.asarray(nc_result), rtol=1e-10, atol=1e-10, equal_nan=True):
        print(f"[FAIL] {test_name}"); sys.exit(1)
    print(f"[OK] {test_name}: PASSED")

def test_rot90_k2(): assert_arrays_equal(test_bind.np.rot90(test_bind.np.array([[1,2],[3,4]]),k=2), test_bind.np.rot90(test_bind.numpycore.arange(1.,5.,1.).reshape([2,2]),k=2), "rot90_k2")
def test_fliplr(): assert_arrays_equal(test_bind.np.fliplr(test_bind.np.array([[1,2],[3,4]])), test_bind.np.fliplr(test_bind.numpycore.arange(1.,5.,1.).reshape([2,2])), "fliplr")
def test_flipud(): assert_arrays_equal(test_bind.np.flipud(test_bind.np.array([[1,2],[3,4]])), test_bind.np.flipud(test_bind.numpycore.arange(1.,5.,1.).reshape([2,2])), "flipud")
def test_roll_2d(): assert_arrays_equal(test_bind.np.roll(test_bind.np.array([[1,2],[3,4]]),1,axis=0), test_bind.np.roll(test_bind.numpycore.arange(1.,5.,1.).reshape([2,2]),1,axis=0), "roll_2d")
def test_rollaxis(): assert_arrays_equal(test_bind.np.rollaxis(test_bind.np.ones((3,4,5)),2), test_bind.np.rollaxis(test_bind.numpycore.ones([3,4,5]),2), "rollaxis")
def test_transpose_axes(): assert_arrays_equal(test_bind.np.transpose(test_bind.np.ones((2,3,4)),(2,0,1)), test_bind.np.transpose(test_bind.numpycore.ones([2,3,4]),(2,0,1)), "transpose_axes")

def f_main():
    if test_bind.f_setup_test_environment() != 0: return 1
    print("="*70); print("Additional 2D/3D Operations Tests"); print("="*70); print()
    test_rot90_k2(); test_fliplr(); test_flipud(); test_roll_2d(); test_rollaxis(); test_transpose_axes()
    print(); print("[OK] All 6 2D/3D operations tests passed!")
    return 0

if __name__ == "__main__": sys.exit(f_main())

empty (test_array_creation_complete.py:67)

    assert np.allclose(arr, np.zeros((2, 3))), "zeros() 2D values incorrect"

    f_print_success("zeros() tests passed")


def test_empty():
    """Test empty() - create uninitialized array"""
    f_print_info("Testing empty()")

    # Test shape creation
    arr = test_bind.numpycore.empty([2, 3])
    assert arr.shape == (2, 3), f"Expected shape (2, 3), got {arr.shape}"
    assert arr.dtype == np.float64, f"Expected dtype float64, got {arr.dtype}"

    f_print_success("empty() tests passed")


def test_full():
    """Test full() - create array filled with specific value"""
    f_print_info("Testing full()")

full (test_array_creation_complete.py:79)

    assert arr.dtype == np.float64, f"Expected dtype float64, got {arr.dtype}"

    f_print_success("empty() tests passed")


def test_full():
    """Test full() - create array filled with specific value"""
    f_print_info("Testing full()")

    # Test with scalar value
    arr = test_bind.numpycore.full([2, 3], 7.5)
    assert arr.shape == (2, 3), f"Expected shape (2, 3), got {arr.shape}"
    assert np.allclose(arr, np.full((2, 3), 7.5)), "full() values incorrect"

    f_print_success("full() tests passed")


def test_identity():
    """Test identity() - create identity matrix"""
    f_print_info("Testing identity()")

zeros_like (test_array_creation_complete.py:163)

    assert np.allclose(arr, np.ones_like(prototype)), "ones_like() values incorrect"

    f_print_success("ones_like() tests passed")


def test_zeros_like():
    """Test zeros_like() - create array of zeros with shape from prototype"""
    f_print_info("Testing zeros_like()")

    prototype = np.array([[1, 2], [3, 4]])
    arr = test_bind.numpycore.zeros_like(prototype)
    assert arr.shape == prototype.shape, f"Expected shape {prototype.shape}, got {arr.shape}"
    assert np.allclose(arr, np.zeros_like(prototype)), "zeros_like() values incorrect"

    f_print_success("zeros_like() tests passed")


def test_empty_like():
    """Test empty_like() - create uninitialized array with shape from prototype"""
    f_print_info("Testing empty_like()")

ones_like (test_array_creation_complete.py:151)

# ============================================================================
# LIKE FUNCTIONS TESTS
# ============================================================================

def test_ones_like():
    """Test ones_like() - create array of ones with shape from prototype"""
    f_print_info("Testing ones_like()")

    prototype = np.array([[1, 2], [3, 4]])
    arr = test_bind.numpycore.ones_like(prototype)
    assert arr.shape == prototype.shape, f"Expected shape {prototype.shape}, got {arr.shape}"
    assert np.allclose(arr, np.ones_like(prototype)), "ones_like() values incorrect"

    f_print_success("ones_like() tests passed")


def test_zeros_like():
    """Test zeros_like() - create array of zeros with shape from prototype"""
    f_print_info("Testing zeros_like()")

empty_like (test_array_creation_complete.py:175)

    assert np.allclose(arr, np.zeros_like(prototype)), "zeros_like() values incorrect"

    f_print_success("zeros_like() tests passed")


def test_empty_like():
    """Test empty_like() - create uninitialized array with shape from prototype"""
    f_print_info("Testing empty_like()")

    prototype = np.array([[1, 2], [3, 4]])
    arr = test_bind.numpycore.empty_like(prototype)
    assert arr.shape == prototype.shape, f"Expected shape {prototype.shape}, got {arr.shape}"
    assert arr.dtype == prototype.dtype, f"Expected dtype {prototype.dtype}, got {arr.dtype}"

    f_print_success("empty_like() tests passed")


def test_full_like():
    """Test full_like() - create filled array with shape from prototype"""
    f_print_info("Testing full_like()")

full_like (test_array_creation_complete.py:187)

    assert arr.dtype == prototype.dtype, f"Expected dtype {prototype.dtype}, got {arr.dtype}"

    f_print_success("empty_like() tests passed")


def test_full_like():
    """Test full_like() - create filled array with shape from prototype"""
    f_print_info("Testing full_like()")

    prototype = np.array([[1, 2], [3, 4]])
    arr = test_bind.numpycore.full_like(prototype, 7.5)
    assert arr.shape == prototype.shape, f"Expected shape {prototype.shape}, got {arr.shape}"
    assert np.allclose(arr, np.full_like(prototype, 7.5)), "full_like() values incorrect"

    f_print_success("full_like() tests passed")


# ============================================================================
# CONVERSION FUNCTIONS TESTS
# ============================================================================

arange (test_2d_3d_operations.py:11)

#!/usr/bin/env python3
"""Phase 28: Additional 2D/3D Operations Tests"""
import sys
import test_bind

def assert_arrays_equal(np_result, nc_result, test_name):
    if not test_bind.np.allclose(test_bind.np.asarray(np_result), test_bind.np.asarray(nc_result), rtol=1e-10, atol=1e-10, equal_nan=True):
        print(f"[FAIL] {test_name}"); sys.exit(1)
    print(f"[OK] {test_name}: PASSED")

def test_rot90_k2(): assert_arrays_equal(test_bind.np.rot90(test_bind.np.array([[1,2],[3,4]]),k=2), test_bind.np.rot90(test_bind.numpycore.arange(1.,5.,1.).reshape([2,2]),k=2), "rot90_k2")
def test_fliplr(): assert_arrays_equal(test_bind.np.fliplr(test_bind.np.array([[1,2],[3,4]])), test_bind.np.fliplr(test_bind.numpycore.arange(1.,5.,1.).reshape([2,2])), "fliplr")
def test_flipud(): assert_arrays_equal(test_bind.np.flipud(test_bind.np.array([[1,2],[3,4]])), test_bind.np.flipud(test_bind.numpycore.arange(1.,5.,1.).reshape([2,2])), "flipud")
def test_roll_2d(): assert_arrays_equal(test_bind.np.roll(test_bind.np.array([[1,2],[3,4]]),1,axis=0), test_bind.np.roll(test_bind.numpycore.arange(1.,5.,1.).reshape([2,2]),1,axis=0), "roll_2d")
def test_rollaxis(): assert_arrays_equal(test_bind.np.rollaxis(test_bind.np.ones((3,4,5)),2), test_bind.np.rollaxis(test_bind.numpycore.ones([3,4,5]),2), "rollaxis")
def test_transpose_axes(): assert_arrays_equal(test_bind.np.transpose(test_bind.np.ones((2,3,4)),(2,0,1)), test_bind.np.transpose(test_bind.numpycore.ones([2,3,4]),(2,0,1)), "transpose_axes")

def f_main():
    if test_bind.f_setup_test_environment() != 0: return 1
    print("="*70); print("Additional 2D/3D Operations Tests"); print("="*70); print()
    test_rot90_k2(); test_fliplr(); test_flipud(); test_roll_2d(); test_rollaxis(); test_transpose_axes()

linspace (test_advanced_operations.py:75)

        return False


# ============================================================================
# Sorting Tests
# ============================================================================

def test_sort_1d():
    """Test sorting 1D array"""
    np_arr = test_bind.np.array([3.0, 1.0, 4.0, 1.0, 5.0, 9.0])
    nc_arr = test_bind.numpycore.linspace(3.0, 9.0, 6)  # Will need to shuffle or use explicit values

    # Use explicit construction
    nc_values = [3.0, 1.0, 4.0, 1.0, 5.0, 9.0]
    nc_arr = test_bind.numpycore.zeros([6])
    for i, val in enumerate(nc_values):
        nc_arr.itemset(i, val)

    np_sorted = test_bind.np.sort(np_arr)
    nc_sorted = test_bind.np.sort(nc_arr)

eye (test_array_creation_complete.py:102)

    assert np.allclose(arr, np.identity(3)), "identity() values incorrect"

    f_print_success("identity() tests passed")


def test_eye():
    """Test eye() - create matrix with ones on diagonal"""
    f_print_info("Testing eye()")

    # Square matrix
    arr = test_bind.numpycore.eye(3, 3, 0)
    assert arr.shape == (3, 3), f"Expected shape (3, 3), got {arr.shape}"
    assert np.allclose(arr, np.eye(3)), "eye() values incorrect"

    # Rectangular matrix
    arr = test_bind.numpycore.eye(3, 4, 1)
    assert arr.shape == (3, 4), f"Expected shape (3, 4), got {arr.shape}"
    assert np.allclose(arr, np.eye(3, 4, 1)), "eye() with offset values incorrect"

    f_print_success("eye() tests passed")

identity (test_array_creation_complete.py:90)

    assert arr.shape == (2, 3), f"Expected shape (2, 3), got {arr.shape}"
    assert np.allclose(arr, np.full((2, 3), 7.5)), "full() values incorrect"

    f_print_success("full() tests passed")


def test_identity():
    """Test identity() - create identity matrix"""
    f_print_info("Testing identity()")

    arr = test_bind.numpycore.identity(3)
    assert arr.shape == (3, 3), f"Expected shape (3, 3), got {arr.shape}"
    assert np.allclose(arr, np.identity(3)), "identity() values incorrect"

    f_print_success("identity() tests passed")


def test_eye():
    """Test eye() - create matrix with ones on diagonal"""
    f_print_info("Testing eye()")

meshgrid (test_array_creation_extended.py:464)

    np_arr = test_bind.np.arange(0, 24, 1, dtype='float64').reshape(2, 3, 4)
    nc_arr = test_bind.numpycore.arange(0.0, 24.0, 1.0).reshape(2, 3, 4)

    np_result = test_bind.np.ravel(np_arr)
    nc_result = test_bind.numpycore.ravel(nc_arr)

    assert_arrays_equal(np_result, nc_result, "ravel_numpycore_3d")


def test_meshgrid_numpycore_2d_xy():
    """Test numpycore.meshgrid() with 2 vectors, xy indexing"""
    np_x = test_bind.np.array([1.0, 2.0, 3.0])
    np_y = test_bind.np.array([4.0, 5.0])

    nc_x = test_bind.numpycore.array([1.0, 2.0, 3.0])
    nc_y = test_bind.numpycore.array([4.0, 5.0])

    np_xv, np_yv = test_bind.np.meshgrid(np_x, np_y, indexing='xy')
    nc_xv, nc_yv = test_bind.numpycore.meshgrid(nc_x, nc_y, indexing='xy')

    assert_arrays_equal(np_xv, nc_xv, "meshgrid_numpycore_2d_xy_xv")

indices (test_phase11_array_generation.py:36)

    # and all elements after should be >= element at index 3
    partitioned_nc = arr_nc[result_nc]
    partitioned_np = arr_np[result_np]

    assert test_bind.np.all(partitioned_nc[:4] <= partitioned_nc[3]), "Partition property failed for numpycore"
    assert test_bind.np.all(partitioned_nc[4:] >= partitioned_nc[3]), "Partition property failed for numpycore"
    print("[OK] test_argpartition_basic: argpartition(arr, 3) works correctly")

def test_indices_2d_dense():
    """Test indices() - 2D dense mode"""
    grid_nc = test_bind.numpycore.indices((2, 3))
    grid_np = test_bind.np.indices((2, 3))

    assert len(grid_nc) == 2, f"Expected 2 arrays, got {len(grid_nc)}"
    assert test_bind.np.allclose(grid_nc[0], grid_np[0]), "Row indices don't match"
    assert test_bind.np.allclose(grid_nc[1], grid_np[1]), "Column indices don't match"
    print("[OK] test_indices_2d_dense: indices((2, 3)) dense mode matches NumPy")

def test_indices_2d_sparse():
    """Test indices() - 2D sparse mode"""
    grid_nc = test_bind.numpycore.indices((2, 3), sparse=True)