Visitar URL original
NumericArray: Memory-efficient numeric data representation—Wolfram Documentation

WOLFRAM

Wolfram Language & System Documentation Center

NumericArray[array,type]

creates a numeric array of the specified type.

NumericArray[array,type,method]

uses method to convert numbers into type.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Basic Uses  
NumericArray Types  
Integers  
Reals  
Complexes  
Converting between NumericArray Objects  
Operating on a NumericArray  
Array Properties  
Structural Operations  
Properties & Relations  
Possible Issues  
See Also
Related Guides
History
Cite this Page

NumericArray

NumericArray[array,type]

creates a numeric array of the specified type.

NumericArray[array,type,method]

uses method to convert numbers into type.

Details and Options

  • NumericArray provides the most compact representation of array to reduce memory usage and enhance speed of execution.
  • The input array can be a full list of any depth containing machine‐sized integers and machine‐sized approximate real and complex numbers.
  • Possible settings for type include:
  • "Integer8"signed 8-bit integers from through 127
    "UnsignedInteger8"integers 0 through 255
    "Integer16"signed 16-bit integers from through
    "UnsignedInteger16"integers 0 through 65535
    "Integer32"signed 32-bit integers from through
    "UnsignedInteger32"integers 0 through
    "Integer64"signed 64-bit integers from through
    "UnsignedInteger64"integers 0 through
    "Real32"single-precision real (32-bit)
    "Real64"double-precision real (64-bit)
    "ComplexReal32"single-precision complex
    "ComplexReal64"double-precision complex
  • NumericArray[array,type] clips values to the range supported by type and rounds reals to integers, if necessary.
  • Other conversion method settings include:
  • "Check"checks values to be compatible with type
    "Coerce"coerces to type
    "Round"rounds reals to integers
    "ClipAndCheck"clips to the range and checks for compatible type
    "ClipAndCoerce"clips to the range and coerces to type
    "ClipAndRound"clips to the range and rounds reals to integers
  • For complex numbers, the method is applied separately to real and imaginary parts.
  • NumericArray is treated as a raw object by functions like AtomQ and for purposes of pattern matching.
  • Normal[NumericArray[…]] yields the list of values in the numeric array.
  • Functions such as Length, Equal and First work with NumericArray objects.
  • Functions such as Part, Take and Drop can be used to take or drop parts of a NumericArray object.
  • Functions such as ListPlot, ArrayPlot and BarChart can visualize a NumericArray object.

Examples

open all close all

Basic Examples  (2)

Create a vector of byte size integers:

Wolfram Language code: NumericArray[Range[100], "UnsignedInteger8"]

Convert a matrix of reals to a numeric array:

Wolfram Language code: NumericArray[RandomReal[1, {5, 5}], "Real64"]

Convert back to a regular list:

Wolfram Language code: Normal[%]

Scope  (20)

Basic Uses  (6)

Create a numeric array from a list using a specific type:

Wolfram Language code: NumericArray[{1, 2, 3, 4}, "Real32"]

Specify the conversion method to fit numbers in the desired type:

Wolfram Language code: NumericArray[{1, 2, 3, $MaxMachineNumber}, "Real32", "ClipAndCoerce"]

Create a 2D numeric array:

Wolfram Language code: NumericArray[{{1, 2}, {3, 4}}, "UnsignedInteger8"]

Convert ByteArray to NumericArray:

Wolfram Language code: ba = ByteArray[{1, 2, 3, 4}];
Wolfram Language code: NumericArray[ba, "UnsignedInteger8"]

Convert SparseArray to NumericArray:

Wolfram Language code: s = SparseArray[{{1, 1} -> 1, {2, 2} -> 2, {3, 3} -> 3, {4, 4} -> 4}]
Wolfram Language code: NumericArray[s, "UnsignedInteger8"]

Convert SymmetrizedArray to NumericArray:

Wolfram Language code: s = SymmetrizedArray[{{i_, i_, i_, i_} -> 1, {i_, i_, j_, j_} :> i + j}, {4, 4, 4, 4}, {Symmetric[{1, 2, 3, 4}]}]
Wolfram Language code: NumericArray[s, "UnsignedInteger8"]

NumericArray Types  (3)

Integers  (1)

Create an 8-bit unsigned integer numeric array:

Wolfram Language code: NumericArray[{0, 1, 2}, "UnsignedInteger8"]//Normal

For a larger integer, use a larger integer type:

Wolfram Language code: NumericArray[{0, 1000, 2000}, "UnsignedInteger16"]//Normal

Clip large values into a smaller integer type:

Wolfram Language code: NumericArray[{0, 1000, 2000}, "UnsignedInteger8", "ClipAndCoerce"]//Normal

Real numbers can be rounded when converted into an integer type:

Wolfram Language code: NumericArray[{.1, 1.1, 2.1}, "UnsignedInteger8", "Round"]//Normal

