<section class="intro">

The [minkowski distance][wikipedia-minkowski-distance] is defined as

where `a_i` and `b_i` are the _ith_ components of vectors **A** and **B**, respectively.

</section>

<section class="usage">

var dminkowski = require( '@stdlib/stats/strided/distances/dminkowski' );

Computes the Minkowski distance between two double-precision floating-point strided arrays.

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

var x = new Float64Array( [ 4.0, 2.0, -3.0, 5.0, -1.0 ] );

var y = new Float64Array( [ 2.0, 6.0, -1.0, -4.0, 8.0 ] );

var z = dminkowski( x.length, 3, x, 1, y, 1 );

The function has the following parameters:

- **N**: number of indexed elements.

- **p**: order of the Minkowski norm.

- **x**: input [`Float64Array`][@stdlib/array/float64].

- **strideX**: stride length of `x`.

- **y**: input [`Float64Array`][@stdlib/array/float64].

- **strideY**: stride length of `y`.

The `N` and stride parameters determine which elements in the strided arrays are accessed at runtime. For example, to calculate the Minkowski distance between every other element in `x` and the first `N` elements of `y` in reverse order,

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

var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );

var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );

var z = dminkowski( 3, 3, x, 2, y, -1 );

Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.

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

var x0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );

var y0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );

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

var y1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 ); // start at 4th element

var z = dminkowski( 3, 3, x1, 1, y1, 1 );

Computes the Minkowski distance between two double-precision floating-point strided arrays using alternative indexing semantics.

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

var x = new Float64Array( [ 4.0, 2.0, -3.0, 5.0, -1.0 ] );

var y = new Float64Array( [ 2.0, 6.0, -1.0, -4.0, 8.0 ] );

var z = dminkowski.ndarray( x.length, 3, x, 1, 0, y, 1, 0 );

The function has the following additional parameters:

- **offsetX**: starting index for `x`.

- **offsetY**: starting index for `y`.

While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example, to calculate the Minkowski distance between every other element in `x` starting from the second element with the last 3 elements in `y` in reverse order

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

var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );

var y = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );

var z = dminkowski.ndarray( 3, 3, x, 2, 1, y, -1, y.length-1 );

</section>

<section class="notes">

- If `N <= 0`, both functions return `NaN`.

</section>

<section class="examples">

var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );

var dminkowski = require( '@stdlib/stats/strided/distances/dminkowski' );

var opts = {

'dtype': 'float64'

};

var x = discreteUniform( 10, 0, 100, opts );

console.log( x );

var y = discreteUniform( x.length, 0, 10, opts );

console.log( y );

var out = dminkowski.ndarray( x.length, 3, x, 1, 0, y, -1, y.length-1 );

console.log( out );

</section>

<section class="c">

<section class="intro">

</section>

<section class="usage">

#include "stdlib/stats/strided/distances/dminkowski.h"

Computes the Minkowski distance between two double-precision floating-point strided arrays.

const double x[] = { 4.0, 2.0, -3.0, 5.0, -1.0 };

const double y[] = { 2.0, 6.0, -1.0, -4.0, 8.0 };

double v = stdlib_strided_dminkowski( 5, 3, x, 1, y, 1 );

// returns ~11.543

Computes the Minkowski distance between two double-precision floating-point strided arrays using alternative indexing semantics.

const double x[] = { 4.0, 2.0, -3.0, 5.0, -1.0 };

const double y[] = { 2.0, 6.0, -1.0, -4.0, 8.0 };

double v = stdlib_strided_dminkowski_ndarray( 5, 3, x, -1, 4, y, -1, 4 );

// returns ~11.543

</section>

<section class="notes">

</section>

<section class="examples">

#include "stdlib/stats/strided/distances/dminkowski.h"

#include <stdio.h>

int main( void ) {

// Create strided arrays:

const double x[] = { 1.0, -2.0, 3.0, -4.0, 5.0, -6.0, 7.0, -8.0 };

const double y[] = { 1.0, -2.0, 3.0, -4.0, 5.0, -6.0, 7.0, -8.0 };

// Specify the number of elements:

const int N = 8;

// Specify the order of the Minkowski norm:

const double p = 3.0;

// Specify strides:

const int strideX = 1;

const int strideY = -1;

// Compute the Minkowski distance between `x` and `y`:

double d = stdlib_strided_dminkowski( N, p, x, strideX, y, strideY );

// Print the result:

printf( "Minkowski distance: %lf\n", d );

// Compute the Minkowski distance between `x` and `y` with offsets:

d = stdlib_strided_dminkowski_ndarray( N, p, x, strideX, 0, y, strideY, N-1 );

// Print the result:

printf( "Minkowski distance: %lf\n", d );

}