```/* nag_kalman_sqrt_filt_info_var (g13ecc) Example Program.
*
* Copyright 2014 Numerical Algorithms Group
*
* Mark 3, 1993
* Mark 8 revised, 2004.
*/

#include <nag.h>
#include <stdio.h>
#include <nag_stdlib.h>
#include <nagg13.h>

#define AINV(I, J) ainv[(I) *tdainv + J]
#define QINV(I, J) qinv[(I) *tdqinv + J]
#define RINV(I, J) rinv[(I) *tdrinv + J]
#define T(I, J)    t[(I) *tdt + J]
#define B(I, J)    b[(I) *tdb + J]
#define C(I, J)    c[(I) *tdc + J]
int main(void)
{

Integer      exit_status = 0, i, istep, j, m, n, p, tdainv, tdb, tdc, tdqinv,
tdrinv;
Integer      tdt;
Nag_ab_input inp_ab;
double       *ainv = 0, *b = 0, *c = 0, *qinv = 0, *rinv = 0, *rinvy = 0;
double       *t = 0, tol, *x = 0, *z = 0;
NagError     fail;

INIT_FAIL(fail);

printf(
"nag_kalman_sqrt_filt_info_var (g13ecc) Example Program Results\n");

/* Skip the heading in the data file   */
scanf("%*[^\n]");
scanf("%ld%ld%ld%lf", &n, &m, &p, &tol);
if (n >= 1 && m >= 1 && p >= 1)
{
if (!(ainv = NAG_ALLOC(n*n, double)) ||
!(qinv = NAG_ALLOC(m*m, double)) ||
!(rinv = NAG_ALLOC(p*p, double)) ||
!(t = NAG_ALLOC(n*n, double)) ||
!(b = NAG_ALLOC(n*m, double)) ||
!(c = NAG_ALLOC(p*n, double)) ||
!(x = NAG_ALLOC(n, double)) ||
!(z = NAG_ALLOC(m, double)) ||
!(rinvy = NAG_ALLOC(p, double)))
{
printf("Allocation failure\n");
exit_status = -1;
goto END;
}
tdainv = n;
tdqinv = m;
tdrinv = p;
tdt = n;
tdb = m;
tdc = n;
}
else
{
printf("Invalid n or m or p.\n");
exit_status = 1;
return exit_status;
}
inp_ab = Nag_ab_prod;

for (i = 0; i < n; ++i)
for (j = 0; j < n; ++j)
scanf("%lf", &AINV(i, j));
for (i = 0; i < p; ++i)
for (j = 0; j < n; ++j)
scanf("%lf", &C(i, j));
if (rinv)
for (i = 0; i < p; ++i)
for (j = 0; j < p; ++j)
scanf("%lf", &RINV(i, j));
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j)
scanf("%lf", &B(i, j));
for (i = 0; i < m; ++i)
for (j = 0; j < m; ++j)
scanf("%lf", &QINV(i, j));
for (i = 0; i < n; ++i)
for (j = 0; j < n; ++j)
scanf("%lf", &T(i, j));
for (j = 0; j < m; ++j)
scanf("%lf", &z[j]);
for (j = 0; j < n; ++j)
scanf("%lf", &x[j]);
for (j = 0; j < p; ++j)
scanf("%lf", &rinvy[j]);

/* Perform three iterations of the (Kalman) filter recursion
(in square root information form). */
for (istep = 1; istep <= 3; ++istep)
/* nag_kalman_sqrt_filt_info_var (g13ecc).
* One iteration step of the time-varying Kalman filter
* recursion using the square root information
* implementation
*/
nag_kalman_sqrt_filt_info_var(n, m, p, inp_ab, t, tdt, ainv, tdainv, b,
tdb, rinv, tdrinv, c, tdc, qinv, tdqinv, x,
rinvy, z, tol, &fail);
if (fail.code != NE_NOERROR)
{
printf(
"Error from nag_kalman_sqrt_filt_info_var (g13ecc).\n%s\n",
fail.message);
exit_status = 1;
goto END;
}

printf("\nThe inverse of the square root of the state covariance "
"matrix is\n\n");
for (i = 0; i < n; ++i)
{
for (j = 0; j < n; ++j)
printf("%8.4f ", T(i, j));
printf("\n");
}

printf("\nThe components of the estimated filtered state are\n\n");
printf("k       x(k)  \n");
for (i = 0; i < n; ++i)
{
printf("%ld  ", i);
printf("  %8.4f  \n", x[i]);
}

END:
NAG_FREE(ainv);
NAG_FREE(qinv);
NAG_FREE(rinv);
NAG_FREE(t);
NAG_FREE(b);
NAG_FREE(c);
NAG_FREE(x);
NAG_FREE(z);
NAG_FREE(rinvy);
return exit_status;
}
```