numpy-ts 0.12.0 → 0.13.1

package/dist/types/core/typechecking.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Type checking and dtype utility functions
+ *
+ * Tree-shakeable standalone functions for dtype operations.
+ */
+import { NDArrayCore, type DType } from '../common/ndarray-core';
+/**
+ * Check if a cast between dtypes is possible according to the casting rule
+ */
+export declare function can_cast(from_: DType | NDArrayCore, to: DType, casting?: 'no' | 'equiv' | 'safe' | 'same_kind' | 'unsafe'): boolean;
+/**
+ * Return a scalar type common to input arrays
+ *
+ * This returns a floating-point type that can represent all input types.
+ * Integers are promoted to floats that can hold their full range.
+ */
+export declare function common_type(...arrays: NDArrayCore[]): DType;
+/**
+ * Return the type that results from applying promotion rules
+ *
+ * NumPy-compatible type promotion:
+ * - Integers promote to larger integers that can hold both ranges
+ * - int32 + uint32 -> int64 (needs signed type that fits both)
+ * - Integer + float -> float64 if integer is 32+ bits
+ * - float32 + complex64 -> complex64
+ * - float64 + complex64 -> complex128
+ */
+export declare function result_type(...arrays_and_dtypes: (NDArrayCore | DType)[]): DType;
+/**
+ * Return the minimum scalar type needed to represent a value
+ */
+export declare function min_scalar_type(val: number | bigint | boolean): DType;
+/**
+ * Check if dtype1 is a subtype of dtype2
+ */
+export declare function issubdtype(dtype1: DType | NDArrayCore, dtype2: DType | string): boolean;
+/**
+ * Return a description for the given dtype
+ *
+ * Returns the dtype name directly (NumPy compatible).
+ */
+export declare function typename(dtype: DType): string;
+/**
+ * Return the character code of the minimum-size type needed
+ *
+ * Returns the minimum type from typeset that can safely represent all input types.
+ * Uses safe casting rules to ensure no precision loss.
+ */
+export declare function mintypecode(typechars: string, typeset?: string, default_?: string): string;
+//# sourceMappingURL=typechecking.d.ts.map

package/dist/types/core/types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Shared types for standalone function modules
+ *
+ * This module provides type definitions and helper functions used by
+ * standalone function wrappers for tree-shaking support.
+ */
+import { NDArrayCore } from '../common/ndarray-core';
+import { ArrayStorage } from '../common/storage';
+import { Complex } from '../common/complex';
+export type { DType, TypedArray } from '../common/dtype';
+export { NDArrayCore, ArrayStorage, Complex };
+/**
+ * Input type for functions that accept arrays
+ * Can be an NDArrayCore instance or nested arrays
+ */
+export type ArrayLike = NDArrayCore | number[] | number[][] | number[][][] | number | bigint;
+/**
+ * Convert input to ArrayStorage
+ * Handles both NDArrayCore and NDArray (which has _storage property)
+ */
+export declare function toStorage(a: NDArrayCore | ArrayStorage): ArrayStorage;
+/**
+ * Wrap ArrayStorage result in NDArrayCore
+ */
+export declare function fromStorage(storage: ArrayStorage, base?: NDArrayCore): NDArrayCore;
+/**
+ * Wrap ArrayStorage result in NDArrayCore as a view of the input array
+ * Sets the base to track the view relationship
+ */
+export declare function fromStorageView(storage: ArrayStorage, original: NDArrayCore): NDArrayCore;
+/**
+ * Wrap multiple ArrayStorage results
+ */
+export declare function fromStorageArray(storages: ArrayStorage[]): NDArrayCore[];
+/**
+ * Wrap multiple ArrayStorage results as views of the original array
+ */
+export declare function fromStorageViewArray(storages: ArrayStorage[], original: NDArrayCore): NDArrayCore[];
+/**
+ * Wrap a tuple of ArrayStorage results
+ */
+export declare function fromStorageTuple(tuple: [ArrayStorage, ArrayStorage]): [NDArrayCore, NDArrayCore];
+//# sourceMappingURL=types.d.ts.map

package/dist/types/core/utility.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Utility functions
+ *
+ * Tree-shakeable standalone functions for array introspection.
+ */
+import { NDArrayCore, type DType } from '../common/ndarray-core';
+import { Complex } from '../common/complex';
+/**
+ * Return the number of dimensions of an array.
+ * Works with NDArrayCore, scalars, and nested arrays.
+ */
+export declare function ndim(a: NDArrayCore | number | bigint | boolean | unknown[] | unknown): number;
+/**
+ * Return the shape of an array.
+ * Works with NDArrayCore, scalars, and nested arrays.
+ */
+export declare function shape(a: NDArrayCore | number | bigint | boolean | unknown[] | unknown): readonly number[] | number[];
+/**
+ * Return the number of elements in an array.
+ * Works with NDArrayCore, scalars, and nested arrays.
+ */
+export declare function size(a: NDArrayCore | number | bigint | boolean | unknown[] | unknown): number;
+export declare function item(a: NDArrayCore, ...args: number[]): number | bigint | boolean | Complex;
+export declare function tolist(a: NDArrayCore): unknown;
+export declare function tobytes(a: NDArrayCore, order?: 'C' | 'F'): Uint8Array;
+export declare function byteswap(a: NDArrayCore, inplace?: boolean): NDArrayCore;
+export declare function view(a: NDArrayCore, dtype?: DType): NDArrayCore;
+export declare function tofile(_a: NDArrayCore, _file: string, _sep?: string, _format?: string): void;
+export declare function fill(a: NDArrayCore, value: number | bigint | boolean | Complex): void;
+//# sourceMappingURL=utility.d.ts.map

package/dist/types/core.d.ts

@@ -0,0 +1,30 @@
+/**
+ * numpy-ts/core - Tree-shakeable entry point
+ *
+ * This module provides standalone functions that return NDArrayCore.
+ * Use this entry point when bundle size is critical and you don't need method chaining.
+ *
+ * All functions in this module are designed for optimal tree-shaking.
+ * Import only what you need to get minimal bundle sizes.
+ *
+ * @example
+ * ```typescript
+ * import { array, add, reshape } from 'numpy-ts/core';
+ *
+ * const a = array([1, 2, 3, 4]);
+ * const b = add(a, 10);              // Standalone function
+ * const c = reshape(b, [2, 2]);      // Standalone function
+ * console.log(c.shape);              // [2, 2]
+ * ```
+ *
+ * For method chaining, use the main entry point instead:
+ * ```typescript
+ * import { array } from 'numpy-ts';
+ *
+ * const c = array([1, 2, 3, 4]).add(10).reshape([2, 2]);
+ * ```
+ *
+ * @module numpy-ts/core
+ */
+export * from './core/index';
+//# sourceMappingURL=core.d.ts.map