# NMath User's Guide

5.6 Functions of Vectors (.NET, C#, CSharp, VB, Visual Basic, F#)

NMath provides a variety of functions that take vectors as arguments.

Rounding Functions

Class NMathFunctions provides static methods for rounding a vector's elements:

Round() rounds each element of a given vector to the specified number of decimal places.

Ceil() applies the ceiling rounding function to each element of a given vector.

Floor() applies the floor rounding function to each element of a given vector.

For instance, this code converts a vector of dollar amounts to Euros, then rounds to two decimal places:

Code Example – C# vector

```var v = new DoubleVector( "\$4.30 \$0.08 (\$5.87)",
```
```   NumberStyles.Number | NumberStyles.AllowCurrencySymbol |
```
```   NumberStyles.AllowParentheses );
```
```v = v * 0.9289;  // exchange rate
```
```v = NMathFunctions.Round( v, 2 );
```

Code Example – VB vector

```Dim V As New DoubleVector("\$4.30 \$0.08 (\$5.87)",
```
```  NumberStyles.Number Or NumberStyles.AllowCurrencySymbol Or
```
```  NumberStyles.AllowParentheses)
```
```V = V * 0.9289  ' exchange rate
```
```V = NMathFunctions.Round(V, 2)
```

Sums, Differences, and Products

Class NMathFunctions provides static methods to calculate sums, differences, and products of vector elements:

Sum() returns the sum of the elements in a given vector.

AbsSum() returns the sum of the absolute value of the elements in a given vector. (For complex vectors, this function calculates the sum of the L1 norms of the vector's elements.)

CumulativeSum() returns a vector containing the cumulative sum of the elements in a given vector, such that u[i] = v[0] + v[1] + ... v[i].

NaNSum() returns the sum of the elements in a given vector, ignoring values that are Not-a-Number (NaN). NaN functions are available for real-value vectors only, not complex number vectors.

Delta() returns a vector containing the differences between successive elements in a given vector, such that:

```u[0] = v[0]
```
```u[i] = v[i] - v[i-1]
```

Product() returns the product of the elements in a given vector.

CumulativeProduct() returns a vector containing the cumulative product of the elements in a given vector.

Dot() returns the vector dot, or inner, product d of two vectors, v and w, where

```d = v[0]*w[0] + v[1]*w[1]...
```

OuterProduct() creates a matrix containing the outer product of two vectors.

Cross() computes the cross product of two vectors. The vectors must have at least length three, and elements beyond three are ignored for purposes of computing the cross product.

For example:

Code Example – C# vector

```var v = new FloatVector( "[1 2 3 4 5 6]" );
```
```var u = new FloatVector( v.Length, 1, 1 );

```

```float dp = NMathFunctions.Dot( v, u );
```

Code Example – VB vector

```Dim V As New FloatVector("[1 2 3 4 5 6]")
```
```Dim U As New FloatVector(V.Length, 1, 1)

```

```Dim DP As Single = NMathFunctions.Dot(V, U)
```

Min/Max Functions

Class NMathFunctions provides static min/max finding methods that return the integer index of the element that meets the appropriate criterion:

MaxIndex() returns the index of the element with the greatest value.

MinIndex() returns the index of the element with the smallest value.

MaxAbsIndex() returns the index of the element with the greatest absolute value.

MinAbsIndex() returns the index of the element with the smallest absolute value.

Min/max value methods MaxValue(), MinValue(), MaxAbsValue(), and MinAbsValue() return the value of the element that meets the appropriate criterion. The returned type depends on the type of the vector. For instance, the MaxValue() method that accepts a DoubleVector returns a double.

NaNMax(), NaNMin(), NaNMaxIndex(), and NaNMinIndex() ignore values that are Not-a-Number (NaN). NaN functions are available for real-value vectors only, not complex number vectors.

Statistical Functions

The static Mean() method on NMathFunctions returns the mean of a given vector's elements. Median() returns the median. If the length of the vector is even, the middle two elements are averaged. Median() is available for real-value vectors only, not complex number vectors, because there is no standard ordering for complex numbers.

Variance() returns the biased variance of the elements. For instance:

Code Example – C# vector

```var v = new DoubleVector( "[1 2 3 4 5 6]" );
```
```double mean = NMathFunctions.Mean( v );
```
```double variance = NMathFunctions.Variance( v );
```

Code Example – VB vector

```Dim V As New DoubleVector("[1 2 3 4 5 6]")
```
```Dim Mean As Double = NMathFunctions.Mean(V)
```
```Dim Variance As Double = NMathFunctions.Variance(V)
```

SumOfSquares() returns the sum of the squared deviations from the mean of the elements of a given vector.

NaNMean(), NanMedian(), NaNVariance(), and NanSumOfSquares() ignore values that are Not-A-Number (NaN). NaNCount() returns the number of NaN values in a vector. NaN functions are available for real-value vectors only, not complex vectors.

Trigonometric Functions

NMath extends standard trigonometric functions Acos(), Asin(), Atan(), Cos(), Cosh(), Sin(), Sinh(), Tan(), and Tanh() to take vector arguments. Class NMathFunctions provides these functions as static methods. For example, this code construct a vector whose contents are the cosines of another vector:

Code Example – C# vector

```var v = new FloatVector( 10, 0, 2 );
```
```FloatVector cosv = NMathFunctions.Cos( v );
```

Code Example – VB vector

```Dim V As New FloatVector(10, 0, 2)
```
```Dim Cosv As FloatVector = NMathFunctions.Cos(V)
```

The static Atan2() method takes two vectors and applies the two-argument arc tangent function to successive pairs of elements.

Transcendental Functions

NMath extends standard transcendental functions Exp() and Log(), Log10() to take vector arguments. Class NMathFunctions provides these functions as static methods; each takes a single vector as an argument and return a vector as a result. For instance, this code creates a vector whose elements are the log of another vector's elements:

Code Example – C# vector

```var v = new DoubleVector( 10, 0, 5 );
```
```DoubleVector log = NMathFunctions.Log( v );
```

Code Example – VB vector

```Dim V As New DoubleVector(10, 0, 5)
```
```Dim Log As DoubleVector = NMathFunctions.Log(V)
```

Class NMathFunctions also provides the exponential function Pow() to raise each element of a vector to a real exponent:

Code Example – C# vector

```var v = new DoubleVector( 100, 0, 1 );
```
```FloatVector vCubed = NMathFunctions.Pow( v, 3 );
```

Code Example – VB vector

```Dim V As New DoubleVector(100, 0, 1)
```
```Dim VCubed As FloatVector = NMathFunctions.Pow(V, 3)
```

Absolute Value and Square Root

The static Abs() function on class NMathFunctions applies the absolute value function to each element of a given vector:

Code Example – C# vector

```var v = new DoubleVector ( 10, 0, -1 );
```
```DoubleVector abs = NMathFunctions.Abs( v );
```

Code Example – VB vector

```Dim V As New DoubleVector(10, 0, -1)
```
```Dim ABS As DoubleVector = NMathFunctions.Abs(V)
```

NMath also extends the standard Sqrt() function to take a vector argument. Thus, this code creates a vector whose elements are the square root of another vector's elements:

Code Example – C# vector

```var v = new DoubleVector( 10, 0, 5 );
```
```DoubleVector sqrt = NMathFunctions.Sqrt( v );
```

Code Example – VB vector

```Dim V As New DoubleVector(10, 0, 5)
```
```Dim SQRT As DoubleVector = NMathFunctions.Sqrt(V)
```

Sorting Functions

The static Sort() method on class NMathFunctions sorts the elements of a given vector in ascending order using the quicksort algorithm and returns a new vector containing the result:

Code Example – C# vector

```double[] dblArray = { 1.12, -2.0, 3.88, 1.2, 15.345 };
```
```var v = new DoubleVector( dblArray );

```

```v = NMathFunctions.Sort( v );
```

Code Example – VB vector

```Dim DblArray() As Double = {1.12, -2.0, 3.88, 1.2, 15.345}
```
```Dim V As New DoubleVector(DblArray)

```

```V = NMathFunctions.Sort(V)
```

NOTE—This method is only available for FloatVector and DoubleVector, since there is no standard ordering for complex numbers.

Any NaN values in the vector are placed at the end of the ordered vector. To order the elements in descending order, Reverse() the returned vector:

Code Example – C# vector

```v = NMathFunctions.Sort( v ).Reverse();
```

Code Example – VB vector

```V = NMathFunctions.Sort(V).Reverse()
```

Complex Vector Functions

Static methods Real() and Imag() on class NMathFunctions return the real and imaginary part of a vector's elements. If the elements of the given vector are real, Real() simply returns the given vector and Imag() returns a vector of the same length containing all zeros.

Static methods Arg() and Conj() on class NMathFunctions return the arguments (or phases) and complex conjugates of a vector's elements. If the elements of the given vector are real, both methods simply return the given vector.

Top

Top