![](bg3.png)
Provided that the equations in (2) are linearly in-
dependent, there are three possible cases:
1. if m < n, i.e., there are less equations than un-
knowns, the problem has infinite solutions;
2. if m = n, i.e., the number of equations is equal to
the number of unknowns, and A is non-singular,
the problem has exactly one solution;
3. if m > n, i.e., there are more equations than un-
knowns, the problem has no solutions.
If the problem admits at least one solution, it can be
solved by considering the inverse of the matrix A, be-
cause z = A
−1
·b. The implementation of the inverse
matrix computation has been widely studied and op-
timized, and can be found in most of mathematical
software, e.g. MATLAB (MathWorks, 2017).
2.2 Non-linear Problems
All problems like (1) that can not be written as in (2)
are classified as non-linear problems. Rarely direct
approaches can solve this kind of problems and some-
times it is impossible to know if a solution exists. For-
tunately, there exist iterative approaches that allow to
find approximations of one of the problem solutions.
When in (1) m = n, one of the most used
and implemented iterative solution approaches is the
Newton-Raphson method (NR) (Kelley, 1995). In its
steps, starting from an initial guess of z, the new ap-
proximation is determined using the Jacobian J of
the initial non-linear problem. However, since the
Jacobian of a set of real (or, respectively, complex)
equations is the matrix containing all their real (com-
plex) derivatives, in order to use NR, the problem has
to contain all derivable (holomorphic, i.e., complex
derivable) equations (Kreutz-Delgado, 2009).
An implementation of NR with MATLAB (Math-
Works, 2017) can be given by:
function [z, conv] = NR(z, par, max_it, tol)
conv = 0; i = 0; % initialize
F = feval(z, par); % evaluate f(z)
normF = norm(F, inf);
if normF < tol % check tolerance
conv = 1; exit;
end
while(conv==0 && i<max_it) % do NR iterations
i = i + 1; % update it.counter
J = jeval(z, F, par); % evaluate J
dz = -(J \ F); % calc. update step
z = z + dz; % update z
F = feval(z, par); % evaluate f(z)
normF = norm(F, inf);
if normF < tol % check convergence
conv = 1;
end
end
where the inputs are: (i) the initial guess z, (ii)
a list of parameters par containing all known val-
ues, (iii) the maximum number of iterations max_it
and (iv) the tolerance tol. The evaluation of f and J
is performed by the functions feval and jeval, re-
spectively. The functions feval and jeval are de-
fined and implemented by the modeler. feval has
inputs z and par; jeval has inputs z, par and F, i.e.,
the result of the current evaluation of f. The defini-
tion of jeval can include built-in automatic deriva-
tive operators provided by MATLAB. The solution
dz = -(J \ F) of the linear system J ·dz = −f(z)
determined by the Jacobian is used to approximate z
(z = z + dz).
Despite NR is a powerful and fast method, for
some problems it does not converge (conv = 0) and
hence the solution cannot be found.
When the functions f
i
of f are not complex deriv-
able, and then NR is not applicable, solutions can be
found only using an ad-hoc method.
3 THE NEW APPROACH: WNR
Our aim is to improve NR in order to obtain a method
that can find solutions when classic NR fails or can
not be used. The proposed method is called Wirtinger
Newton Raphson (WNR) because of the particular
derivatives used. WNR applies to systems described
by real derivable complex equations that can be holo-
morphic or non-holomorphic.
In fact, each function f
i
: C
n
→ C in f can be
seen as
˜
f
i
: R
2n
→ C when the cartesian coordinates
z
j
= x
j
+ıy
j
are considered. If all
˜
f
i
are derivable with
respect to x
j
and y
j
(as real variables), then the fol-
lowing method, here implemented in MATLAB, can
be used:
function [z, conv] = WNR(z, par, max_it, tol)
conv = 0; i = 0; % initialize
F = feval(z, par); % evaluate f(z)
normF = norm(F, inf);
if normF < tol % check tolerance
conv = 1; exit;
end
while(conv==0 && i<max_it) % do WNR iterations
i = i + 1; % update it.counter
G = wfunc(F); % NEW function
J = wjeval(z, F, par); % NEW Jacobian
dw = -(J \ G); % NEW update step
dz = wstep(dw); % calc. update step
z = z + dz; % update z
F = feval(z, par); % evaluate f(z)
normF = norm(F, inf);
if normF < tol % check convergence
conv = 1;
end
end
AMARETTO 2018 - Special Session on domAin specific Model-based AppRoaches to vErificaTion and validaTiOn
682