createArray

You can specify the dimensions of an array using one of three syntaxes.

When you specify a scalar, createArray returns a square matrix. Create a 3-by-3 array of zeros using a scalar as input.

A = createArray(3)

A = 3×3

     0     0     0
     0     0     0
     0     0     0

You can specify the dimensions individually. Create a 2-by-3 array of zeros by specifying both dimensions.

B = createArray(2,3)

B = 2×3

     0     0     0
     0     0     0

You can also use a vector to specify the size of the array. Create a 4-by-3-by-2 array of zeros using a vector input.

d = [4 3 2];
C = createArray(d)

C = 
C(:,:,1) =

     0     0     0
     0     0     0
     0     0     0
     0     0     0


C(:,:,2) =

     0     0     0
     0     0     0
     0     0     0
     0     0     0

When you specify a class but not a fill value, createArray fills the array with the default value of that class. Create a 1-by-5 array of class single. The array is filled with 0, which is the default value of single.

S = createArray(1,5,"single")

S = 1×5 single row vector

     0     0     0     0     0

createArray can return arrays of almost any MATLAB class. Create a 5-by-1 array of class datetime. The array is filled with NaT, which is the default value of datetime.

D = createArray(5,1,"datetime")

D = 5×1 datetime
   NaT
   NaT
   NaT
   NaT
   NaT

You can also use the Like name-value argument to specify a class. createArray uses the class of the prototype to determine a default value. Create a 1-by-3 array using a uint16 prototype. The returned array preserves the class of the prototype value and substitutes in the default value of uint16.

E = createArray(1,3,Like=uint16(12))

E = 1×3 uint16 row vector

   0   0   0

The Like name-value argument enables you to create an array based on a prototype. The returned array takes on the class, complexity, sparsity, and other properties of the prototype.

Define a complex variable of class uint8.

p = uint8(7 + 3i)

p = uint8

7 +   3i

Create a 3-by-3 array using p as a prototype. The returned array has the same class and complexity as p, but createArray uses the default value of the class, which is 0, instead of the actual value of p.

X = createArray(3,Like=p)

X = 3×3 uint8 matrix

   0 +   0i   0 +   0i   0 +   0i
   0 +   0i   0 +   0i   0 +   0i
   0 +   0i   0 +   0i   0 +   0i

Using a prototype also preserves other properties of the prototype, including general formatting. Create a 2-by-3 array with a duration prototype.

Y = createArray(2,3,Like=seconds(30))

Y = 2×3 duration
   0 sec   0 sec   0 sec
   0 sec   0 sec   0 sec

The value of elements of Y is the default value of duration, but they have the same format as the prototype.

Y.Format

ans = 
's'

Use the FillValue name-value argument to set the value of all elements of an array.

Create a 2-by-3 array of 10 seconds as a duration.

A = createArray(2,3,FillValue=seconds(10))

A = 2×3 duration
   10 sec   10 sec   10 sec
   10 sec   10 sec   10 sec

createArray preserves the class of the fill value. Create a 3-by-3 array of pi as a single.

P = createArray(3,FillValue=single(pi))

P = 3×3 single matrix

    3.1416    3.1416    3.1416
    3.1416    3.1416    3.1416
    3.1416    3.1416    3.1416

f = duration(0,30,0,Format="hh:mm");
C = createArray(3,"string",FillValue=f)

C = 3×3 string
    "00:30"    "00:30"    "00:30"
    "00:30"    "00:30"    "00:30"
    "00:30"    "00:30"    "00:30"

p = single(3 + 1i);
Y = createArray(2,4,Like=p,FillValue=8)

Y = 2×4 single matrix

   8.0000 + 0.0000i   8.0000 + 0.0000i   8.0000 + 0.0000i   8.0000 + 0.0000i
   8.0000 + 0.0000i   8.0000 + 0.0000i   8.0000 + 0.0000i   8.0000 + 0.0000i

T = datetime(NaT,Format="hh:mm");
Z = createArray(2,3,Like=T,FillValue="now")

Z = 2×3 datetime
   12:16   12:16   12:16
   12:16   12:16   12:16

Create an array of objects of a user-defined class named BasicClass. (For more information on this class, see Creating a Simple Class.)

classdef BasicClass
    properties
        Value {mustBeNumeric} = 0
    end
    methods
        function obj = BasicClass(val)
            if nargin == 1
                obj.Value = val;
            end
        end
        function r = roundOff(obj)
            r = round([obj.Value],2);
        end
        function r = multiplyBy(obj,n)
            r = [obj.Value] * n;
        end
        function r = plus(o1,o2)
            r = [o1.Value] + [o2.Value];
        end
    end
end

Create a 2-by-3 object array. Use "BasicClass" as the classname input argument. createArray calls the no-argument constructor once to create a default object. The array is filled with copies of that default object.

A = createArray(2,3,"BasicClass")

A=2×3 BasicClass array with properties:
    Value

Because all elements are copies of the default object, the Value property of each instance takes the default property value of 0.

[A.Value]

ans = 1×6

     0     0     0     0     0     0

Create a new 2-by-2 array using A as a prototype. Set the FillValue to NaN. MATLAB converts the fill value to the class of the prototype by calling the BasicClass constructor with the fill value as an argument.

B = createArray(2,Like=A,FillValue=NaN)

B=2×2 BasicClass array with properties:
    Value

Because all elements are copies of the result of one call to the one-argument constructor, the Value property of each instance is assigned the value NaN.

[B.Value]

ans = 1×4

   NaN   NaN   NaN   NaN

Set the FillValue to an instance of BasicClass with an input argument to get a 2-by-2 array with the property Value set to -1.

C = createArray(2,FillValue=BasicClass(-1));
[C.Value]

ans = 1×4

    -1    -1    -1    -1