Skip to content

README.md

Latest commit

 

History

History
454 lines (309 loc) · 14.9 KB

README.md

File metadata and controls

454 lines (309 loc) · 14.9 KB

cindexOfRow

Return the index of the first row in a single-precision complex floating-point input matrix which has the same elements as a provided search vector.

Usage

var cindexOfRow = require( '@stdlib/blas/ext/base/cindex-of-row' );

cindexOfRow( order, M, N, A, LDA, x, strideX, workspace, strideW )

Returns the index of the first row in a single-precision complex floating-point input matrix which has the same elements as a provided search vector.

var Complex64Array = require( '@stdlib/array/complex64' );
var Uint8Array = require( '@stdlib/array/uint8' );

/*
    A = [
        [ 1+0i, 3+0i ],
        [ 2+0i, 4+0i ]
    ]
*/
var A = new Complex64Array( [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] );

var x = new Complex64Array( [ 2.0, 0.0, 4.0, 0.0 ] );
var workspace = new Uint8Array( 2 );
var out = cindexOfRow( 'column-major', 2, 2, A, 2, x, 1, workspace, 1 );
// returns 1

The function has the following parameters:

  • order: storage layout.
  • M: number of rows in A.
  • N: number of columns in A.
  • A: input matrix stored as a Complex64Array.
  • LDA: stride of the first dimension of A (a.k.a., leading dimension of the matrix A).
  • x: search vector stored as a Complex64Array.
  • strideX: stride length of x.
  • workspace: workspace array stored as a Uint8Array for tracking row match candidates. This parameter is ignored if the function is provided an input matrix stored in row-major order.
  • strideW: stride length of workspace.

When an input matrix is stored in row-major order, the workspace parameter is ignored, and, thus, one may provide an empty workspace array.

var Complex64Array = require( '@stdlib/array/complex64' );
var Uint8Array = require( '@stdlib/array/uint8' );

/*
    A = [
        [ 1+0i, 2+0i ],
        [ 3+0i, 4+0i ]
    ]
*/
var A = new Complex64Array( [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] );

var x = new Complex64Array( [ 3.0, 0.0, 4.0, 0.0 ] );
var workspace = new Uint8Array( 0 );
var out = cindexOfRow( 'row-major', 2, 2, A, 2, x, 1, workspace, 1 );
// returns 1

If the function is unable to find a matching row, the function returns -1.

var Complex64Array = require( '@stdlib/array/complex64' );
var Uint8Array = require( '@stdlib/array/uint8' );

/*
    A = [
        [ 1+0i, 3+0i ],
        [ 2+0i, 4+0i ]
    ]
*/
var A = new Complex64Array( [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] );

var x = new Complex64Array( [ -3.0, 0.0, -4.0, 0.0 ] );
var workspace = new Uint8Array( 2 );
var out = cindexOfRow( 'column-major', 2, 2, A, 2, x, 1, workspace, 1 );
// returns -1

Note that indexing is relative to the first index. To introduce an offset, use typed array views.

var Complex64Array = require( '@stdlib/array/complex64' );
var Uint8Array = require( '@stdlib/array/uint8' );

// Initial arrays:
var A0 = new Complex64Array( [ 0.0, 0.0, 3.0, 0.0, 4.0, 0.0, 0.0, 0.0 ] );
var x0 = new Complex64Array( [ 0.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] );

// Create offset views:
var A1 = new Complex64Array( A0.buffer, A0.BYTES_PER_ELEMENT*1 );
var x1 = new Complex64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );

var workspace = new Uint8Array( 0 );
var out = cindexOfRow( 'row-major', 1, 2, A1, 2, x1, 1, workspace, 1 );
// returns 0

cindexOfRow.ndarray( M, N, A, strideA1, strideA2, offsetA, x, strideX, offsetX, workspace, strideW, offsetW )

Returns the index of the first row in a single-precision complex floating-point input matrix which has the same elements as a provided search vector using alternative indexing semantics.

var Complex64Array = require( '@stdlib/array/complex64' );
var Uint8Array = require( '@stdlib/array/uint8' );

/*
    A = [
        [ 1+0i, 3+0i ],
        [ 2+0i, 4+0i ]
    ]
*/
var A = new Complex64Array( [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] );

