Skip to content

README.md

Latest commit

 

History

History
368 lines (244 loc) · 11.3 KB

README.md

File metadata and controls

368 lines (244 loc) · 11.3 KB

dediff

Calculate the differences between consecutive elements of a double-precision floating-point strided array.

Usage

var dediff = require( '@stdlib/blas/ext/base/dediff' );

dediff( N, x, strideX, N1, prepend, strideP, N2, append, strideA, out, strideOut )

Calculates the differences between consecutive elements of a double-precision floating-point strided array.

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

var x = new Float64Array( [ 2.0, 4.0, 6.0, 8.0, 10.0 ] );
var p = new Float64Array( [ 1.0 ] );
var a = new Float64Array( [ 11.0 ] );
var out = new Float64Array( 6 );

dediff( x.length, x, 1, 1, p, 1, 1, a, 1, out, 1 );

console.log( out );
// out => <Float64Array>[ 1.0, 2.0, 2.0, 2.0, 2.0, 11.0 ]

The function has the following parameters:

  • N: number of indexed elements.
  • x: input Float64Array.
  • strideX: stride length for x.
  • N1: number of elements to prepend.
  • prepend: a Float64Array containing values to prepend after computing differences.
  • strideP: stride length for prepend.
  • N2: number of elements to append.
  • append: a Float64Array containing values to append after computing differences..
  • strideA: strides length for append.
  • out: output Float64Array. Must have N + N1 + N2 - 1 elements.
  • strideOut: stride length for out.

The N and stride parameters determine which elements in the strided array are accessed at runtime. For example, to differences of every other element:

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

var x = new Float64Array( [ 2.0, 4.0, 6.0, 8.0, 10.0 ] );
var p = new Float64Array( [ 1.0 ] );
var a = new Float64Array( [ 11.0 ] );
var out = new Float64Array( 4 );

dediff( 3, x, 2, 1, p, 1, 1, a, 1, out, 1 );

console.log( out );
// out => <Float64Array>[ 1.0, 4.0, 4.0, 11.0 ]

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

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

// Initial array...
var x0 = new Float64Array( [ 2.0, 4.0, 6.0, 8.0, 10.0 ] );

// Create an offset view...
var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element

var p = new Float64Array( [ 1.0 ] );
var a = new Float64Array( [ 11.0 ] );
var out = new Float64Array( 5 );

dediff( x1.length, x1, 1, 1, p, 1, 1, a, 1, out, 1 );

console.log( out );
// out => <Float64Array>[ 1.0, 2.0, 2.0, 2.0, 11.0 ]

dediff.ndarray( N, x, strideX, offsetX, N1, prepend, strideP, offsetP, N2, append, strideA, offsetA, out, strideOut, offsetOut )

Calculates the differences between consecutive elements of a double-precision floating-point strided array using alternative indexing semantics.

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

var x = new Float64Array( [ 2.0, 4.0, 6.0, 8.0, 10.0 ] );
var p = new Float64Array( [ 1.0 ] );
var a = new Float64Array( [ 11.0 ] );
var out = new Float64Array( 6 );

dediff.ndarray( x.length, 1, x, 1, 0, 1, p, 1, 0, 1, a, 1, 0, out, 1, 0 );

console.log( out );
// out => <Float64Array>[ 1.0, 2.0, 2.0, 2.0, 2.0, 11.0 ]

The function has the following additional parameters:

  • offsetX: starting index for x.
  • offsetP: starting index for prepend.
  • offsetA: starting index for append.
  • offsetOut: starting index for out.

While typed array views mandate a view offset based on the underlying buffer, the offset parameter supports indexing semantics based on a starting index. For example, to access only the last three elements:

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

var x = new Float64Array( [ 2.0, 4.0, 6.0, 8.0, 10.0 ] );
var p = new Float64Array( [ 1.0 ] );
var a = new Float64Array( [ 11.0 ] );
var out = new Float64Array( 4 );

dediff.ndarray( 3, x, 1, x.length-3, 1, p, 1, 0, 1, a, 1, 0, out, 1, 0 );

console.log( out );
// out => <Float64Array>[ 1.0, 2.0, 2.0, 11.0 ]

Notes

  • If N <= 0, both functions return x unchanged.

Examples

var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
var Float64Array = require( '@stdlib/array/float64' );
var dediff = require( '@stdlib/blas/ext/base/dediff' );

var x = discreteUniform( 10, -100, 100, {
    'dtype': 'float64'
});
console.log( 'Input array: ', x );

var p = discreteUniform( 2, -100, 100, {
    'dtype': 'float64'
});
console.log( 'Prepend array: ', p );

