Integer type:  int32  int64  nag_int  show int32  show int32  show int64  show int64  show nag_int  show nag_int

Chapter Contents
Chapter Introduction
NAG Toolbox

# NAG Toolbox: nag_dot_real_prec (x03aa)

## Purpose

nag_dot_real_prec (x03aa) calculates the value of a scalar product using basic precision or additional precision and adds it to a basic precision or additional precision initial value.

## Syntax

[d1, d2, ifail] = x03aa(a, b, n, istepa, istepb, c1, c2, sw, 'isizea', isizea, 'isizeb', isizeb)
[d1, d2, ifail] = nag_dot_real_prec(a, b, n, istepa, istepb, c1, c2, sw, 'isizea', isizea, 'isizeb', isizeb)

## Description

nag_dot_real_prec (x03aa) calculates the scalar product of two double vectors and adds it to an initial value $c$ to give a correctly rounded result $d$:
 $d=c+∑i=1naibi.$
If $n<1$, $d=c$.
The vector elements ${a}_{i}$ and ${b}_{i}$ are stored in selected elements of the one-dimensional array arguments a and b, which in the function from which nag_dot_real_prec (x03aa) is called may be identified with parts of possibly multidimensional arrays according to the standard Fortran rules. For example, the vectors may be parts of a row or column of a matrix. See Arguments for details, and Example for an example.
Both the initial value $c$ and the result $d$ are defined by a pair of double variables, so that they may take either basic precision or additional precision values.
 (a) If ${\mathbf{sw}}=\mathit{true}$, the products are accumulated in additional precision, and on exit the result is available either in basic precision, correctly rounded, or in additional precision. (b) If ${\mathbf{sw}}=\mathit{false}$, the products are accumulated in basic precision, and the result is returned in basic precision.
This function is designed primarily for use as an auxiliary function by other functions in the NAG Toolbox, especially those in the chapters on Linear Algebra.

None.

## Parameters

### Compulsory Input Parameters

1:     $\mathrm{a}\left({\mathbf{isizea}}\right)$ – double array
The elements of the first vector.
The $i$th vector element is stored in the array element ${\mathbf{a}}\left(\left(i-1\right)×{\mathbf{istepa}}+1\right)$. In your function from which nag_dot_real_prec (x03aa) is called, a can be part of a multidimensional array and the actual argument must be the array element containing the first vector element.
2:     $\mathrm{b}\left({\mathbf{isizeb}}\right)$ – double array
The elements of the second vector.
The $i$th vector element is stored in the array element ${\mathbf{b}}\left(\left(i-1\right)×{\mathbf{istepb}}+1\right)$. In your function from which nag_dot_real_prec (x03aa) is called, b can be part of a multidimensional array and the actual argument must be the array element containing the first vector element.
3:     $\mathrm{n}$int64int32nag_int scalar
$n$, the number of elements in the scalar product.
4:     $\mathrm{istepa}$int64int32nag_int scalar
The step length between elements of the first vector in array a.
Constraint: ${\mathbf{istepa}}>0$.
5:     $\mathrm{istepb}$int64int32nag_int scalar
The step length between elements of the second vector in array b.
Constraint: ${\mathbf{istepb}}>0$.
6:     $\mathrm{c1}$ – double scalar
7:     $\mathrm{c2}$ – double scalar
c1 and c2 must specify the initial value $c$: $c={\mathbf{c1}}+{\mathbf{c2}}$. Normally, if $c$ is in additional precision, c1 specifies the most significant part and c2 the least significant part; if $c$ is in basic precision, then c1 specifies $c$ and c2 must have the value $0.0$. Both c1 and c2 must be defined on entry.
8:     $\mathrm{sw}$ – logical scalar
The precision to be used in the calculation.
${\mathbf{sw}}=\mathit{true}$
${\mathbf{sw}}=\mathit{false}$
basic precision.

### Optional Input Parameters