Reals  (1)

Create a 32-bit real numeric array:

Wolfram Language code: NumericArray[{.1, 1.1, 2.1}, "Real32"]//Normal

Coerce exact numbers into reals:

Wolfram Language code: NumericArray[{1 / 3, 2 / 3}, "Real32", "Coerce"]//Normal

Complexes  (1)

Create a complex numeric array:

Wolfram Language code: NumericArray[{1 + 2I}, "ComplexReal32"]//Normal

Coerce exact real and imaginary parts of a complex number into reals:

Wolfram Language code: NumericArray[{1 / 3 + 2 / 3I}, "ComplexReal32", "Coerce"]//Normal

Converting between NumericArray Objects  (2)

Convert an "Integer8" array to "Real32":

Wolfram Language code: na = NumericArray[{-100, 0, 5, 120}, "Integer8"]
Wolfram Language code: NumericArray[na, "Real32"]

If numbers cannot be represented in the new type, specify a conversion method:

Wolfram Language code: na = NumericArray[{-100, 0, 5, 120}, "Integer8"]
Wolfram Language code: NumericArray[na, "UnsignedInteger8", "ClipAndCoerce"]

Operating on a NumericArray  (9)

Array Properties  (3)

ByteCount of a numeric array:

Wolfram Language code: na = NumericArray[{1, 2, 3, 4}, "UnsignedInteger8"]; ByteCount[na]

Dimensions:

Wolfram Language code: na = NumericArray[{1, 2, 3, 4}, "UnsignedInteger8"]; Dimensions[na]

ArrayDepth:

Wolfram Language code: na = NumericArray[{1, 2, 3, 4}, "UnsignedInteger8"]; ArrayDepth[na]

Structural Operations  (6)

Flatten a numeric array:

Wolfram Language code: na = NumericArray[{{1, 2}, {3, 4}}, "UnsignedInteger8"]
Wolfram Language code: Flatten[na]

Normal converts a numeric array to a List:

Wolfram Language code: na = NumericArray[{1, 2, 3, 4}, "UnsignedInteger8"]; Normal[na]

Apply Join to numeric array objects:

Wolfram Language code: na = NumericArray[{1, 2, 3, 4}, "UnsignedInteger8"]; Join[na, na]

Use Part to take a part of a numeric array:

Wolfram Language code: NumericArray[Range[100], "UnsignedInteger8"][[1]]

Use Take to take a part of a numeric array:

Wolfram Language code: na = NumericArray[{1, 2, 3, 4}, "UnsignedInteger8"]; Take[na, {2, 3}]

Apply Drop to elements of a numeric array:

Wolfram Language code: na = NumericArray[{1, 2, 3, 4}, "UnsignedInteger8"]; Drop[na, 2]

Properties & Relations  (2)

Byte count of a NumericArray is less than the equivalent list of random integers:

Wolfram Language code: ByteCount[r = RandomInteger[255, {10, 10}]]
Wolfram Language code: ByteCount[NumericArray[r, "UnsignedInteger8"]]

Normal can convert a NumericArray to a normal expression:

Wolfram Language code: Normal[NumericArray[Range[10], "UnsignedInteger8"]]

Possible Issues  (2)

Some conversion methods may not give numbers suitable for the new type:

Wolfram Language code: na = NumericArray[{-100, 0, 5, 120.5}, "Real32"]
Wolfram Language code: NumericArray[na, "Integer8", "ClipAndCoerce"]

Use a conversion that yields numbers supported by the new type:

Wolfram Language code: NumericArray[na, "Integer8", "ClipAndRound"]

The default conversion method will fail when the input array contains numbers that are out of range for the specified type.

Try to store in an "Integer8" numeric array:

Wolfram Language code: NumericArray[{-129}, "Integer8"]

Use the "ClipAndCoerce" method to automatically clip to the smallest "Integer8":

Wolfram Language code: NumericArray[{-129}, "Integer8", "ClipAndCoerce"]
Wolfram Research (2019), NumericArray, Wolfram Language function, https://reference.wolfram.com/language/ref/NumericArray.html.

Text

Wolfram Research (2019), NumericArray, Wolfram Language function, https://reference.wolfram.com/language/ref/NumericArray.html.

CMS

Wolfram Language. 2019. "NumericArray." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/NumericArray.html.

APA

Wolfram Language. (2019). NumericArray. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/NumericArray.html

BibTeX

@misc{reference.wolfram_2026_numericarray, author="Wolfram Research", title="{NumericArray}", year="2019", howpublished="\url{https://reference.wolfram.com/language/ref/NumericArray.html}", note=[Accessed: 14-November-2026]}

BibLaTeX

@online{reference.wolfram_2026_numericarray, organization={Wolfram Research}, title={NumericArray}, year={2019}, url={https://reference.wolfram.com/language/ref/NumericArray.html}, note=[Accessed: 14-November-2026]}