WOLFRAM

Wolfram Language & System Documentation Center

GPUArray[array]

yields an array stored in memory accessible for GPU-accelerated computation.

Details
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Basic Uses  
Arrays Operations  
Mathematical Operations  
Show More Show More
Fourier Analysis  
Statistics  
Linear Algebra  
Random Number Generation  
Visualization  
Properties & Relations  
Possible Issues  
See Also
Related Guides
History
Cite this Page

GPUArray

GPUArray[array]

yields an array stored in memory accessible for GPU-accelerated computation.

Details

  • GPUArray provides an efficient representation for storing and manipulating data accessible from a graphics processor unit (GPU).
  • GPUArray is typically used to enhance speed of execution of functions by running computations on the GPU.
  • GPUArray[array] creates an array in GPU memory or unified memory.
  • The array can have the following forms:
  • {e1,…},{{e1,…},…},…full array of numeric elements
    NumericArray[…]numeric array of a specified type
  • Normal[GPUArray[array]] converts the GPUArray object to an ordinary list of values.
  • Additional conversions include:
  • SparseArray[GPUArray[…]]sparse array with few nonzero elements
    NumericArray[GPUArray[…],type]numeric array of a specified type
  • Information for a GPUArray includes the following properties:
  • "ElementType"element native type
    "Dimensions"list of the dimensions
  • Functions such as LinearSolve, Plus and Part work on GPUArray by running the computation on the GPU.
  • GPUArray is treated as a raw object by functions like AtomQ and for purposes of pattern matching.

Examples

open all close all

Basic Examples  (1)

Create a GPUArray object from a vector:

Wolfram Language code: ga = GPUArray[{0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5}]

Compute the cosine:

Wolfram Language code: Cos[ga]

Converts to an ordinary list of values:

Wolfram Language code: Normal[%]

Scope  (27)

Basic Uses  (4)

Create a GPUArray object from a vector:

Wolfram Language code: GPUArray[{0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5}]

From a matrix:

Wolfram Language code: GPUArray[{{0., 0.5}, {1., 1.5}, {2., 2.5}, {3., 3.5}}]

Use NumericArray to create a GPUArray object of a specified type:

Wolfram Language code: GPUArray[NumericArray[RandomReal[1, 20], "Real32"]]

64-bit integers:

Wolfram Language code: GPUArray[NumericArray[RandomInteger[10, 20], "Integer64"]]

Convert a GPUArray object to an ordinary list of values:

Wolfram Language code: ga = GPUArray[{0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5}]
Wolfram Language code: Normal[ga]

Convert to a NumericArray object:

Wolfram Language code: NumericArray[ga, "Real32"]

Convert to a SparseArray:

Wolfram Language code: SparseArray[ga]

Get information of a GPUArray object:

Wolfram Language code: ga = GPUArray[{{0., 0.5}, {1., 1.5}, {2., 2.5}, {3., 3.5}}]

Dimensions:

Wolfram Language code: ga["Dimensions"]

Type of elements:

Wolfram Language code: ga["ElementType"]

Arrays Operations  (3)

Test whether a GPUArray object is a vector:

Wolfram Language code: GPUArray[{0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5}]
Wolfram Language code: VectorQ[%]

A matrix:

Wolfram Language code: GPUArray[{{0., 0.5}, {1., 1.5}, {2., 2.5}, {3., 3.5}}]
Wolfram Language code: MatrixQ[%]

Extract parts of a GPUArray object:

Wolfram Language code: ga = GPUArray[{{0., 0.5}, {1., 1.5}, {2., 2.5}, {3., 3.5}}]
Wolfram Language code: Part[ga, 2]
Wolfram Language code: Part[ga, 1, 2]

Get properties of a GPUArray object:

Wolfram Language code: ga = GPUArray[{{0., 0.5}, {1., 1.5}, {2., 2.5}, {3., 3.5}}]

Dimensions:

Wolfram Language code: Dimensions[ga]

Depth:

Wolfram Language code: ArrayDepth[ga]

Byte count:

Wolfram Language code: ByteCount[ga]

Mathematical Operations  (6)