1:     $\mathrm{isizea}$int64int32nag_int scalar
Default: the dimension of the array a.
The dimension of the array a.
The upper bound for isizea is found by multiplying together the dimensions of a as declared in your function from which nag_dot_real_prec (x03aa) is called, subtracting the starting position and adding $1$.
Constraint: ${\mathbf{isizea}}\ge \left({\mathbf{n}}-1\right)×{\mathbf{istepa}}+1$.
2:     $\mathrm{isizeb}$int64int32nag_int scalar
Default: the dimension of the array b.
The dimension of the array b.
The upper bound for isizeb is found by multiplying together the dimensions of b as declared in your function from which nag_dot_real_prec (x03aa) is called, subtracting the starting position and adding $1$.
Constraint: ${\mathbf{isizeb}}\ge \left({\mathbf{n}}-1\right)×{\mathbf{istepb}}+1$.

### Output Parameters

1:     $\mathrm{d1}$ – double scalar
2:     $\mathrm{d2}$ – double scalar
The result $d$.
If the calculation is in additional precision (${\mathbf{sw}}=\mathit{true}$),
• ${\mathbf{d1}}=d$ rounded to basic precision;
• ${\mathbf{d2}}=d-{\mathbf{d1}}$,
thus d1 holds the correctly rounded basic precision result and the sum ${\mathbf{d1}}+{\mathbf{d2}}$ gives the result in additional precision. d2 may have the opposite sign to d1
If the calculation is in basic precision (${\mathbf{sw}}=\mathit{false}$),
• ${\mathbf{d1}}=d$;
• ${\mathbf{d2}}=0.0$.
3:     $\mathrm{ifail}$int64int32nag_int scalar
${\mathbf{ifail}}={\mathbf{0}}$ unless the function detects an error (see Error Indicators and Warnings).

## Error Indicators and Warnings

Errors or warnings detected by the function:
${\mathbf{ifail}}=1$
 On entry, ${\mathbf{istepa}}\le 0$, or ${\mathbf{istepb}}\le 0$.
${\mathbf{ifail}}=2$
 On entry, ${\mathbf{isizea}}>\left({\mathbf{n}}-1\right)×{\mathbf{istepa}}+1$, or ${\mathbf{isizeb}}>\left({\mathbf{n}}-1\right)×{\mathbf{istepb}}+1$.
${\mathbf{ifail}}=-99$
${\mathbf{ifail}}=-399$
Your licence key may have expired or may not have been installed correctly.
${\mathbf{ifail}}=-999$
Dynamic memory allocation failed.

## Accuracy

If the calculation is an additional precision, the rounded basic precision result d1 is correct to full implementation accuracy, provided that exceptionally severe cancellation does not occur in the summation. If the calculation is in basic precision, such accuracy cannot be guaranteed.

The time taken by nag_dot_real_prec (x03aa) is approximately proportional to $n$ and also depends on whether basic precision or additional precision is used.
On exit the variables d1 and d2 may be used directly to supply a basic precision or additional precision initial value for a subsequent call of nag_dot_real_prec (x03aa).

## Example

This example calculates the scalar product of the second column of the matrix $A$ and the vector ${\mathbf{b}}$, and add it to an initial value $1.0$ where
 $A= -2 -3 7 2 -5 3 -9 1 0 , b= 8 -4 -2 .$
```function x03aa_example

fprintf('x03aa example results\n\n');

% Evaluate d = c + a(:,2).b, where
a = [ -2   -3        7;
2   -5        3;
-9    1e-19    0];
b = [ 8;
-4;
-2];
n = int64(size(a,2));

% c = 1 (in basic precision) + 1e-19 (extra precision)
c1 = 1;
c2 = 1e-20;

% elements are stored contiguously in a and b
istepa = int64(1);
istepb = istepa;

% Calculate dodt-product in extended precision
sw = true;

[d1, d2, ifail] = x03aa( ...
a(:,2), b, n, istepa, istepb, c1, c2, sw);

fprintf('Accumulated dot-product = %20.15e + %10.2e\n',d1,d2);

```
```x03aa example results

Accumulated dot-product = -3.000000000000000e+00 +  -1.90e-19
```