dspm Namespace Reference

DSP matrix namespace. More...

Data Structures
class	Mat
	Matrix. More...

Functions
std::ostream &	operator<< (std::ostream &os, const Mat &m)
std::ostream &	operator<< (std::ostream &os, const Mat::Rect &rect)
std::istream &	operator>> (std::istream &is, Mat &m)
Mat	operator+ (const Mat &A, const Mat &B)
Mat	operator+ (const Mat &A, float C)
Mat	operator- (const Mat &A, const Mat &B)
Mat	operator- (const Mat &A, float C)
Mat	operator* (const Mat &A, const Mat &B)
Mat	operator* (const Mat &A, float C)
Mat	operator* (float C, const Mat &A)
Mat	operator/ (const Mat &A, float C)
Mat	operator/ (const Mat &A, const Mat &B)
bool	operator== (const Mat &A, const Mat &B)
ostream &	operator<< (ostream &os, const Mat &m)
ostream &	operator<< (ostream &os, const Mat::Rect &rect)
istream &	operator>> (istream &is, Mat &m)

Detailed Description

DSP matrix namespace.

DSP library matrix namespace.

Function Documentation

operator*() [1/3]

Mat dspm::operator*	(	const Mat &	A,
		const Mat &	B )

• operator, multiplication of two matrices. The operator use DSP optimized implementation of multiplication.

Parameters

[in]	A	Input matrix A
[in]	B	Input matrix B

Returns

• result matrix A*B

Definition at line 933 of file mat.cpp.

{
    if (m1.cols != m2.rows) {
        ESP_LOGW("Mat", "operator * Error: matrices do not have correct dimensions");
        Mat err_ret;
        return err_ret;
    }
    Mat temp(m1.rows, m2.cols);
 
    if (m1.sub_matrix || m2.sub_matrix) {
        dspm_mult_ex_f32(m1.data, m2.data, temp.data, m1.rows, m1.cols, m2.cols, m1.padding, m2.padding, temp.padding);
    } else {
        dspm_mult_f32(m1.data, m2.data, temp.data, m1.rows, m1.cols, m2.cols);
    }
 
    return temp;
 
}

References dspm::Mat::cols, dspm::Mat::data, dspm_mult_ex_f32, dspm_mult_f32, dspm::Mat::padding, dspm::Mat::rows, and dspm::Mat::sub_matrix.

operator*() [2/3]

Mat dspm::operator*	(	const Mat &	A,
		float	C )

• operator, multiplication of matrix with constant The operator use DSP optimized implementation of multiplication.

Parameters

[in]	A	Input matrix A
[in]	C	floating point value

Returns

• result matrix A*B

Definition at line 952 of file mat.cpp.

{
    if (m.sub_matrix) {
        Mat temp(m.rows, m.cols);
        dspm_mulc_f32(m.data, temp.data, num, m.rows, m.cols, m.padding, temp.padding, 1, 1);
        return temp;
    } else {
        Mat temp(m);
        return (temp *= num);
    }
}

References dspm::Mat::data, dspm_mulc_f32, m, and dspm::Mat::padding.

operator*() [3/3]

Mat dspm::operator*	(	float	C,
		const Mat &	A )

• operator, multiplication of matrix with constant The operator use DSP optimized implementation of multiplication.

Parameters

[in]	C	floating point value
[in]	A	Input matrix A

Returns

• result matrix A*B

Definition at line 964 of file mat.cpp.

{
    return (m * num);
}

References m.

operator+() [1/2]

Mat dspm::operator+	(	const Mat &	A,
		const Mat &	B )

• operator, sum of two matrices The operator use DSP optimized implementation of multiplication.

Parameters

[in]	A	Input matrix A
[in]	B	Input matrix B

Returns

• result matrix A+B

Definition at line 855 of file mat.cpp.

