Skip to content

README.md

Latest commit

 

History

History
450 lines (306 loc) · 14.1 KB

README.md

File metadata and controls

450 lines (306 loc) · 14.1 KB

dindexOfRow

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

Usage

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

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

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

var Float64Array = require( '@stdlib/array/float64' );
var Uint8Array = require( '@stdlib/array/uint8' );

/*
    A = [
        [ 1.0, 3.0 ],
        [ 2.0, 4.0 ],
        [ 0.0, 0.0 ]
    ]
*/
var A = new Float64Array( [ 1.0, 2.0, 0.0, 3.0, 4.0, 0.0 ] );

var x = new Float64Array( [ 2.0, 4.0 ] );
var workspace = new Uint8Array( 3 );
var out = dindexOfRow( 'column-major', 3, 2, A, 3, 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 Float64Array.
  • LDA: stride of the first dimension of A (a.k.a., leading dimension of the matrix A).
  • x: search vector stored as a Float64Array.
  • 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 Float64Array = require( '@stdlib/array/float64' );
var Uint8Array = require( '@stdlib/array/uint8' );

/*
    A = [
        [ 1.0, 2.0 ],
        [ 3.0, 4.0 ],
        [ 0.0, 0.0 ]
    ]
*/
var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 0.0, 0.0 ] );

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

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

var Float64Array = require( '@stdlib/array/float64' );
var Uint8Array = require( '@stdlib/array/uint8' );

/*
    A = [
        [ 1.0, 3.0 ],
        [ 2.0, 4.0 ],
        [ 0.0, 0.0 ]
    ]
*/
var A = new Float64Array( [ 1.0, 2.0, 0.0, 3.0, 4.0, 0.0 ] );

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

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

var Float64Array = require( '@stdlib/array/float64' );
var Uint8Array = require( '@stdlib/array/uint8' );

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

// Create offset views:
var A1 = new Float64Array( A0.buffer, A0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element

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

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

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

var Float64Array = require( '@stdlib/array/float64' );
var Uint8Array = require( '@stdlib/array/uint8' );

/*
    A = [
        [ 1.0, 3.0 ],
        [ 2.0, 4.0 ],
        [ 0.0, 0.0 ]
    ]
*/
var A = new Float64Array( [ 1.0, 2.0, 0.0, 3.0, 4.0, 0.0 ] );

var x = new Float64Array( [ 2.0, 4.0 ] );
var workspace = new Uint8Array( 3 );
var out = dindexOfRow.ndarray( 3, 2, A, 1, 3, 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 Float64Array.
  • 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 Float64Array.
  • 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 Float64Array = require( '@stdlib/array/float64' );
var Uint8Array = require( '@stdlib/array/uint8' );

var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 0.0, 0.0 ] );

var x = new Float64Array( [ 3.0, 4.0 ] );
var workspace = new Uint8Array( 0 );
var out = dindexOfRow.ndarray( 3, 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 Float64Array = require( '@stdlib/array/float64' );
var Uint8Array = require( '@stdlib/array/uint8' );
var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
var dindexOfRow = require( '@stdlib/blas/ext/base/dindex-of-row' );

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

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

var x = new Float64Array( [ 4.0, 5.0, 6.0 ] );
console.log( x );

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

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

C APIs

Usage

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

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

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

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

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

int idx = stdlib_strided_dindex_of_row( CblasColMajor, 3, 2, A, 3, 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] double* input matrix.
  • LDA: [in] CBLAS_INT stride of the first dimension of A (a.k.a., leading dimension of the matrix A).
  • X: [in] double* 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/blas/base/shared.h"

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

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

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

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

#include <stdint.h>

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

int idx = stdlib_strided_dindex_of_row_ndarray( 3, 2, A, 1, 3, 0, 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] double* 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] double* 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.

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

int idx = stdlib_strided_dindex_of_row_ndarray( 3, 2, A, 2, 1, 0, x, 1, 0, NULL, 1, 0 );
// returns 1
CBLAS_INT stdlib_strided_dindex_of_row_ndarray( const CBLAS_INT M, const CBLAS_INT N, const double *A, const CBLAS_INT strideA1, const CBLAS_INT strideA2, const CBLAS_INT offsetA, const double *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/dindex_of_row.h"
#include "stdlib/blas/base/shared.h"
#include <stdio.h>

int main( void ) {
    // Create a matrix (row-major):
    const double A[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.0, 0.0, 0.0 };

    // Create a search vector:
    const double x[] = { 4.0, 5.0, 6.0 };

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

    // Perform a search:
    int idx = stdlib_strided_dindex_of_row( CblasRowMajor, M, N, A, N, x, 1, NULL, 1 );

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