Apply arithmetic operations on GPUArray objects:

Wolfram Language code: ga = GPUArray[{0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5}]; gb = GPUArray[{1., 1.5, 1.1, 2.5, 2.3, 3.5, 4., 4.5}];

Addition:

Wolfram Language code: ga + gb

Multiplication:

Wolfram Language code: ga * gb

Power:

Wolfram Language code: ga ^ 2

Evaluate numerically trigonometric functions:

Wolfram Language code: ga = GPUArray[{0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5}];

Sine:

Wolfram Language code: Sin[ga]

Cosine:

Wolfram Language code: Cos[ga]

Arc cosine:

Wolfram Language code: ArcCos[ga]

Compute transcendental functions:

Wolfram Language code: ga = GPUArray[{0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5}];

Exp:

Wolfram Language code: Exp[ga]

Log:

Wolfram Language code: Log[ga]

Power:

Wolfram Language code: ga ^ 2

Evaluate efficiently hyperbolic functions:

Wolfram Language code: ga = GPUArray[{5., 0.5, 1., 1.5, 2., 2.5, 3., 3.5}];

Sinh:

Wolfram Language code: Sinh[ga]

Cosh:

Wolfram Language code: Cosh[ga]

Inverse cosine:

Wolfram Language code: ArcCosh[ga]

Evaluate numerically integer functions:

Wolfram Language code: ga = GPUArray[{0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5}];

Ceiling:

Wolfram Language code: Ceiling[ga]

Floor:

Wolfram Language code: Floor[ga]

Round:

Wolfram Language code: Round[ga]

Compute absolute values and signs functions:

Wolfram Language code: ga = GPUArray[{0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5}];

Abs:

Wolfram Language code: Abs[ga]

Sign:

Wolfram Language code: Sign[ga]

Absolute value of the real:

Wolfram Language code: RealAbs[ga]

Fourier Analysis  (2)

Find a discrete Fourier transform:

Wolfram Language code: GPUArray[{0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5}]
Wolfram Language code: Fourier[%]

Inverse Fourier transform of a complex list:

Wolfram Language code: GPUArray[{0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5}]
Wolfram Language code: InverseFourier[%]

Statistics  (3)

Evaluate statistics functions on a GPUArray object:

Wolfram Language code: ga = GPUArray[{0.4, 0.5, 1., 1.5, 2., 2.5, 3., 3.5}];

Mean:

Wolfram Language code: Mean[ga]

Geometric mean:

Wolfram Language code: GeometricMean[ga]

Variance:

Wolfram Language code: Variance[ga]

Standard deviation:

Wolfram Language code: StandardDeviation[ga]

Skewness:

Wolfram Language code: Skewness[ga]

Minimum of a GPUArray object:

Wolfram Language code: ga = GPUArray[{0.4, 0.5, 1., 1.5, 2., 2.5, 3., 3.5}];
Wolfram Language code: Min[ga]

Maximum:

Wolfram Language code: Max[ga]

Minimum and maximum:

Wolfram Language code: MinMax[ga]

Sort a GPUArray object:

Wolfram Language code: ga = GPUArray[{0.4, 0.5, 1., 1.5, 2., 2.5, 3., 3.5}];
Wolfram Language code: Sort[ga]

Linear Algebra  (4)

Apply matrix operations on GPUArray objects:

Wolfram Language code: ga = GPUArray[{0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5}]; gb = GPUArray[{1., 1.5, 1.1, 2.5, 2.3, 3.5, 4., 4.5}];

Dot product:

Wolfram Language code: ga.gb

Transpose:

Wolfram Language code: Transpose[ga]

Trace:

Wolfram Language code: Tr[ga]

Solve a matrix-vector equation:

Wolfram Language code: gm = GPUArray[{{0., 0.5, 1.}, {1.5, 2., 2.5}, {3., 3.5, 4.}}];
Wolfram Language code: gb = GPUArray[{0.5, 1., 1.5}];
Wolfram Language code: LinearSolve[gm, gb]

A matrix equation:

