matlab::data::ArrayFactory - C++ class to create arrays - MATLAB (original) (raw)

C++ class to create arrays

Description

Use ArrayFactory to create matlab::data::Array objects.

Class Details

Constructors

• Default Constructor

Default Constructor

Throws

Destructor

~ArrayFactory()

Member Functions

• createArray
• createScalar
• createCellArray
• createCharArray
• createCharArrayFromUTF8
• createStructArray
• createEnumArray
• createSparseArray
• createEmptyArray
• createBuffer
• createArrayFromBuffer

createArray

template TypedArray createArray(ArrayDimensions dims)

template <typename ItType, typename T> TypedArray createArray(ArrayDimensions dims, ItType begin, ItType end, InputLayout inputLayout)

template TypedArray createArray(ArrayDimensions dims, const T* const begin, const T* const end)

template TypedArray createArray(ArrayDimensions dims, std::initializer_list data)

Description

Creates a TypedArray<T> with the given dimensions. If specified, createArray fills the array with data. The data is copied by default in column-major order. To specify the data layout, use theinputLayout parameter.

Template Parameters

• ItType - Iterator types, specified asstd::iterator.
• T - Element types, specified as one of the following C++ data types.

  bool	int8_t	int16_t	int32_t	int64_t	uint8_t
  uint16_t	uint32_t	uint64_t	float	double	char16_t
  matlab::data::String	std::complex	std::complex	std::complex<int8_t>	std::complex<uint8_t>	std::complex<int16_t>
  std::complex<uint16_t>	std::complex<int32_t>	std::complex<uint32_t>	std::complex<int64_t>	std::complex<uint64_t>	matlab::data::MATLABString
  To create an array of matlab::data::Object element types, use the TypedArray<T> createArray(ArrayDimensions dims, ItType begin, ItType end) syntax.

Parameters

Throws

createScalar

template TypedArray createScalar(const T val)

TypedArray createScalar(const String val)

TypedArray createScalar(const std::string val)

ObjectArray createScalar(const Object& val);

Description

Creates a scalar TypedArray<T> with the given value. This method supports arithmetic types, complex types, and string types.

Parameters

Throws

Examples

#include "MatlabDataArray.hpp"

int main() { matlab::data::ArrayFactory factory;

// Create a vector containing two scalar values    
std::vector<matlab::data::Array> args({
factory.createScalar<int16_t>(100),
factory.createScalar<int16_t>(60)});
return 0;

}

createCellArray

CellArray createCellArray(ArrayDimensions dims)

template <typename ...Targs> CellArray createCellArray(ArrayDimensions dims, Targs... data)

Description

Creates a CellArray with the specifieddata. The data is in column-major order.

Template Parameters

Parameters

Throws

Examples

Create a two element cell array containing an std::string and a double.

#include "MatlabDataArray.hpp"

int main() { using namespace matlab::data; ArrayFactory f; CellArray myArray = f.createCellArray({ 1,2 }, std::string("MATLAB Cell Array"), 5.5);

return 0;

}

createCharArray

CharArray createCharArray(String str)

CharArray createCharArray(std::string str)

Description

Creates a 1xn CharArray from the specified input, where n is the string length.

Parameters

Throws

Examples

#include "MatlabDataArray.hpp"

int main() { using namespace matlab::data; ArrayFactory factory; CharArray A = factory.createCharArray("This is a char array"); return 0; }

createCharArrayFromUTF8

CharArray createCharArray(const std::string& str)

Description

Creates a 1xn CharArray from the specifiedstd::string of UTF8 characters, where n is the string length.

Parameters

Throws

Examples

#include "MatlabDataArray.hpp"