var x = new Complex64Array( [ 2.0, 0.0, 4.0, 0.0 ] );
var workspace = new Uint8Array( 2 );
var out = cindexOfRow.ndarray( 2, 2, A, 1, 2, 0, x, 1, 0, workspace, 1, 0 );
// returns 1

The function has the following parameters:

  • M: number of rows in A.
  • N: number of columns in A.
  • A: input matrix stored as a Complex64Array.
  • strideA1: stride of the first dimension of A.
  • strideA2: stride of the second dimension of A.
  • offsetA: starting index for A.
  • x: search vector stored as a Complex64Array.
  • strideX: stride length of x.
  • offsetX: starting index for x.
  • workspace: workspace array stored as a Uint8Array for tracking row match candidates. This parameter is ignored if the function is provided an input matrix stored in row-major order.
  • strideW: stride length of workspace.
  • offsetW: starting index for workspace.

When an input matrix is stored in row-major order, the workspace parameter is ignored, and, thus, one may provide an empty workspace array.

var Complex64Array = require( '@stdlib/array/complex64' );
var Uint8Array = require( '@stdlib/array/uint8' );

/*
    A = [
        [ 1+0i, 2+0i ],
        [ 3+0i, 4+0i ]
    ]
*/
var A = new Complex64Array( [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] );

var x = new Complex64Array( [ 3.0, 0.0, 4.0, 0.0 ] );
var workspace = new Uint8Array( 0 );
var out = cindexOfRow.ndarray( 2, 2, A, 2, 1, 0, x, 1, 0, workspace, 1, 0 );
// returns 1

Notes

  • When searching for a matching row, the function checks for equality using the strict equality operator ===. As a consequence, NaN values are considered distinct, and -0 and +0 are considered the same.

Examples

var Complex64Array = require( '@stdlib/array/complex64' );
var Uint8Array = require( '@stdlib/array/uint8' );
var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
var cindexOfRow = require( '@stdlib/blas/ext/base/cindex-of-row' );

var shape = [ 2, 2 ];
var order = 'row-major';
var strides = shape2strides( shape, order );

var A = new Complex64Array( [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] );
console.log( ndarray2array( A, shape, strides, 0, order ) );

var x = new Complex64Array( [ 3.0, 0.0, 4.0, 0.0 ] );
console.log( x );

var workspace = new Uint8Array( shape[ 0 ] );

var out = cindexOfRow( order, shape[ 0 ], shape[ 1 ], A, strides[ 0 ], x, 1, workspace, 1 );
console.log( out );

C APIs

Usage

#include "stdlib/blas/ext/base/cindex_of_row.h"

stdlib_strided_cindex_of_row( order, M, N, *A, LDA, *X, strideX, *workspace, strideW )

Returns the index of the first row in a single-precision complex floating-point input matrix which has the same elements as a provided search vector.

#include "stdlib/complex/float32/ctor.h"
#include "stdlib/blas/base/shared.h"
#include <stdint.h>

const float A[] = { 1.0f, 0.0f, 2.0f, 0.0f, 0.0f, 0.0f, 3.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f };
const float x[] = { 2.0f, 0.0f, 4.0f, 0.0f };
uint8_t workspace[ 3 ];

int idx = stdlib_strided_cindex_of_row( CblasColMajor, 3, 2, (const stdlib_complex64_t *)A, 3, (const stdlib_complex64_t *)x, 1, workspace, 1 );
// returns 1

The function accepts the following arguments:

  • order: [in] CBLAS_LAYOUT storage layout.
  • M: [in] CBLAS_INT number of rows in A.
  • N: [in] CBLAS_INT number of columns in A.
  • A: [in] stdlib_complex64_t* input matrix.
  • LDA: [in] CBLAS_INT stride of the first dimension of A (a.k.a., leading dimension of the matrix A).
  • X: [in] stdlib_complex64_t* search vector.
  • strideX: [in] CBLAS_INT stride length for X.
  • workspace: [inout] uint8_t* workspace array for tracking row match candidates. This parameter is ignored if the function is provided an input matrix stored in row-major order.
  • strideW: [in] CBLAS_INT stride length for workspace.

When an input matrix is stored in row-major order, the workspace parameter is ignored, and, thus, one may either provide an empty workspace array or a NULL pointer.

#include "stdlib/complex/float32/ctor.h"
#include "stdlib/blas/base/shared.h"

