Gradient (nabla) of vector/array in Delphi - arrays

Question

I am to implement the following formula in Delphi:
Understanding the formula:
Y_k is a floating point number which we'll call just Y.
w[i][j] is an array containing floating point numbers as well (1<=i<=43 and 1<=j<=30).
According to my source paper (p. 12) nabla(w)*Y_k is the partial derivative of (column) vector w with respect to the value Y". Is this correct?
Coding in Delphi (implementation):
So how do I implement this in Delphi?
Thanks a lot in advance!

Answer 1

I will assume that the problem is: "How can I compute a gradient of a scalar function in Delphi?" [I still think that the symbol given above looks more like a connection/covariant derivative as known from differential geometry/tensor calculus!]
You need to specify the input you got. The simplest case is when you got the function f whose gradient you wish to compute. Per definition, if f is a function of the k variables x1, x2, ..., xk, that is, if you'd write
f(x1, x2, ..., xk)
which is a scalar field in ℝk then the gradient is
∇f = (∂f/∂x1, ∂f/∂x2, ..., ∂f/∂xk)
that is, a vector field in ℝk (at each point in ℝk you get a k-dimensional vector).
This is rather easily implemented in Delphi. The following is an example for the case where k = 3.
type
TVector = record
x, y, z: real;
constructor Create(ax, ay, az: real);
end;
TRealValuedFunction = function(v: TVector): real;
function gradient(f: TRealValuedFunction; v: TVector): TVector;
const
h = 0.001;
begin
result.x := (f(TVector.Create(v.x + h, v.y, v.z)) - f(TVector.Create(v.x - h, v.y, v.z))) / (2*h);
result.y := (f(TVector.Create(v.x, v.y + h, v.z)) - f(TVector.Create(v.x, v.y - h, v.z))) / (2*h);
result.z := (f(TVector.Create(v.x, v.y, v.z + h)) - f(TVector.Create(v.x, v.y, v.z - h))) / (2*h);
end;
where, of course,
constructor TVector.Create(ax, ay, az: real);
begin
x := ax;
y := ay;
z := az;
end;
Sample usage:
function SampleFunction(v: TVector): real;
begin
result := 5*v.x + 7*v.y;
end;
procedure TForm4.FormCreate(Sender: TObject);
begin
with gradient(SampleFunction, TVector.Create(2, 6, 3)) do
ShowMessage(FloatToStr(x) + ', ' + FloatToStr(y) + ', ' + FloatToStr(z))
end;
The result is 5.00000000000256, 7.000000000005, 0 which is a very good approximation to the gradient of SampleFunction at v (in this case the gradient is constant in space, that is, it doesn't depend on which point v in space you select).
Of course, if you are writing anything serious, you will probably use your own vector algebra library.
Also, h = 0.001 might not be a great value in your case.