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 allBasic Examples (2)
Scope (20)
Basic Uses (6)
Create a numeric array from a list using a specific type:
NumericArray[{1, 2, 3, 4}, "Real32"]Specify the conversion method to fit numbers in the desired type:
NumericArray[{1, 2, 3, $MaxMachineNumber}, "Real32", "ClipAndCoerce"]NumericArray[{{1, 2}, {3, 4}}, "UnsignedInteger8"]Convert ByteArray to NumericArray:
ba = ByteArray[{1, 2, 3, 4}];NumericArray[ba, "UnsignedInteger8"]Convert SparseArray to NumericArray:
s = SparseArray[{{1, 1} -> 1, {2, 2} -> 2, {3, 3} -> 3, {4, 4} -> 4}]NumericArray[s, "UnsignedInteger8"]Convert SymmetrizedArray to NumericArray:
s = SymmetrizedArray[{{i_, i_, i_, i_} -> 1, {i_, i_, j_, j_} :> i + j}, {4, 4, 4, 4}, {Symmetric[{1, 2, 3, 4}]}]NumericArray[s, "UnsignedInteger8"]NumericArray Types (3)
Integers (1)
Create an 8-bit unsigned integer numeric array:
NumericArray[{0, 1, 2}, "UnsignedInteger8"]//NormalFor a larger integer, use a larger integer type:
NumericArray[{0, 1000, 2000}, "UnsignedInteger16"]//NormalClip large values into a smaller integer type:
NumericArray[{0, 1000, 2000}, "UnsignedInteger8", "ClipAndCoerce"]//NormalReal numbers can be rounded when converted into an integer type:
NumericArray[{.1, 1.1, 2.1}, "UnsignedInteger8", "Round"]//NormalReals (1)
Converting between NumericArray Objects (2)
Convert an "Integer8" array to "Real32":
na = NumericArray[{-100, 0, 5, 120}, "Integer8"]NumericArray[na, "Real32"]If numbers cannot be represented in the new type, specify a conversion method:
na = NumericArray[{-100, 0, 5, 120}, "Integer8"]NumericArray[na, "UnsignedInteger8", "ClipAndCoerce"]Operating on a NumericArray (9)
Array Properties (3)
ByteCount of a numeric array:
na = NumericArray[{1, 2, 3, 4}, "UnsignedInteger8"];
ByteCount[na]na = NumericArray[{1, 2, 3, 4}, "UnsignedInteger8"];
Dimensions[na]na = NumericArray[{1, 2, 3, 4}, "UnsignedInteger8"];
ArrayDepth[na]Structural Operations (6)
na = NumericArray[{{1, 2}, {3, 4}}, "UnsignedInteger8"]Flatten[na]Normal converts a numeric array to a List:
na = NumericArray[{1, 2, 3, 4}, "UnsignedInteger8"];
Normal[na]Apply Join to numeric array objects:
na = NumericArray[{1, 2, 3, 4}, "UnsignedInteger8"];
Join[na, na]Use Part to take a part of a numeric array:
NumericArray[Range[100], "UnsignedInteger8"][[1]]Use Take to take a part of a numeric array:
na = NumericArray[{1, 2, 3, 4}, "UnsignedInteger8"];
Take[na, {2, 3}]Apply Drop to elements of a numeric array:
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:
ByteCount[r = RandomInteger[255, {10, 10}]]ByteCount[NumericArray[r, "UnsignedInteger8"]]Normal can convert a NumericArray to a normal expression:
Normal[NumericArray[Range[10], "UnsignedInteger8"]]Possible Issues (2)
Some conversion methods may not give numbers suitable for the new type:
na = NumericArray[{-100, 0, 5, 120.5}, "Real32"]NumericArray[na, "Integer8", "ClipAndCoerce"]
Use a conversion that yields numbers supported by the new type:
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:
NumericArray[{-129}, "Integer8"]
Use the "ClipAndCoerce" method to automatically clip to the smallest "Integer8":
NumericArray[{-129}, "Integer8", "ClipAndCoerce"]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