{
    if ((m1.rows != m2.rows) || (m1.cols != m2.cols)) {
        ESP_LOGW("Mat", "operator + Error: matrices do not have equal dimensions");
        Mat err_ret;
        return err_ret;
    }
 
    if (m1.sub_matrix || m2.sub_matrix) {
        Mat temp(m1.rows, m2.cols);
        dspm_add_f32(m1.data, m2.data, temp.data, m1.rows, m1.cols, m1.padding, m2.padding, temp.padding, 1, 1, 1);
        return temp;
    } else {
        Mat temp(m1);
        return (temp += m2);
    }
}

References dspm::Mat::cols, dspm::Mat::data, dspm_add_f32, dspm::Mat::padding, dspm::Mat::rows, and dspm::Mat::sub_matrix.

operator+() [2/2]

Mat dspm::operator+	(	const Mat &	A,
		float	C )

• operator, sum of matrix with constant The operator use DSP optimized implementation of multiplication.

Parameters

[in]	A	Input matrix A
[in]	C	Input constant

Returns

• result matrix A+C

Definition at line 873 of file mat.cpp.

{
    if (m.sub_matrix) {
        Mat temp(m.rows, m.cols);
        dspm_addc_f32(m.data, temp.data, C, m.rows, m.cols, m.padding, temp.padding, 1, 1);
        return temp;
    } else {
        Mat temp(m);
        return (temp += C);
    }
}

References C, dspm::Mat::data, dspm_addc_f32, m, and dspm::Mat::padding.

operator-() [1/2]

Mat dspm::operator-	(	const Mat &	A,
		const Mat &	B )

• operator, subtraction of two matrices The operator use DSP optimized implementation of multiplication.

Parameters

[in]	A	Input matrix A
[in]	B	Input matrix B

Returns

• result matrix A-B

Definition at line 903 of file mat.cpp.

{
    if ((m1.rows != m2.rows) || (m1.cols != m2.cols)) {
        ESP_LOGW("Mat", "operator - Error: matrices do not have equal dimensions");
        Mat err_ret;
        return err_ret;
    }
 
    if (m1.sub_matrix || m2.sub_matrix) {
        Mat temp(m1.rows, m1.cols);
        dspm_sub_f32(m1.data, m2.data, temp.data, m1.rows, m1.cols, m1.padding, m2.padding, temp.padding, 1, 1, 1);
        return temp;
    } else {
        Mat temp(m1);
        return (temp -= m2);
    }
}

References dspm::Mat::cols, dspm::Mat::data, dspm_sub_f32, dspm::Mat::padding, dspm::Mat::rows, and dspm::Mat::sub_matrix.

operator-() [2/2]

Mat dspm::operator-	(	const Mat &	A,
		float	C )

• operator, sum of matrix with constant The operator use DSP optimized implementation of multiplication.

Parameters

[in]	A	Input matrix A
[in]	C	Input constant

Returns

• result matrix A+C

Definition at line 921 of file mat.cpp.

{
    if (m.sub_matrix) {
        Mat temp(m.rows, m.cols);
        dspm_addc_f32(m.data, temp.data, -C, m.rows, m.cols, m.padding, temp.padding, 1, 1);
        return temp;
    } else {
        Mat temp(m);
        return (temp -= C);
    }
}

References C, dspm::Mat::data, dspm_addc_f32, m, and dspm::Mat::padding.

operator/() [1/2]

Mat dspm::operator/	(	const Mat &	A,
		const Mat &	B )

/ operator, divide matrix A by matrix B

Parameters

[in]	A	Input matrix A
[in]	B	Input matrix B

Returns

• result matrix C, where C[i,j] = A[i,j]/B[i,j]

Definition at line 981 of file mat.cpp.

{
    if ((A.rows != B.rows) || (A.cols != B.cols)) {
        ESP_LOGW("Mat", "Operator + Error: matrices do not have equal dimensions");
        Mat err_ret;
        return err_ret;
    }
 
    Mat temp(A.rows, A.cols);
    for (int row = 0; row < A.rows; row++) {
        for (int col = 0; col < A.cols; col++) {
            temp(row, col) = A(row, col) / B(row, col);
        }
    }
    return temp;
}

