Skip to content

README.md

Latest commit

 

History

History
365 lines (244 loc) · 12 KB

README.md

File metadata and controls

365 lines (244 loc) · 12 KB

dlaswp

Perform a series of row interchanges on an input matrix.

Usage

var dlaswp = require( '@stdlib/lapack/base/dlaswp' );

dlaswp( N, A, LDA, k1, k2, IPIV, incx )

Performs a series of row interchanges on an input matrix A using pivot indices stored in IPIV.

var Int32Array = require( '@stdlib/array/int32' );
var Float64Array = require( '@stdlib/array/float64' );

var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
var IPIV = new Int32Array( [ 2, 0, 1 ] );

dlaswp( 'row-major', 2, A, 2, 0, 2, IPIV, 1 );
// A => <Float64Array>[ 3.0, 4.0, 1.0, 2.0, 5.0, 6.0 ]

The function has the following parameters:

  • order: storage layout.
  • N: number of columns in A.
  • A: input matrix stored in linear memory as a Float64Array.
  • LDA: stride of the first dimension of A (a.k.a., leading dimension of the matrix A).
  • k1: index of first row to interchange when incx is positive and the index of the last row to interchange when incx is negative.
  • k2: index of last row to interchange when incx is positive and the index of the first row to interchange when incx is negative.
  • IPIV: vector of pivot indices as an Int32Array. Must contain at least k1+(k2-k1)*abs(incx) elements. Only the elements in positions k1 through k1+(k2-k1)*abs(incx) are accessed.
  • incx: increment between successive values of IPIV. Elements from IPIV are accessed according to IPIV[k1+(k-k1)*abs(incx)] = j, thus implying that rows k and j should be interchanged. If incx is negative, the pivots are applied in reverse order.

The sign of the increment parameter incx determines the order in which pivots are applied. For example, to apply pivots in reverse order,

var Int32Array = require( '@stdlib/array/int32' );
var Float64Array = require( '@stdlib/array/float64' );

var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
var IPIV = new Int32Array( [ 2, 0, 1 ] );

dlaswp( 'row-major', 2, A, 2, 0, 2, IPIV, -1 );
// A => <Float64Array>[ 3.0, 4.0, 1.0, 2.0, 5.0, 6.0 ]

To perform strided access over IPIV, provide an abs(incx) value greater than one. For example, to access every other element in IPIV,

var Int32Array = require( '@stdlib/array/int32' );
var Float64Array = require( '@stdlib/array/float64' );

var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
var IPIV = new Int32Array( [ 2, 999, 0, 999, 1 ] );

dlaswp( 'row-major', 2, A, 2, 0, 2, IPIV, 2 );
// A => <Float64Array>[ 3.0, 4.0, 1.0, 2.0, 5.0, 6.0 ]

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

var Int32Array = require( '@stdlib/array/int32' );
var Float64Array = require( '@stdlib/array/float64' );