const float A[] = { 1.0f, 0.0f, 2.0f, 0.0f, 3.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
const float x[] = { 3.0f, 0.0f, 4.0f, 0.0f };

int idx = stdlib_strided_cindex_of_row( CblasRowMajor, 3, 2, (const stdlib_complex64_t *)A, 2, (const stdlib_complex64_t *)x, 1, NULL, 1 );
// returns 1
CBLAS_INT stdlib_strided_cindex_of_row( const CBLAS_LAYOUT order, const CBLAS_INT M, const CBLAS_INT N, const stdlib_complex64_t *A, const CBLAS_INT LDA, const stdlib_complex64_t *X, const CBLAS_INT strideX, uint8_t *workspace, const CBLAS_INT strideW );

stdlib_strided_cindex_of_row_ndarray( M, N, *A, strideA1, strideA2, offsetA, *X, strideX, offsetX, *workspace, strideW, offsetW )

Returns the index of the first row in a single-precision complex floating-point input matrix which has the same elements as a provided search vector using alternative indexing semantics.

#include "stdlib/complex/float32/ctor.h"
#include <stdint.h>

const float A[] = { 1.0f, 0.0f, 2.0f, 0.0f, 0.0f, 0.0f, 3.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f };
const float x[] = { 2.0f, 0.0f, 4.0f, 0.0f };
uint8_t workspace[ 3 ];

int idx = stdlib_strided_cindex_of_row_ndarray( 3, 2, (const stdlib_complex64_t *)A, 1, 3, 0, (const stdlib_complex64_t *)x, 1, 0, workspace, 1, 0 );
// returns 1

The function accepts the following arguments:

  • M: [in] CBLAS_INT number of rows in A.
  • N: [in] CBLAS_INT number of columns in A.
  • A: [in] stdlib_complex64_t* input matrix.
  • strideA1: [in] CBLAS_INT stride of the first dimension of A.
  • strideA2: [in] CBLAS_INT stride of the second dimension of A.
  • offsetA: [in] CBLAS_INT index offset for A.
  • X: [in] stdlib_complex64_t* search vector.
  • strideX: [in] CBLAS_INT stride length for X.
  • offsetX: [in] CBLAS_INT starting index for X.
  • workspace: [inout] uint8_t* workspace array for tracking row match candidates. This parameter is ignored if the function is provided an input matrix stored in row-major order.
  • strideW: [in] CBLAS_INT stride length for workspace.
  • offsetW: [in] CBLAS_INT starting index for workspace.

When an input matrix is stored in row-major order, the workspace parameter is ignored, and, thus, one may either provide an empty workspace array or a NULL pointer.

#include "stdlib/complex/float32/ctor.h"

const float A[] = { 1.0f, 0.0f, 2.0f, 0.0f, 3.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
const float x[] = { 3.0f, 0.0f, 4.0f, 0.0f };

int idx = stdlib_strided_cindex_of_row_ndarray( 3, 2, (const stdlib_complex64_t *)A, 2, 1, 0, (const stdlib_complex64_t *)x, 1, 0, NULL, 1, 0 );
// returns 1
CBLAS_INT stdlib_strided_cindex_of_row_ndarray( const CBLAS_INT M, const CBLAS_INT N, const stdlib_complex64_t *A, const CBLAS_INT strideA1, const CBLAS_INT strideA2, const CBLAS_INT offsetA, const stdlib_complex64_t *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, uint8_t *workspace, const CBLAS_INT strideW, const CBLAS_INT offsetW );

Examples

#include "stdlib/blas/ext/base/cindex_of_row.h"
#include "stdlib/complex/float32/ctor.h"
#include "stdlib/blas/base/shared.h"
#include <stdio.h>

int main( void ) {
    // Create a matrix (row-major, 2x2, interleaved real and imaginary components):
    const float A[] = { 1.0f, 0.0f, 2.0f, 0.0f, 3.0f, 0.0f, 4.0f, 0.0f };

    // Create a search vector (interleaved real and imaginary components):
    const float x[] = { 3.0f, 0.0f, 4.0f, 0.0f };

    // Specify the number of matrix rows and columns:
    const int M = 2;
    const int N = 2;

    // Perform a search:
    int idx = stdlib_strided_cindex_of_row( CblasRowMajor, M, N, (const stdlib_complex64_t *)A, N, (const stdlib_complex64_t *)x, 1, NULL, 1 );

    // Print the result:
    printf( "index value: %d\n", idx );
}