Formatting & Printing

function array2string(a: ArrayLike, options?: { max_line_width?: number; precision?: number; suppress_small?: boolean; separator?: string; prefix?: string; suffix?: string; threshold?: number; edgeitems?: number; sign?: ' ' | '+' | '-'; floatmode?: 'fixed' | 'unique' | 'maxprec' | 'maxprec_equal'; }): string

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

const a = array([[1.123456, 2.789], [3.14159, 4.0]]);

array2string(a);
// '[[1.123456, 2.789   ],\n [3.14159 , 4.      ]]'

array2string(a, { precision: 2, suppress: true });
// '[[1.12, 2.79],\n [3.14, 4.  ]]'

function array_repr(
  a: ArrayLike,
  max_line_width?: number,
  precision?: number,
  suppress_small?: boolean
): string

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

const a = array([[1, 2], [3, 4]]);

array_repr(a);
// 'array([[1, 2],\n       [3, 4]])'

array_repr(a, 40, 2);
// 'array([[1, 2],\n       [3, 4]])'

function array_str(
  a: ArrayLike,
  max_line_width?: number,
  precision?: number
): string

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

const a = array([1.5, 2.5, 3.5]);

array_str(a);
// '[1.5, 2.5, 3.5]'

function base_repr(number: number, base?: number, padding?: number): string

import { base_repr } from 'numpy-ts';

base_repr(10, 2);        // '1010'
base_repr(255, 16);      // 'FF'
base_repr(10, 8, 4);     // '0012'
base_repr(42, 10);       // '42'

function binary_repr(num: number, width?: null | number): string

import { binary_repr } from 'numpy-ts';

binary_repr(10);       // '1010'
binary_repr(3);        // '11'
binary_repr(-3, 8);    // '11111101'  (two's complement)
binary_repr(10, 8);    // '00001010'  (zero-padded)

function format_float_positional(
  x: number,
  precision?: null | number,
  unique?: boolean,
  fractional?: boolean,
  trim?: '-' | '.' | '0' | 'k',
  sign?: ' ' | '+' | '-',
  pad_left?: null | number,
  pad_right?: null | number,
  min_digits?: null | number
): string

import { format_float_positional } from 'numpy-ts';

format_float_positional(3.14);                   // '3.14'
format_float_positional(3.14, 4);                // '3.1400'
format_float_positional(3.14, 4, true, true, '-'); // '3.14'
format_float_positional(3.14, undefined, true, true, 'k', true); // '+3.14'

function format_float_scientific(
  x: number,
  precision?: null | number,
  _unique?: boolean,
  trim?: '-' | '.' | '0' | 'k',
  sign?: ' ' | '+' | '-',
  pad_left?: null | number,
  exp_digits?: number,
  min_digits?: null | number
): string

import { format_float_scientific } from 'numpy-ts';

format_float_scientific(1500.0);              // '1.5e+03'
format_float_scientific(0.00123, 2);          // '1.23e-03'
format_float_scientific(1500.0, 3, true, 'k', true, 3); // '+1.500e+003'

function get_printoptions(): PrintOptions

import { get_printoptions } from 'numpy-ts';

const opts = get_printoptions();
console.log(opts.precision);   // 8
console.log(opts.threshold);   // 1000
console.log(opts.edgeitems);   // 3

function set_printoptions(options: Partial<PrintOptions>): void

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

set_printoptions({ precision: 2, suppress: true });

const a = array([0.000123, 1.23456, 789.0]);
console.log(a);
// array([0.  , 1.23, 789. ])

// Reset to defaults
set_printoptions({ precision: 8, suppress: false });

function printoptions(options: Partial<PrintOptions>): { enter: () => void; exit: () => void; apply: <T>(fn: () => T) => T; _savedOptions: PrintOptions | null; }

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

const a = array([1.23456789, 2.3456789]);

const ctx = printoptions({ precision: 2 });
ctx.enter();
console.log(a);
// array([1.23, 2.35])

ctx.exit();
console.log(a);
// array([1.23456789, 2.3456789 ])