// Initial arrays...
var A0 = new Float64Array( [ 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
var IPIV0 = new Int32Array( [ 0, 2, 0, 1] );

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

dlaswp( 'row-major', 2, A1, 2, 0, 2, IPIV1, 1 );
// A0 => <Float64Array>[ 0.0, 3.0, 4.0, 1.0, 2.0, 5.0, 6.0 ]

dlaswp.ndarray( N, A, sa1, sa2, oa, k1, k2, inck, IPIV, si, oi )

Performs a series of row interchanges on the matrix A using pivot indices stored in IPIV and alternative indexing semantics.

var Int32Array = require( '@stdlib/array/int32' );
var Float64Array = require( '@stdlib/array/float64' );

var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
var IPIV = new Int32Array( [ 2, 0, 1 ] );

dlaswp.ndarray( 2, A, 2, 1, 0, 0, 2, 1, IPIV, 1, 0 );
// A => <Float64Array>[ 3.0, 4.0, 1.0, 2.0, 5.0, 6.0 ]

The function has the following additional parameters:

  • N: number of columns in A.
  • A: input matrix stored in linear memory as a Float64Array.
  • sa1: stride of the first dimension of A.
  • sa2: stride of the second dimension of A.
  • oa: starting index for A.
  • k1: index of first row to interchange when inck is positive and the index of the last row to interchange when inck is negative.
  • k2: index of last row to interchange when inck is positive and the index of the first row to interchange when inck is negative.
  • inck: direction in which to apply pivots (-1 to apply pivots in reverse order; otherwise, apply in provided order).
  • IPIV: vector of pivot indices as an Int32Array.
  • si: index increment for IPIV.
  • oi: starting index for IPIV.

While typed array views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example,

var Int32Array = require( '@stdlib/array/int32' );
var Float64Array = require( '@stdlib/array/float64' );

var A = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
var IPIV = new Int32Array( [ 0, 0, 2, 0, 1 ] );

dlaswp.ndarray( 2, A, 2, 1, 4, 0, 2, 1, IPIV, 1, 2 );
// A => <Float64Array>[ 0.0, 0.0, 0.0, 0.0, 3.0, 4.0, 1.0, 2.0, 5.0, 6.0 ]

Notes

  • Both functions access k2-k1+1 elements from IPIV.
  • While dlaswp conflates the order in which pivots are applied with the order in which elements in IPIV are accessed, the ndarray method delineates control of those behaviors with separate parameters inck and si.
  • dlaswp() corresponds to the LAPACK function dlaswp.

Examples

var Float64Array = require( '@stdlib/array/float64' );
var Int32Array = require( '@stdlib/array/int32' );
var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
var dlaswp = require( '@stdlib/lapack/base/dlaswp' );

// Specify matrix meta data:
var shape = [ 4, 2 ];
var strides = [ 1, 4 ];
var offset = 0;
var order = 'column-major';

// Create a matrix stored in linear memory:
var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
console.log( ndarray2array( A, shape, strides, offset, order ) );

// Define a vector of pivot indices:
var IPIV = new Int32Array( [ 2, 0, 3, 1 ] );

// Interchange rows:
dlaswp( order, shape[ 1 ], A, strides[ 1 ], 0, shape[ 0 ]-1, IPIV, 1 );
console.log( ndarray2array( A, shape, strides, offset, order ) );

C APIs

Usage

#include "stdlib/lapack/base/dlaswp.h"

c_dlaswp( layout, N, *A, LDA, k1, k2, *IPIV, incx )

Performs a series of row interchanges on a matrix A using pivot indices stored in IPIV.

#include "stdlib/lapack/base/shared.h"

double A[ 3*2 ] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
const LAPACK_INT IPIV[ 3 ] = { 2, 0, 1 };

c_dlaswp( LAPACK_ROW_MAJOR, 2, A, 2, 0, 2, IPIV, 1 );

The function accepts the following arguments:

  • layout: [in] LAPACK_LAYOUT storage layout.
  • N: [in] LAPACK_INT number of columns in A.
  • A: [inout] double* input matrix.
  • LDA: [in] LAPACK_INT stride of the first dimension of A (a.k.a., leading dimension of the matrix A).
  • k1: [in] LAPACK_INT index of first row to interchange.
  • k2: [in] LAPACK_INT index of last row to interchange.
  • IPIV: [in] LAPACK_INT* vector of pivot indices.
  • incx: [in] LAPACK_INT increment between successive values of IPIV.
void c_dlaswp( const LAPACK_LAYOUT layout, const LAPACK_INT N, double *A, const LAPACK_INT LDA, const LAPACK_INT k1, const LAPACK_INT k2, const LAPACK_INT *IPIV, const LAPACK_INT incx );

c_dlaswp_ndarray( N, *A, sa1, sa2, oa, k1, k2, inck, *IPIV, si, oi )

Performs a series of row interchanges on a matrix A using pivot indices stored in IPIV and alternative indexing semantics.

#include "stdlib/lapack/base/shared.h"

double A[ 3*2 ] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
const LAPACK_INT IPIV[ 3 ] = { 2, 0, 1 };

c_dlaswp_ndarray( 2, A, 2, 1, 0, 0, 2, 1, IPIV, 1, 0 );

The function accepts the following arguments:

  • N: [in] LAPACK_INT number of columns in A.
  • A: [inout] double* input matrix.
  • sa1: [in] LAPACK_INT stride of the first dimension of A.
  • sa2: [in] LAPACK_INT stride of the second dimension of A.
  • oa: [in] LAPACK_INT starting index for A.
  • k1: [in] LAPACK_INT index of first row to interchange.
  • k2: [in] LAPACK_INT index of last row to interchange.
  • inck: [in] LAPACK_INT direction in which to apply pivots (-1 to apply pivots in reverse order; otherwise, apply in provided order).
  • IPIV: [in] LAPACK_INT* vector of pivot indices.
  • si: [in] LAPACK_INT index increment for IPIV.
  • oi: [in] LAPACK_INT starting index for IPIV.
void c_dlaswp_ndarray( const LAPACK_INT N, double *A, const LAPACK_INT strideA1, const LAPACK_INT strideA2, const LAPACK_INT offsetA, const LAPACK_INT k1, const LAPACK_INT k2, const LAPACK_INT inck, const LAPACK_INT *IPIV, const LAPACK_INT strideIPIV, const LAPACK_INT offsetIPIV );

Examples

#include "stdlib/lapack/base/dlaswp.h"
#include "stdlib/lapack/base/shared.h"
#include <stdio.h>

int main( void ) {
    // Define a 3x3 matrix stored in row-major order:
    double A[ 3*3 ] = {
        1.0, 2.0, 3.0,
        4.0, 5.0, 6.0,
        7.0, 8.0, 9.0
    };

    // Define a vector of pivot indices:
    const LAPACK_INT IPIV[ 3 ] = { 2, 0, 1 };

    // Specify the number of columns:
    const int N = 3;

    // Perform row interchanges:
    c_dlaswp( LAPACK_ROW_MAJOR, N, A, N, 0, 2, IPIV, 1 );

    // Print the result:
    for ( int i = 0; i < 3; i++ ) {
        for ( int j = 0; j < N; j++ ) {
            printf( "A[ %i, %i ] = %lf\n", i, j, A[ (i*N)+j ] );
        }
    }
}