var a = discreteUniform( 2, -100, 100, {
    'dtype': 'float64'
});
console.log( 'Append array: ', a );

var out = new Float64Array( 13 );

dediff( x.length, x, 1, 2, p, 1, 2, a, 1, out, 1 );
console.log( 'Output', out );

C APIs

Usage

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

stdlib_strided_dediff( N, x, strideX, N1, prepend, strideP, N2, append, strideA, *out, strideOut )

Calculates the differences between consecutive elements of a double-precision floating-point strided array.

double x[] = { 2.0, 4.0, 6.0, 8.0, 10.0 };
double p[] = { 1.0 };
double a[] = { 11.0 };
double out[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };

stdlib_strided_dediff( 5, x, 1, 1, p, 1, 1, a, 1, out, 1 );

The function accepts the following arguments:

  • N: [in] CBLAS_INT number of indexed elements.
  • x: [in] double input Float64Array.
  • strideX: [in] CBLAS_INT stride length for x.
  • N1: [in] CBLAS_INT number of elements in prepend.
  • prepend: [in] double a Float64Array containing values to prepend after computing differences.
  • strideP: [in] CBLAS_INT stride length for prepend.
  • N2: [in] CBLAS_INT number of elements in append.
  • append: [in] double a Float64Array containing values to append after computing differences.
  • strideA: [in] CBLAS_INT strides length for append.
  • out: [in] double output Float64Array. Must have N + N1 + N2 - 1 elements.
  • strideOut: [in] CBLAS_INT stride length for out.
void stdlib_strided_dediff( const CBLAS_INT N, const double *X, const CBLAS_INT strideX, const CBLAS_INT N1, const double *prepend,  const CBLAS_INT strideP, const CBLAS_INT N2, const double *append, const CBLAS_INT strideA, double *out,  const CBLAS_INT strideOut );

stdlib_strided_dediff_ndarray( N, x, strideX, offsetX, N1, prepend, strideP, offsetP, N2, append, strideA, offsetA, *out, strideOut, offsetOut )

Calculates the differences between consecutive elements of a double-precision floating-point strided array using alternative indexing semantics.

double x[] = { 2.0, 4.0, 6.0, 8.0, 10.0 };
double p[] = { 1.0 };
double a[] = { 11.0 };
double out[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };

stdlib_strided_dediff_ndarray( 5, 1, x, 1, 0, 1, p, 1, 0, 1, a, 1, 0, out, 1, 0 );

The function accepts the following arguments:

  • N: [in] CBLAS_INT number of indexed elements.
  • x: [in] double input Float64Array.
  • strideX: [in] CBLAS_INT stride length for x.
  • offsetX: [in] CBLAS_INT starting index for x.
  • N1: [in] CBLAS_INT number of elements in prepend.
  • prepend: [in] double a Float64Array containing values to prepend after computing differences.
  • strideP: [in] CBLAS_INT stride length for prepend.
  • offsetP: [in] CBLAS_INT starting index for prepend.
  • N2: [in] CBLAS_INT number of elements in append.
  • append: [in] double a Float64Array containing values to append after computing differences.
  • strideA: [in] CBLAS_INT strides length for append.
  • offsetA: [in] CBLAS_INT starting index for append.
  • out: [in] double output Float64Array. Must have N + N1 + N2 - 1 elements.
  • strideOut: [in] CBLAS_INT stride length for out.
  • offsetOut: [in] CBLAS_INT starting index for out.
void stdlib_strided_dediff_ndarray( const CBLAS_INT N, const double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, const CBLAS_INT N1, const double *prepend,  const CBLAS_INT strideP, const CBLAS_INT offsetP,  const CBLAS_INT N2, const double *append, const CBLAS_INT strideA, const CBLAS_INT offsetA, double *out,  const CBLAS_INT strideOut, const CBLAS_INT offsetOut );

Examples

#include "stdlib/blas/ext/base/dediff.h"
#include <stdio.h>

int main( void ) {
    // Create a strided array:
    const double x[] = { 1.0, -2.0, 3.0, -4.0, 5.0, -6.0, 7.0, -8.0 };

    // Define prepend values:
    const double p[] = { -1.0 };

    // Define append values:
    const double a[] = { 10.0 };

    // Define output array:
    double out[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };

    // Compute forward differences:
    stdlib_strided_dediff( 8, x, 1, 1, p, 1, 1, a, 1, out, 1 );

    // Print the result:
    for ( int i = 0; i < 9; i++ ) {
        printf( "out[ %i ] = %lf\n", i, out[ i ] );
    }
}