Wolfram Language code: gm = GPUArray[{{0., 0.5}, {1., 1.5}}];
Wolfram Language code: gb = GPUArray[{{2., 2.5}, {3., 3.5}}];
Wolfram Language code: LinearSolve[gm, gb]

Solve a matrix-vector least-squares problem:

Wolfram Language code: gm = GPUArray[{{0., 0.5, 1.}, {1.5, 2., 2.5}, {3., 3.5, 4.}, {4.5, 5., 5.5}}]; gbv = GPUArray[{0.5, 1., 1.5, 2.}]; LeastSquares[gm, gbv]

Solve a matrix-matrix least-squares problem:

Wolfram Language code: gbm = GPUArray[{{0.5, 1.}, {1.5, 2.}, {2.5, 3.}, {3.5, 4}}]; LeastSquares[gm, gbm]

Compute the singular value decomposition of a complex-valued matrix:

Wolfram Language code: m = GPUArray[NumericArray[RandomComplex[1 + I, {3, 3}], "ComplexReal32"]];
Wolfram Language code: {u, σ, v} = SingularValueDecomposition[m]

Up to expected precision loss, m=u.sigma.TemplateBox[{v}, ConjugateTranspose]:

Wolfram Language code: Chop[m - u.σ.v, 10^-6] == SymbolicZerosArray[Dimensions[m]]//Normal

Random Number Generation  (2)

Switch to the GPU random number generator:

Wolfram Language code: SeedRandom[Method -> "GPU"]

Random numbers are now generated using it:

Wolfram Language code: RandomReal[1, 5]

Random integers:

Wolfram Language code: RandomInteger[10, 5]

Random complexes:

Wolfram Language code: RandomComplex[1 + I, 5]

A specific seed will affect the current GPU random number generator:

Wolfram Language code: SeedRandom[123, Method -> "GPU"];RandomReal[1, 5]

Visualization  (3)

Plot a list of values from a continuous probability distribution:

Wolfram Language code: GPUArray[RandomVariate[NormalDistribution[0, 1], 200]]
Wolfram Language code: ListPlot[%]

Plot an array of numbers:

Wolfram Language code: ArrayPlot[GPUArray[RandomReal[1, {10, 10}]]]

Plot a matrix as an array of colors:

Wolfram Language code: MatrixPlot[GPUArray[RandomReal[1, {10, 10}]]]

Properties & Relations  (4)

Use GPUArrayQ to test whether an object is a valid GPUArray object:

Wolfram Language code: GPUArray[{0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5}]
Wolfram Language code: GPUArrayQ[%]

Find the number of bytes used to store a GPUArray object:

Wolfram Language code: GPUArray[RandomReal[1, 10 ^ 3]]
Wolfram Language code: ByteCount[%]

Use Normal to retrieve data from GPU:

Wolfram Language code: GPUArray[{1, 2, 3, 4, 5, 6, 7}]
Wolfram Language code: Normal[%]

GPUArray preserves representation types of elements in NumericArray objects:

Wolfram Language code: NumericArray[RandomReal[1, 20], "Real32"]
Wolfram Language code: GPUArray[%]

Element type:

Wolfram Language code: %["ElementType"]

Possible Issues  (2)

GPUArray autoevaluates if no supported GPUs were detected:

Wolfram Language code: GPUArray[{1, 2, 3, 4, 5}]

Operations without GPU-accelerated support fall back to CPU implementations:

Wolfram Language code: ga = GPUArray[RandomReal[1, 6]];
Wolfram Language code: Csch[ga]
Wolfram Research (2025), GPUArray, Wolfram Language function, https://reference.wolfram.com/language/ref/GPUArray.html.

Text

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

CMS

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

APA

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

BibTeX

@misc{reference.wolfram_2026_gpuarray, author="Wolfram Research", title="{GPUArray}", year="2025", howpublished="\url{https://reference.wolfram.com/language/ref/GPUArray.html}", note=[Accessed: 15-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_gpuarray, organization={Wolfram Research}, title={GPUArray}, year={2025}, url={https://reference.wolfram.com/language/ref/GPUArray.html}, note=[Accessed: 15-June-2026]}