20 #include <lal/LALAdaptiveRungeKuttaIntegrator.h>
22 #define XLAL_BEGINGSL \
24 gsl_error_handler_t *saveGSLErrorHandler_; \
25 saveGSLErrorHandler_ = gsl_set_error_handler_off();
28 gsl_set_error_handler( saveGSLErrorHandler_ ); \
32 int (*stop) (
double t,
const double y[],
double dydt[],
void *params),
double eps_abs,
double eps_rel)
42 XLAL_CALLGSL(integrator->
step = gsl_odeiv_step_alloc(gsl_odeiv_step_rkf45, dim));
48 integrator->
sys = (gsl_odeiv_system *)
LALCalloc(1,
sizeof(gsl_odeiv_system));
51 if (!(integrator->
step) || !(integrator->
control) || !(integrator->
evolve) || !(integrator->
sys)) {
56 integrator->
dydt = dydt;
57 integrator->
stop = stop;
59 integrator->
sys->function = dydt;
60 integrator->
sys->jacobian = NULL;
61 integrator->
sys->dimension = dim;
62 integrator->
sys->params = NULL;
71 int (*stop) (
double t,
const double y[],
double dydt[],
void *params),
double eps_abs,
double eps_rel)
81 XLAL_CALLGSL(integrator->
step = gsl_odeiv_step_alloc(gsl_odeiv_step_rk8pd, dim));
86 integrator->
sys = (gsl_odeiv_system *)
LALCalloc(1,
sizeof(gsl_odeiv_system));
89 if (!(integrator->
step) || !(integrator->
control) || !(integrator->
evolve) || !(integrator->
sys)) {
94 integrator->
dydt = dydt;
95 integrator->
stop = stop;
97 integrator->
sys->function = dydt;
98 integrator->
sys->jacobian = NULL;
99 integrator->
sys->dimension = dim;
100 integrator->
sys->params = NULL;
117 if (integrator->
step)
130 int len = *outputlen;
141 for (i = 0; i < dim + 1; i++) {
142 memcpy(&(new->data[2 * i * len]), &(out->
data[i * len]), len *
sizeof(
REAL8));
151 out->
data[count - 1] = t;
152 for (i = 1; i < dim + 1; i++) {
153 out->
data[i * len + count - 1] =
y[i - 1];
165 int len = *outputlen;
174 for (i = 0; i < dim + 1; i++) {
175 memcpy(&(new->data[i * count]), &(out->
data[i * len]), count *
sizeof(
REAL8));
230 size_t dim, retries, i;
231 int outputlen = 0, count = 0;
239 REAL8 tend = tend_in;
252 dim = integrator->
sys->dimension;
254 outputlen = ((int)(tend_in - tinit) / deltat);
258 (
"XLAL Error - %s: (tend_in - tinit) and deltat must have the same sign\ntend_in: %f, tinit: %f, deltat: %f\n",
259 __func__, tend_in, tinit, deltat);
280 integrator->
sys->params = params;
289 for (i = 1; i <= dim; i++)
290 output->data[i * outputlen] = yinit[i - 1];
295 gsl_odeiv_step_reset(integrator->
step);
296 gsl_odeiv_evolve_reset(integrator->
evolve);
304 gsl_odeiv_evolve_apply(integrator->
evolve, integrator->
control, integrator->
step, integrator->
sys, &t, tend, &h,
309 if (
status != GSL_SUCCESS) {
327 while ((tintp + deltat) * (tintp + deltat) < t * t) {
333 REAL8 hUsed = t - told;
334 REAL8 theta = (tintp - told) / hUsed;
338 REAL8 i0 = 1.0 + theta * theta * (3.0 - 4.0 * theta);
339 REAL8 i1 = -theta * (theta - 1.0);
340 REAL8 i6 = -4.0 * theta * theta * (theta - 1.0);
341 REAL8 iend = theta * theta * (4.0 * theta - 3.0);
346 REAL8 *k6 = rkfState->k6;
347 REAL8 *y0 = rkfState->y0;
349 for (i = 0; i < dim; i++) {
350 ytemp[i] = i0 * y0[i] + iend * yinit[i] + hUsed * i1 *
k1[i] + hUsed * i6 * k6[i];
368 if (integrator->
stop) {
369 if ((
status = integrator->
stop(t, yinit, integrator->
evolve->dydt_out, params)) != GSL_SUCCESS) {
381 for (i = 0; i < dim; i++) {
382 yinit[i] =
output->data[(i + 2) * outputlen - 1];
438 size_t dim, retries, i;
444 REAL8 tend = tend_in;
457 dim = integrator->
sys->dimension;
459 if ((tend < tinit && deltat > 0) || (tend > tinit && deltat < 0)) {
461 (
"XLAL Error - %s: (tend_in - tinit) and deltat must have the same sign\ntend_in: %f, tinit: %f, deltat: %f\n",
462 __func__, tend_in, tinit, deltat);
478 integrator->
sys->params = params;
487 gsl_odeiv_step_reset(integrator->
step);
488 gsl_odeiv_evolve_reset(integrator->
evolve);
496 gsl_odeiv_evolve_apply(integrator->
evolve, integrator->
control, integrator->
step, integrator->
sys, &t, tend, &h,
501 if (
status != GSL_SUCCESS) {
520 if (deltat*yinit[1] >= deltat*y1_final) {
523 REAL8 hUsed = t - told;
525 while (deltat*ytemp[1] < deltat*y1_final) {
531 REAL8 theta = (tintp - told) / hUsed;
535 REAL8 i0 = 1.0 + theta * theta * (3.0 - 4.0 * theta);
536 REAL8 i1 = -theta * (theta - 1.0);
537 REAL8 i6 = -4.0 * theta * theta * (theta - 1.0);
538 REAL8 iend = theta * theta * (4.0 * theta - 3.0);
543 REAL8 *k6 = rkfState->k6;
544 REAL8 *y0 = rkfState->y0;
546 for (i = 0; i < dim; i++) {
547 ytemp[i] = i0 * y0[i] + iend * yinit[i] + hUsed * i1 *
k1[i] + hUsed * i6 * k6[i];
558 if (integrator->
stop) {
559 if ((
status = integrator->
stop(t, yinit, integrator->
evolve->dydt_out, params)) != GSL_SUCCESS) {
567 for (i = 0; i < dim; i++) {
596 size_t dim, outputlength=0, bufferlength, retries;
597 REAL8 t, tnew, h0, h0old;
599 REAL8 *temp = NULL, *
y, *y0, *dydt_in, *dydt_in0, *dydt_out, *yerr;
607 dim = integrator->
sys->dimension;
608 bufferlength = (int)((tend - tinit) / deltat_or_h0) + 2;
611 if(EOBversion==2) dimn = dim + 1;
618 if (!buffers || !temp) {
625 dydt_in = temp + 2 * dim;
626 dydt_in0 = temp + 3 * dim;
627 dydt_out = temp + 4 * dim;
628 yerr = temp + 5 * dim;
631 integrator->
sys->params = params;
640 memcpy(
y, yinit, dim *
sizeof(
REAL8));
643 buffers->
data[0] = t;
644 for (
unsigned int i = 1; i <= dim; i++)
645 buffers->
data[i * bufferlength] =
y[i - 1];
648 if ((
status = integrator->
dydt(t,
y, dydt_in, params)) != GSL_SUCCESS) {
655 for (
unsigned int i = 1; i <= 3; i++)
656 buffers->
data[(dim+i)*bufferlength] = dydt_in[i-1];
660 if(EOBversion==2) loop = dim;
669 if (integrator->
stop) {
670 if ((
status = integrator->
stop(t,
y, dydt_in, params)) != GSL_SUCCESS) {
683 memcpy(y0,
y, dim *
sizeof(
REAL8));
684 memcpy(dydt_in0, dydt_in, dim *
sizeof(
REAL8));
687 status = gsl_odeiv_step_apply(integrator->
step, t, h0,
y, yerr, dydt_in, dydt_out, integrator->
sys);
693 if (
status != GSL_SUCCESS) {
708 status = gsl_odeiv_control_hadjust(integrator->
control, integrator->
step,
y, yerr, dydt_out, &h0);
712 if (h0 < min_deltat_or_h0) h0 = min_deltat_or_h0;
722 memcpy(
y, y0, dim *
sizeof(
REAL8));
723 memcpy(dydt_in, dydt_in0, dim *
sizeof(
REAL8));
730 memcpy(dydt_in, dydt_out, dim *
sizeof(
REAL8));
734 if (outputlength >= bufferlength) {
743 for (
unsigned int i = 0; i <= loop ; i++)
744 memcpy(&rebuffers->
data[i * 2 * bufferlength], &buffers->
data[i * bufferlength], outputlength *
sizeof(
REAL8));
752 buffers->
data[outputlength] = t;
753 for (
unsigned int i = 1; i <= loop; i++)
754 buffers->
data[i * bufferlength + outputlength] =
y[i - 1];
756 for (
unsigned int i = 1; i <= 3; i++)
757 buffers->
data[(dim+i) * bufferlength + outputlength] = dydt_out[i - 1];
763 memcpy(yinit,
y, dim *
sizeof(
REAL8));
766 if (outputlength == 0)
776 if (!(*t_and_y_out)) {
784 for(
UINT8 j=0;j<outputlength;j++) {
785 (*t_and_y_out)->data[j] = buffers->
data[j];
786 for(
UINT8 i=1;i<=loop;i++) {
787 (*t_and_y_out)->data[i*outputlength + j] = buffers->
data[i*bufferlength + j];
815 size_t dim = integrator->
sys->dimension;
816 UINT4 sparse_outputlength = 0;
817 UINT4 dense_outputlength = 1;
818 size_t sparse_bufferlength, dense_bufferlength, retries;
824 REAL8 *temp = NULL, *
y, *y0, *dydt_in, *dydt_in0, *dydt_out, *yerr;
825 REAL8 interp_t = tinit + h0;
833 sparse_bufferlength = (int)((tend - tinit) / h0) + 2;
834 dense_bufferlength = (int)((tend - tinit) / h0) + 2;
836 const UINT4 dimn = dim + 1;
842 if (!sparse_buffers || !dense_buffers || !temp) {
850 dydt_in = temp + 2 * dim;
851 dydt_in0 = temp + 3 * dim;
852 dydt_out = temp + 4 * dim;
853 yerr = temp + 5 * dim;
856 integrator->
sys->params = params;
860 memcpy(
y, yinit, dim *
sizeof(
REAL8));
863 sparse_buffers->
data[0] = t;
864 dense_buffers->
data[0] = t;
865 for (
UINT4 i = 1; i <= dim; i++){
866 UINT4 iminus1 = i - 1;
867 sparse_buffers->
data[i * sparse_bufferlength] =
y[iminus1];
868 dense_buffers->
data[i * dense_bufferlength] =
y[iminus1];
872 if ((
status = integrator->
dydt(t,
y, dydt_in, params)) != GSL_SUCCESS) {
884 if (integrator->
stop) {
885 if ((
status = integrator->
stop(t,
y, dydt_in, params)) != GSL_SUCCESS) {
899 memcpy(y0,
y, dim *
sizeof(
REAL8));
900 memcpy(dydt_in0, dydt_in, dim *
sizeof(
REAL8));
903 status = gsl_odeiv_step_apply(integrator->
step, t, h0,
y, yerr, dydt_in, dydt_out, integrator->
sys);
909 if (
status != GSL_SUCCESS) {
927 status = gsl_odeiv_control_hadjust(integrator->
control, integrator->
step,
y, yerr, dydt_out, &h0);
932 if (
status == GSL_ODEIV_HADJ_DEC) {
934 memcpy(
y, y0, dim *
sizeof(
REAL8));
935 memcpy(dydt_in, dydt_in0, dim *
sizeof(
REAL8));
939 if (2*dense_outputlength >= dense_bufferlength) {
948 for (
UINT4 k = 0; k <= dim; k++)
949 memcpy(&rebuffers->
data[k * 2 * dense_bufferlength], &dense_buffers->
data[k * dense_bufferlength], dense_outputlength *
sizeof(
REAL8));
951 dense_buffers = rebuffers;
952 dense_bufferlength *= 2;
957 const REAL8 interp_t_old = interp_t;
958 const UINT4 dense_outputlength_old = dense_outputlength;
959 while (interp_t < tnew) {
960 dense_buffers->
data[dense_outputlength] = interp_t;
961 dense_outputlength++;
962 interp_t = tinit + dense_outputlength*deltat;
964 interp_t = interp_t_old;
965 dense_outputlength = dense_outputlength_old;
969 const REAL8 h = tnew - t;
970 const REAL8 h_inv = 1.0/h;
972 for (
UINT4 i = 0; i < dim; i++) {
973 REAL8 interp_t_old = interp_t;
974 UINT4 dense_outputlength_old = dense_outputlength;
978 while (interp_t < tnew) {
979 const REAL8 theta = (interp_t - t)*h_inv;
980 dense_buffers->
data[(i+1)*dense_bufferlength + dense_outputlength] =
981 (1.0 - theta)*y0i + theta*yi + theta*(theta-1.0)*( (1.0 - 2.0*theta)*(yi - y0i) + h*( (theta-1.0)*dydt_in[i] + theta*dydt_out[i]));
982 dense_outputlength++;
983 interp_t = tinit + dense_outputlength*deltat;
987 interp_t = interp_t_old;
988 dense_outputlength = dense_outputlength_old;
995 memcpy(dydt_in, dydt_out, dim *
sizeof(
REAL8));
996 sparse_outputlength++;
999 if (sparse_outputlength >= sparse_bufferlength) {
1008 for (
UINT4 i = 0; i <= dim; i++)
1009 memcpy(&rebuffers->
data[i * 2 * sparse_bufferlength], &sparse_buffers->
data[i * sparse_bufferlength], sparse_outputlength *
sizeof(
REAL8));
1011 sparse_buffers = rebuffers;
1012 sparse_bufferlength *= 2;
1017 sparse_buffers->
data[sparse_outputlength] = t;
1018 for (
UINT4 i = 1; i <= dim; i++)
1019 sparse_buffers->
data[i * sparse_bufferlength + sparse_outputlength] =
y[i - 1];
1022 if (sparse_outputlength == 0 || dense_outputlength == 1)
1025 sparse_outputlength++;
1030 if (!(*sparse_output) || !(*dense_output)) {
1032 if (*sparse_output){
1034 sparse_outputlength = 0;
1038 dense_outputlength = 0;
1043 for(
UINT4 j = 0; j < sparse_outputlength; j++) {
1044 (*sparse_output)->data[j] = sparse_buffers->
data[j];
1045 for(
UINT4 i = 1; i <= dim; i++) {
1046 (*sparse_output)->data[i * sparse_outputlength + j] = sparse_buffers->
data[i * sparse_bufferlength + j];
1050 for(
UINT4 j = 0; j < dense_outputlength; j++) {
1051 (*dense_output)->data[j] = dense_buffers->
data[j];
1052 for(
UINT4 i = 1; i <= dim; i++) {
1053 (*dense_output)->data[i * dense_outputlength + j] = dense_buffers->
data[i * dense_bufferlength + j];
1071 return sparse_outputlength;
1081 size_t dim, bufferlength, cnt, retries;
1084 REAL8 *temp = NULL, *
y, *y0, *dydt_in, *dydt_in0, *dydt_out, *yerr;
1087 gsl_spline *interp = NULL;
1088 gsl_interp_accel *accel = NULL;
1091 REAL8 *times, *vector;
1099 dim = integrator->
sys->dimension;
1100 bufferlength = (int)((tend - tinit) / deltat) + 2;
1104 if (!buffers || !temp) {
1111 dydt_in = temp + 2 * dim;
1112 dydt_in0 = temp + 3 * dim;
1113 dydt_out = temp + 4 * dim;
1114 yerr = temp + 5 * dim;
1117 integrator->
sys->params = params;
1122 retries = integrator->
retries;
1126 memcpy(
y, yinit, dim *
sizeof(
REAL8));
1129 buffers->
data[0] = t;
1130 for (
unsigned int i = 1; i <= dim; i++)
1131 buffers->
data[i * bufferlength] =
y[i - 1];
1134 if ((
status = integrator->
dydt(t,
y, dydt_in, params)) != GSL_SUCCESS) {
1146 if (integrator->
stop) {
1147 if ((
status = integrator->
stop(t,
y, dydt_in, params)) != GSL_SUCCESS) {
1160 memcpy(y0,
y, dim *
sizeof(
REAL8));
1161 memcpy(dydt_in0, dydt_in, dim *
sizeof(
REAL8));
1164 status = gsl_odeiv_step_apply(integrator->
step, t, h0,
y, yerr, dydt_in, dydt_out, integrator->
sys);
1170 if (
status != GSL_SUCCESS) {
1179 retries = integrator->
retries;
1185 status = gsl_odeiv_control_hadjust(integrator->
control, integrator->
step,
y, yerr, dydt_out, &h0);
1190 if (
status == GSL_ODEIV_HADJ_DEC) {
1191 memcpy(
y, y0, dim *
sizeof(
REAL8));
1192 memcpy(dydt_in, dydt_in0, dim *
sizeof(
REAL8));
1198 memcpy(dydt_in, dydt_out, dim *
sizeof(
REAL8));
1202 if (cnt >= bufferlength) {
1211 for (
unsigned int i = 0; i <= dim; i++)
1212 memcpy(&rebuffers->
data[i * 2 * bufferlength], &buffers->
data[i * bufferlength], cnt *
sizeof(
REAL8));
1214 buffers = rebuffers;
1220 buffers->
data[cnt] = t;
1221 for (
unsigned int i = 1; i <= dim; i++)
1222 buffers->
data[i * bufferlength + cnt] =
y[i - 1];
1227 memcpy(yinit,
y, dim *
sizeof(
REAL8));
1233 interp = gsl_spline_alloc(gsl_interp_cspline, cnt + 1);
1234 accel = gsl_interp_accel_alloc();
1236 outputlen = (int)(t / deltat) + 1;
1239 if (!interp || !accel || !
output) {
1249 for (
int j = 0; j < outputlen; j++)
1250 times[j] = tinit + deltat * j;
1253 for (
unsigned int i = 1; i <= dim; i++) {
1254 gsl_spline_init(interp, &buffers->
data[0], &buffers->
data[bufferlength * i], cnt + 1);
1256 vector =
output->data + outputlen * i;
1257 for (
int j = 0; j < outputlen; j++) {
1258 gsl_spline_eval_e(interp, times[j], accel, &(vector[j]));
1307 UINT4 MaxRK4Steps = 1000000;
1313 unsigned int iStart, iCurrent;
1316 REAL8 tend = tend_in;
1319 size_t dim, bufferlength, cnt, retries;
1322 REAL8 *temp = NULL, *
y, *y0, *dydt_in, *dydt_in0, *dydt_out, *yerr;
1333 dim = integrator->
sys->dimension;
1334 bufferlength = MaxRK4Steps;
1338 if (!buffers || !temp) {
1345 dydt_in = temp + 2 * dim;
1346 dydt_in0 = temp + 3 * dim;
1347 dydt_out = temp + 4 * dim;
1348 yerr = temp + 5 * dim;
1351 integrator->
sys->params = params;
1356 retries = integrator->
retries;
1364 memcpy(
y, yinit, dim *
sizeof(
REAL8));
1371 iStart = MaxRK4Steps - 1;
1378 buffers->
data[iCurrent] = t;
1379 for (i = 1; i <= dim; i++)
1380 buffers->
data[i * bufferlength + iCurrent] =
y[i - 1];
1383 if ((
status = integrator->
dydt(t,
y, dydt_in, params)) != GSL_SUCCESS) {
1389 buffers->
data[i * bufferlength + iCurrent] = dydt_in[1];
1397 if (integrator->
stop) {
1398 if ((
status = integrator->
stop(t,
y, dydt_in, params)) != GSL_SUCCESS) {
1411 memcpy(y0,
y, dim *
sizeof(
REAL8));
1412 memcpy(dydt_in0, dydt_in, dim *
sizeof(
REAL8));
1415 status = gsl_odeiv_step_apply(integrator->
step, t, h0,
y, yerr, dydt_in, dydt_out, integrator->
sys);
1421 if (
status != GSL_SUCCESS) {
1430 retries = integrator->
retries;
1436 status = gsl_odeiv_control_hadjust(integrator->
control, integrator->
step,
y, yerr, dydt_out, &h0);
1440 if (
status == GSL_ODEIV_HADJ_DEC) {
1441 memcpy(
y, y0, dim *
sizeof(
REAL8));
1442 memcpy(dydt_in, dydt_in0, dim *
sizeof(
REAL8));
1448 memcpy(dydt_in, dydt_out, dim *
sizeof(
REAL8));
1453 if (cnt >= bufferlength) {
1462 for (i = 0; i <= dim; i++)
1463 memcpy(&rebuffers->
data[i * 2 * bufferlength], &buffers->
data[i * bufferlength], cnt *
sizeof(
REAL8));
1465 buffers = rebuffers;
1468 iCurrent += bufferlength;
1474 buffers->
data[iCurrent] = t;
1475 for (i = 1; i <= dim; i++)
1476 buffers->
data[i * bufferlength + iCurrent] =
y[i - 1];
1478 buffers->
data[i * bufferlength + iCurrent] = dydt_in[1];
1483 memcpy(yinit,
y, dim *
sizeof(
REAL8));
1489 outputlen = cnt + 1;
1507 for (i = 0; i <= dim + 1; i++) {
1508 memcpy(&(
output->data[i * outputlen]), &(buffers->
data[i * bufferlength + iStart]), outputlen *
sizeof(
REAL8));
static int storeStateInOutput(REAL8Array **output, REAL8 t, REAL8 *y, size_t dim, int *outputlen, int count)
static int shrinkOutput(REAL8Array **output, int *outputlen, int count, size_t dim)
int XLALPrintError(const char *fmt,...)
#define XLAL_CALLGSL(statement)
REAL8Array * XLALCreateREAL8ArrayL(UINT4,...)
void XLALDestroyREAL8Array(REAL8Array *)
int XLALAdaptiveRungeKutta4(LALAdaptiveRungeKuttaIntegrator *integrator, void *params, REAL8 *yinit, REAL8 tinit, REAL8 tend, REAL8 deltat, REAL8Array **yout)
void XLALAdaptiveRungeKuttaFree(LALAdaptiveRungeKuttaIntegrator *integrator)
int XLALAdaptiveRungeKutta4IrregularIntervals(LALAdaptiveRungeKuttaIntegrator *integrator, void *params, REAL8 *yinit, REAL8 tinit, REAL8 tend_in, REAL8Array **yout)
Fourth-order Runge-Kutta ODE integrator using Runge-Kutta-Fehlberg (RKF45) steps with adaptive step s...
LALAdaptiveRungeKuttaIntegrator * XLALAdaptiveRungeKutta4InitEighthOrderInstead(int dim, int(*dydt)(double t, const double y[], double dydt[], void *params), int(*stop)(double t, const double y[], double dydt[], void *params), double eps_abs, double eps_rel)
Eighth-order Runge-Kutta ODE integrator using Runge-Kutta-Fehlberg steps with adaptive step size cont...
int XLALAdaptiveRungeKutta4NoInterpolate(LALAdaptiveRungeKuttaIntegrator *integrator, void *params, REAL8 *yinit, REAL8 tinit, REAL8 tend, REAL8 deltat_or_h0, REAL8 min_deltat_or_h0, REAL8Array **t_and_y_out, INT4 EOBversion)
Fourth-order Runge-Kutta ODE integrator using Runge-Kutta-Fehlberg steps with adaptive step size cont...
int XLALAdaptiveRungeKuttaDenseandSparseOutput(LALAdaptiveRungeKuttaIntegrator *integrator, void *params, REAL8 *yinit, REAL8 tinit, REAL8 tend, REAL8 deltat, REAL8Array **sparse_output, REAL8Array **dense_output)
int XLALAdaptiveRungeKutta4HermiteOnlyFinal(LALAdaptiveRungeKuttaIntegrator *integrator, void *params, REAL8 *yinit, REAL8 tinit, REAL8 tend_in, REAL8 y1_final, REAL8 deltat)
Fourth-order Runge-Kutta ODE integrator using Runge-Kutta-Fehlberg (RKF45) steps with adaptive step s...
int XLALAdaptiveRungeKutta4Hermite(LALAdaptiveRungeKuttaIntegrator *integrator, void *params, REAL8 *yinit, REAL8 tinit, REAL8 tend_in, REAL8 deltat, REAL8Array **yout)
Fourth-order Runge-Kutta ODE integrator using Runge-Kutta-Fehlberg (RKF45) steps with adaptive step s...
LALAdaptiveRungeKuttaIntegrator * XLALAdaptiveRungeKutta4Init(int dim, int(*dydt)(double t, const double y[], double dydt[], void *params), int(*stop)(double t, const double y[], double dydt[], void *params), double eps_abs, double eps_rel)
uint64_t UINT8
Eight-byte unsigned integer; on some platforms this is equivalent to unsigned long int instead.
double REAL8
Double precision real floating-point number (8 bytes).
uint32_t UINT4
Four-byte unsigned integer.
int32_t INT4
Four-byte signed integer.
#define XLAL_ERROR_NULL(...)
Macro to invoke a failure from a XLAL routine returning a pointer.
#define XLAL_ERROR(...)
Macro to invoke a failure from a XLAL routine returning an integer.
@ XLAL_ENOMEM
Memory allocation error.
@ XLAL_EINVAL
Invalid argument.
@ XLAL_EFAILED
Generic failure.
gsl_odeiv_control * control
int(* stop)(double t, const double y[], double dydt[], void *params)
gsl_odeiv_evolve * evolve
int(* dydt)(double t, const double y[], double dydt[], void *params)
Multidimentional array of REAL8, see DATATYPE-Array types for more details.
REAL8 * data
Pointer to the data array.
void output(int gps_sec, int output_type)