int main() { using namespace matlab::data; ArrayFactory factory; // "UTF8 string" std::string utf8str = "\x55\x54\x46\x20\x73\x74\x72\x69\x6e\x67"; CharArray A = factory.createCharArrayFromUTF8(utf8str); return 0; }

createStructArray

StructArray createStructArray(ArrayDimensions dims, std::vectorstd::string fieldNames)

Description

Creates a StructArray with the given dimensions and field names.

Parameters

Throws

Examples

#include "MatlabDataArray.hpp"

int main() { using namespace matlab::data; ArrayFactory f;

// Create StructArray equivalent to MATLAB structure s:
// s = struct('loc', {'east', 'west'}, 'data', {[1, 2, 3], [4., 5., 6., 7., 8.]})
StructArray S = f.createStructArray({ 1,2 }, { "loc", "data" });
S[0]["loc"] = f.createCharArray("east");
S[0]["data"] = f.createArray<uint8_t>({ 1, 3 }, { 1, 2, 3 });
S[1]["loc"] = f.createCharArray("west");
S[1]["data"] = f.createArray<double>({ 1, 5 }, { 4., 5., 6., 7., 8. });

// Access the value defined by the MATLAB statement:
// s(1).data
Reference<Array> val = S[0]["data"];

return 0;

}

createEnumArray

EnumArray createEnumArray(ArrayDimensions dims, std::string className, std::vectorstd::string enums)

EnumArray createEnumArray(ArrayDimensions dims, std::string className)

Description

Creates an EnumArray of type className, which is a defined class. If specified, the method initializes the array with the list of enumeration names.

Parameters

Throws

Examples

Create a matlab::data::EnumArray object for theTextColor.Blue enumeration argument defined in this class.

classdef TextColor enumeration Red Green Blue end end

Move the value into an argument vector.

#include "MatlabDataArray.hpp" #include

int main() { using namespace matlab::data; ArrayFactory f; auto blue = f.createEnumArray({ 1,1 }, "TextColor", { "Blue" });

// Create an argument vector
std::vector<Array> args({ f.createCharArray("My text"), std::move(blue) });

return 0;

}

For more examples, see Pass Enumerations to MATLAB from C++.

createSparseArray

template SparseArray createSparseArray(ArrayDimensions dims, size_t nnz, buffer_ptr_t data, buffer_ptr_t rows, buffer_ptr_t cols)

Description

Creates a SparseArray<T> withrows-by-cols dimensions. You can only have two dimensions for sparse arrays. The method does not copy the buffer and the array takes ownership of the memory.

Template Parameters

Parameters

Throws

Examples

#include "MatlabDataArray.hpp"

int main() { std::vector data = { 3.5, 12.98, 21.76 }; std::vector rows = { 0,0,1 }; std::vector cols = { 0,4,8 }; size_t nnz = 3;

matlab::data::ArrayFactory factory;
auto data_p = factory.createBuffer<double>(nnz);
auto rows_p = factory.createBuffer<size_t>(nnz);
auto cols_p = factory.createBuffer<size_t>(nnz);

double* dataPtr = data_p.get();
size_t* rowsPtr = rows_p.get();
size_t* colsPtr = cols_p.get();
std::for_each(data.begin(), data.end(), [&](const double& e) { *(dataPtr++) = e; });
std::for_each(rows.begin(), rows.end(), [&](const size_t& e) { *(rowsPtr++) = e; });
std::for_each(cols.begin(), cols.end(), [&](const size_t& e) { *(colsPtr++) = e; });

matlab::data::SparseArray<double> arr =
    factory.createSparseArray<double>({ 2,9 }, nnz, std::move(data_p),
        std::move(rows_p), std::move(cols_p));
return 0;

}

createEmptyArray

Descriptions

Creates an empty Array containing no elements.

Throws

createBuffer

template buffer_ptr_t createBuffer(size_t numberOfElements)

Description

Creates an uninitialized buffer to pass to thecreateArrayFromBuffer method.

Parameters

Returns

Throws

createArrayFromBuffer

template TypedArray createArrayFromBuffer(ArrayDimensions dims, buffer_ptr_t buffer, MemoryLayout memoryLayout = MemoryLayout::COLUMN_MAJOR)

Description

Creates a TypedArray<T> using the given buffer. You can specify a custom deleter function of typebuffer_deleter_t to manage the buffer. (since R2024b)

Parameters

Throws

Version History

Introduced in R2017b