Type Checking

function can_cast(
  from_: ArrayLike | DType,
  to: DType,
  casting?: 'no' | 'equiv' | 'safe' | 'same_kind' | 'unsafe'
): boolean

import { can_cast } from 'numpy-ts';

can_cast('int32', 'float64');                // true  (safe)
can_cast('float64', 'int32');                // false (not safe)
can_cast('float64', 'int32', 'unsafe');      // true
can_cast('float32', 'float64', 'same_kind'); // true
can_cast('int32', 'int32', 'no');            // true

function common_type(...arrays: ArrayLike[]): DType

import { array, common_type } from 'numpy-ts';

const a = array([1, 2], 'float32');
const b = array([3, 4], 'int32');

common_type(a, b);    // 'float64'
common_type(a);       // 'float32'

function result_type(...arrays_and_dtypes: (ArrayLike | DType)[]): DType

import { array, result_type } from 'numpy-ts';

result_type('int32', 'float32');           // 'float64'
result_type('float32', 'float32');         // 'float32'
result_type(array([1, 2], 'int16'), 'int32'); // 'int32'

function min_scalar_type(val: number | bigint | boolean): DType

import { min_scalar_type } from 'numpy-ts';

min_scalar_type(0);       // 'uint8'
min_scalar_type(255);     // 'uint8'
min_scalar_type(256);     // 'uint16'
min_scalar_type(-1);      // 'int8'
min_scalar_type(3.14);    // 'float64'

function issubdtype(dtype1: ArrayLike | DType, dtype2: DType | string): boolean

import { issubdtype } from 'numpy-ts';

issubdtype('int32', 'integer');           // true
issubdtype('float64', 'floating');        // true
issubdtype('int32', 'floating');          // false
issubdtype('uint8', 'unsignedinteger');   // true
issubdtype('float32', 'number');          // true
issubdtype('bool', 'integer');            // true

function typename(dtype: DType): string

import { typename } from 'numpy-ts';

typename(1);   // 'int8'
typename(5);   // 'float32'
typename(12);  // 'float64'

function mintypecode(
  typechars: string,
  typeset?: string,
  default_?: string
): string

import { mintypecode } from 'numpy-ts';

mintypecode(['f', 'd']);    // 'd'  (float64 needed for float32 + float64)
mintypecode(['i', 'f']);    // 'd'  (float64 covers int + float32)
mintypecode([]);            // 'd'  (default)