References A, and B.

operator/() [2/2]

Mat dspm::operator/	(	const Mat &	A,
		float	C )

/ operator, divide of matrix by constant The operator use DSP optimized implementation of multiplication.

Parameters

[in]	A	Input matrix A
[in]	C	floating point value

Returns

• result matrix A*B

Definition at line 969 of file mat.cpp.

{
    if (m.sub_matrix) {
        Mat temp(m.rows, m.cols);
        dspm_mulc_f32(m.data, temp.data, 1 / num, m.rows, m.cols, m.padding, temp.padding, 1, 1);
        return temp;
    } else {
        Mat temp(m);
        return (temp /= num);
    }
}

References dspm::Mat::data, dspm_mulc_f32, m, and dspm::Mat::padding.

operator<<() [1/4]

ostream & dspm::operator<<	(	ostream &	os,
		const Mat &	m )

Definition at line 998 of file mat.cpp.

{
    for (int i = 0; i < m.rows; ++i) {
        os << m(i, 0);
        for (int j = 1; j < m.cols; ++j) {
            os << " " << m(i, j);
        }
        os << endl;
    }
    return os;
}

References m.

operator<<() [2/4]

ostream & dspm::operator<<	(	ostream &	os,
		const Mat::Rect &	rect )

Definition at line 1010 of file mat.cpp.

{
    os << "row start " << rect.y << endl;
    os << "col start " << rect.x << endl;
    os << "row count " << rect.height << endl;
    os << "col count " << rect.width << endl;
 
    return os;
}

References dspm::Mat::Rect::height, dspm::Mat::Rect::width, dspm::Mat::Rect::x, and dspm::Mat::Rect::y.

operator<<() [3/4]

std::ostream & dspm::operator<<	(	std::ostream &	os,
		const Mat &	m )

Print matrix to the standard iostream.

Parameters

[in]	os	output stream
[in]	m	matrix to print

Returns

• output stream

References m.

operator<<() [4/4]

std::ostream & dspm::operator<<	(	std::ostream &	os,
		const Mat::Rect &	rect )

Print rectangular ROI to the standard iostream.

Parameters

[in]	os	output stream
[in]	rect	ROI

Returns

• output stream

operator==()

bool dspm::operator==	(	const Mat &	A,
		const Mat &	B )

== operator, compare two matrices

Parameters

[in]	A	Input matrix A
[in]	B	Input matrix B

Returns

• true if matrices are the same
• false if matrices are different

Definition at line 885 of file mat.cpp.

{
    if ((m1.cols != m2.cols) || (m1.rows != m2.rows)) {
        return false;
    }
 
    for (int row = 0; row < m1.rows; row++) {
        for (int col = 0; col < m1.cols; col++) {
            if (m1(row, col) != m2(row, col)) {
                ESP_LOGW("Mat", "operator == Error: %i %i, m1.data=%f, m2.data=%f \n", row, col, m1(row, col), m2(row, col));
                return false;
            }
        }
    }
 
    return true;
}

References dspm::Mat::cols, and dspm::Mat::rows.

operator>>() [1/2]

istream & dspm::operator>>	(	istream &	is,
		Mat &	m )

Definition at line 1020 of file mat.cpp.

{
    for (int i = 0; i < m.rows; ++i) {
        for (int j = 0; j < m.cols; ++j) {
            is >> m(i, j);
        }
    }
    return is;
}

References m.

operator>>() [2/2]

std::istream & dspm::operator>>	(	std::istream &	is,
		Mat &	m )

Fill the matrix from iostream.

Parameters

[in]	is	input stream
[in]	m	matrix to fill

Returns

• input stream

References A, B, C, and m.