Header file for libtpcmodel. More...

#include "tpcclibConfig.h"
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>
#include <math.h>
#include <float.h>
#include <sys/time.h>
#include <time.h>
#include "libtpcmisc.h"

Data Structures
struct	MERTWI

struct	bobyqa_data

struct	TGO_POINT

Macros
#define	MAX_PARAMETERS 50

#define	MAX_PARAMS MAX_PARAMETERS

#define	TPCCLIB_MERTWI_NN 312

#define	TPCCLIB_MERTWI_A UINT64_C(0xB5026F5AA96619E9)

#define	MTGA_BEST_MIN_NR 5

#define	DEFAULT_SAO2 0.97

#define	DEFAULT_P50HB 3.6

#define	DEFAULT_P50MB 0.319

#define	DEFAULT_NHB 2.7

#define	DEFAULT_CHB 150.0

#define	DEFAULT_CMB 4.7

Typedefs
typedef double(*	bobyqa_func) (int n, const double x, void func_data)

Enumerations
enum	bobyqa_result { BOBYQA_INVALID_ARGS = -1 , BOBYQA_OUT_OF_MEMORY = -2 , BOBYQA_ROUNDOFF_LIMITED = -3 , BOBYQA_FAIL = -4 , BOBYQA_SUCCESS = 0 , BOBYQA_MINF_MAX_REACHED = 1 , BOBYQA_FTOL_REACHED = 2 , BOBYQA_XTOL_REACHED = 3 , BOBYQA_MAXEVAL_REACHED = 4 , BOBYQA_RELFTOL_REACHED = 5 , BOBYQA_ABSFTOL_REACHED = 6 }

enum	linefit_method { PEARSON , PERP , LLSQWT , MEDIAN }

enum	linefit_range { PRESET , EXCLUDE_BEGIN , EXCLUDE_END }

Functions
uint32_t	mertwiSeed32 (void)
	Make uint32_t seed for pseudorandom number generators.

uint64_t	mertwiSeed64 (void)
	Make uint64_t seed for pseudorandom number generators.

void	mertwiInit (MERTWI *mt)

void	mertwiInitWithSeed64 (MERTWI *mt, uint64_t seed)
	Initialize the state vector mt[] inside data struct for Mersenne Twister MT19937 pseudorandom number generator using given seed.

void	mertwiInitByArray64 (MERTWI *mt, uint64_t init_key[], uint64_t key_length)
	Initialize the state vector mt[] inside data struct for Mersenne Twister MT19937 pseudorandom number generator using given array.

uint64_t	mertwiRandomInt64 (MERTWI *mt)
	Generate a random number on [0, 2^64-1]-interval using Mersenne Twister MT19937.

int64_t	mertwiRandomInt63 (MERTWI *mt)
	Generate a random number on [0, 2^63-1]-interval using Mersenne Twister MT19937.

double	mertwiRandomDouble1 (MERTWI *mt)
	Generate a 64-bit double precision floating point pseudorandom number in the range of [0,1] with uniform distribution using Mersenne Twister MT19937.

double	mertwiRandomDouble2 (MERTWI *mt)
	Generate a 64-bit double precision floating point pseudorandom number in the range of [0,1) with uniform distribution using Mersenne Twister MT19937.

double	mertwiRandomDouble3 (MERTWI *mt)
	Generate a 64-bit double precision floating point pseudorandom number in the range of (0,1) with uniform distribution using Mersenne Twister MT19937.

double	aicSS (double ss, const int n, const int k)

int	parFreeNr (const int n, double pLower, double pUpper)
	Calculate the number of free parameters.

int	aicWeights (double aic, double w, int n)

double	aicWeightedAvg (double w, double p, int n)

double	aicModel (double *w, int n)

bobyqa_result	bobyqb (bobyqa_data *bdata)

bobyqa_result	bobyqa (int n, int npt, double x, const double xl, const double xu, const double dx, const double rhoend, double xtol_rel, double minf_max, double ftol_rel, double ftol_abs, int maxeval, int nevals, double minf, double(f)(int n, double x, void objf_data), void objf_data, double *working_space, int verbose)

int	bobyqa_minimize_single_parameter (bobyqa_data *bdata)

char *	bobyqa_rc (bobyqa_result rc)

int	fixed_params (int n, const double lower, const double upper, const double *delta)

int	bobyqa_working_memory_size (int n, int fitted_n, int npt, bobyqa_data *bdata)

bobyqa_result	bobyqa_set_memory (int n, int fitted_n, int npt, bobyqa_data bdata, double wm)

bobyqa_result	bobyqa_free_memory (bobyqa_data *bdata)

bobyqa_result	bobyqa_reset_memory (bobyqa_data *bdata)

void	bobyqa_print (bobyqa_data bdata, int sw, FILE fp)

double	bobyqa_x_funcval (bobyqa_data bdata, double x)

void	bobyqa_xfull (bobyqa_data *bdata)

bobyqa_result	bobyqa_set_optimization (int full_n, double x, const double dx, const double xl, const double xu, const double rhoend, double xtol_rel, double minf_max, double ftol_rel, double ftol_abs, int maxeval, double(f)(int n, double x, void objf_data), void objf_data, int verbose, bobyqa_data *bdata)

int	bootstrap (int iterNr, double cLim1, double cLim2, double SD, double parameter, double lowlim, double uplim, int frameNr, double origTac, double fitTac, double bsTAC, int parNr, double weight, double(objf)(int, double , void ), char status, int verbose)

int	bvls (int key, const int m, const int n, double a, double b, double bl, double bu, double x, double w, double act, double zz, int istate, int iter, int verbose)
	Bounded-value least-squares method to solve the linear problem A x ~ b , subject to limit1 <= x <= limit2.

int	llsqWght (int N, int M, double *A, double a, double b, double weight)

int	llsqWghtSquared (int N, int M, double *A, double a, double b, double weight)

int	modelCheckParameters (int par_nr, double lower_p, double upper_p, double test_p, double accept_p, double *penalty)

int	modelCheckLimits (int par_nr, double lower_p, double upper_p, double *test_p)

int	fitExpDecayNNLS (double x, double y, int n, double fittime, double kmin, double kmax, int pnr, double a, double k, int *fnr, int verbose)
	Estimate initial values for sum of exponentials to be fitted on decaying x,y-data.

unsigned int	drandSeed (short int seed)
	Make and optionally set the seed for rand(), drand, drandRange, and drandGaussian().

double	gaussdev ()

double	gaussdev2 ()

void	init_gaussdev ()

double	drand ()

int	rand_range (int nr, double *d, double low, double up, int type)

double	householder_transform (double *v, int N)

int	householder_hm (double tau, double vector, double *matrix, int rowNr, int columnNr)

int	householder_hv (double tau, int size, double v, double w)

double	householder_norm (double *v, int size)

int	interpolate (double x, double y, int nr, double newx, double newy, double newyi, double newyii, int newnr)
	Linear interpolation and integration.

int	finterpolate (float x, float y, int nr, float newx, float newy, float newyi, float newyii, int newnr)
	float version of interpolate().

int	integrate (double x, double y, int nr, double *yi)

int	fintegrate (float x, float y, int nr, float *yi)
	float version of integrate().

int	petintegrate (double x1, double x2, double y, int nr, double newyi, double *newyii)

int	fpetintegrate (float x1, float x2, float y, int nr, float newyi, float *newyii)
	Calculates integrals of PET data at frame end times. Float version of petintegrate().

int	interpolate4pet (double x, double y, int nr, double newx1, double newx2, double newy, double newyi, double *newyii, int newnr)
	Interpolate and integrate TAC to PET frames.

int	finterpolate4pet (float x, float y, int nr, float newx1, float newx2, float newy, float newyi, float *newyii, int newnr)
	Interpolate and integrate TAC to PET frames. Float version of interpolate4pet().

int	petintegral (double x1, double x2, double y, int nr, double ie, double *iie)
	Integrate PET TAC data to frame mid times.

int	fpetintegral (float x1, float x2, float y, int nr, float ie, float *iie)
	Integrate PET TAC data to frame mid times. Float version of petintegral().

int	petintegrate2fe (double x1, double x2, double y, int nr, double e, double ie, double iie)
	Integrate PET TAC data to frame end times.

int	fpetintegrate2fe (float x1, float x2, float y, int nr, float e, float ie, float iie)
	Integrate PET TAC data to frame end times. Float version of petintegrate2fe().

int	llsqwt (double x, double y, int n, double wx, double wy, double tol, double w, double ic, double slope, double nwss, double sic, double sslope, double cx, double cy)

int	best_llsqwt (double x, double y, double wx, double wy, int nr, int min_nr, int mode, double slope, double ic, double nwss, double sslope, double sic, double cx, double cy, int bnr)

int	llsqperp (double x, double y, int nr, double slope, double ic, double *ssd)

int	llsqperp3 (double x, double y, int nr, double slope, double ic, double *ssd)

int	quadratic (double a, double b, double c, double m1, double m2)

int	medianline (double x, double y, int nr, double slope, double ic)

double	least_median_of_squares (double *data, int n)
	Fit a constant (horisontal straight line) to the data by minimising the median of squared residuals.

int	least_trimmed_square (double data[], long int n, double mean, double variance)

double	d_kth_smallest (double *data, int n, int k)

double	dmedian (double *data, int n)

double	dmean (double data, int n, double sd)

double	dmean_nan (double data, int n, double sd, int *vn)

double	mEstim (double *data, int nr, int iterNr, double cutoff)

double	huber (double x, double b)

int	patlak_data (int data_nr, double i, double ii, double c, double x, double *y)

int	logan_data (int data_nr, double i, double ii, double c, double ci, double k2, double x, double y)

int	mtga_best_perp (double x, double y, int nr, double slope, double ic, double ssd, int fnr)

int	nnls (double *a, int m, int n, double b, double x, double rnorm, double w, double zz, int *index)

int	nnlsWght (int N, int M, double *A, double b, double *weight)

int	nnlsWghtSquared (int N, int M, double *A, double b, double *sweight)

double	ndtr (double a)

double	normal_pvalue_2 (double x)

double	normal_pvalue_1 (double x)

int	pearson (double x, double y, int nr, double k, double kSD, double b, double bSD, double r, double ySD)

int	pearson2 (double x, double y, char is, int nr, double k, double kSD, double b, double bSD, double r, double *ySD)

int	pearson3 (double x, double y, int nr, double k, double kSD, double b, double bSD, double r, double ySD)

int	pearson4 (double x, double y, int nr, double start, double end, double k, double kSD, double b, double bSD, double r, double ySD)
	Calculate slope and intercept of a line and Pearson's correlation coefficient.

int	best_pearson (double x, double y, int nr, int min_nr, int first, int last, double k, double kSD, double b, double bSD, double r, double ySD)

int	mean (double x, double y, int nr, double xmean, double xsd, double ymean, double ysd)

int	regr_line (double x, double y, int n, double m, double c)

int	highest_slope (double x, double y, int n, int slope_n, double m, double c, double xi, double xh)

int	highest_slope_after (double x, double y, int n, int slope_n, double x_start, double m, double c, double xi, double xh)

int	powell (double p, double delta, int parNr, double ftol, int iterNr, double fret, double(_fun)(int, double , void ), void fundata, int verbose)

int	qrLSQ (double *mat, double rhs, double sol, const unsigned int rows, const unsigned int cols, double r2)
	QR least-squares solving routine.

int	qr (double *A, int m, int n, double B, double X, double rnorm, double tau, double res, double *wws, double ws)

int	qr_decomp (double *a, int M, int N, double tau, double *cchain, double chain)

int	qr_solve (double *QR, int M, int N, double tau, double b, double x, double residual, double resNorm, double *cchain, double chain)

int	qr_weight (int N, int M, double *A, double b, double weight, double ws)

int	qrLH (const unsigned int m, const unsigned int n, double a, double b, double x, double r2)
	Solve over-determined least-squares problem A x ~ b using successive Householder rotations.

int	runs_test (double data1, double data2, int N, double alpha, double *p)

int	residuals (double d1, double d2, int Nr, int Rnr, int Nminus, int *Nplus)

int	mrl_between_tacs (double y1[], double y2[], int n)

void	random_shuffle (int *array, int n)

void	randperm (int *array, int n, int a)

double	simplex (double(_fun)(double ), int parNr, double par, double delta, double maxerr, int maxiter, int verbose)

int	simC3s (double t, double ca, int nr, double k1, double k2, double k3, double k4, double k5, double k6, double ct, double cta, double ctb, double ctc)

int	simC3p (double t, double ca, int nr, double k1, double k2, double k3, double k4, double k5, double k6, double ct, double cta, double ctb, double ctc)

int	simC3vs (double t, double ca, double cb, int nr, double k1, double k2, double k3, double k4, double k5, double k6, double f, double vb, double fa, double cpet, double cta, double ctb, double ctc, double ctab, double *ctvb)

int	simC3vp (double t, double ca, double cb, int nr, double k1, double k2, double k3, double k4, double k5, double k6, double f, double vb, double fa, double cpet, double cta, double ctb, double ctc, double ctab, double *ctvb)

int	simC2l (double t, double ca, int nr, double k1, double k2, double k3, double kLoss, double ct, double cta, double *ctb)

int	simC2vl (double t, double ca, double cb, int nr, double k1, double k2, double k3, double kL, double f, double vb, double fa, double cpet, double cta, double ctb, double ctab, double ctvb)

int	simC3vpKLoss (double t, double ca, double cb, int nr, double k1, double k2, double k3, double k4, double k5, double k6, double kLoss, double f, double vb, double fa, double cpet, double cta, double ctb, double ctc, double ctab, double *ctvb)

int	simRTCM (double t, double cr, int nr, double R1, double k2, double k3, double k4, double ct, double cta, double *ctb)

int	simSRTM (double t, double cr, int nr, double R1, double k2, double BP, double *ct)

int	simTRTM (double t, double cr, int nr, double R1, double k2, double k3, double *ct)

int	simHuangmet (double t, double ctot, int nr, double k01, double k12, double k21, double k03, double k34, double k43, double c0, double c1, double *c3)

int	simTPCMOD0009c (double t, double ctot, int nr, double km, double k1m, double k2m, double k3m, double k4m, double ca, double cm)

int	simMBF (double t, double ci, int nr, double k1, double k2, double Vfit, double *ct)

int	simC1 (double t, double ca, int nr, double k1, double k2, double *ct)

int	simC3DIvs (double t, double ca1, double ca2, double cb, int nr, double k1, double k2, double k3, double k4, double k5, double k6, double k1b, double k2b, double f, double vb, double fa, double scpet, double sct1, double sct2, double sct3, double sct1b, double sctab, double *sctvb)

int	simC4DIvp (double t, double ca1, double ca2, double cb, int nr, double k1, double k2, double k3, double k4, double k5, double k6, double k7, double km, double k1b, double k2b, double f, double vb, double fa, double scpet, double sct1, double sct2, double sct3, double sct1b, double sctab, double *sctvb, int verbose)

int	simC4DIvs (double t, double ca1, double ca2, double cb, int nr, double k1, double k2, double k3, double k4, double k5, double k6, double k7, double km, double k1b, double k2b, double f, double vb, double fa, double scpet, double sct1, double sct2, double sct3, double sct1b, double sctab, double *sctvb, int verbose)

int	simDispersion (double x, double y, int n, double tau1, double tau2, double *tmp)

int	simOxygen (double t, double ca1, double ca2, double ca1i, double ca2i, const int n, const double k1a, const double k2a, const double km, const double k1b, const double k2b, const double vb, const double fa, double scpet, double sct1, double sct2, double sctab, double sctvb1, double sctvb2, double scvb1, double *scvb2, const int verbose)

double	mo2k1k2 (const double OER, const double SaO2, const double p50Hb, const double p50Mb, const double nHb, const double cHb, const double cMb, const int verbose)
	Calculates K1/k2 ratio for [O-15]O2 in muscle, based on OER.

double	mo2pO2 (const double OER, const double K1k2, const double SaO2, const double p50Mb, const double cHb, const double cMb, const int verbose)

int	tgo (double lowlim, double uplim, double(objf)(int, double , void ), void objfData, int dim, int neighNr, double fmin, double gmin, int samNr, int tgoNr, int verbose)

void	tgoRandomParameters (TGO_POINT p, int parNr, int sNr, double low, double *up)

void	tgoRandomParametersST (TGO_POINT p, int parNr, int sNr, double low, double *up)

int	nlopt1D (double(_fun)(double, void ), void _fundata, double x, double xl, double xu, double delta, double tol, const int maxeval, double nx, double *nf, int verbose)

Variables
long int	GAUSSDEV_SEED

int	TGO_SQUARED_TRANSF

int	TGO_LOCAL_INSIDE

int	TGO_LOCAL_OPT

Detailed Description

Header file for libtpcmodel.

Author: Vesa Oikonen

Definition in file libtpcmodel.h.

Macro Definition Documentation

◆ DEFAULT_CHB

#define DEFAULT_CHB 150.0

Hemoglobin concentration in blood (mg/g)

Definition at line 962 of file libtpcmodel.h.

◆ DEFAULT_CMB

#define DEFAULT_CMB 4.7

Myoglobin concentration in muscle (mg/g)

Definition at line 964 of file libtpcmodel.h.

◆ DEFAULT_NHB

#define DEFAULT_NHB 2.7

Hill coefficient n for hemoglobin

Definition at line 960 of file libtpcmodel.h.

◆ DEFAULT_P50HB

#define DEFAULT_P50HB 3.6

Half-saturation pressure p50 (kPa) for hemoglobin

Definition at line 956 of file libtpcmodel.h.

◆ DEFAULT_P50MB

#define DEFAULT_P50MB 0.319

Half-saturation pressure p50 (kPa) p50 for myoglobin

Definition at line 958 of file libtpcmodel.h.

◆ DEFAULT_SAO2

#define DEFAULT_SAO2 0.97

Arterial oxygen saturation fraction

Definition at line 954 of file libtpcmodel.h.

◆ MAX_PARAMETERS

#define MAX_PARAMETERS 50

Max nr of parameters

Definition at line 31 of file libtpcmodel.h.

Referenced by powell().

◆ MAX_PARAMS

#define MAX_PARAMS MAX_PARAMETERS

Max nr of parameters

Definition at line 35 of file libtpcmodel.h.

◆ MTGA_BEST_MIN_NR

#define MTGA_BEST_MIN_NR 5

Min nr of points in MTGA line fit

Definition at line 664 of file libtpcmodel.h.

Referenced by img_logan(), img_patlak(), and mtga_best_perp().

◆ TPCCLIB_MERTWI_A

#define TPCCLIB_MERTWI_A UINT64_C(0xB5026F5AA96619E9)

Mersenne Twister required constant

Definition at line 43 of file libtpcmodel.h.

Referenced by mertwiInit(), and mertwiRandomInt64().

◆ TPCCLIB_MERTWI_NN

#define TPCCLIB_MERTWI_NN 312

Mersenne Twister state vector length

Definition at line 41 of file libtpcmodel.h.

Referenced by mertwiInit().

Typedef Documentation

◆ bobyqa_func

typedef double(* bobyqa_func) (int n, const double *x, void *func_data)

BOBYQA objective function

Definition at line 92 of file libtpcmodel.h.

Enumeration Type Documentation

◆ bobyqa_result

enum bobyqa_result

BOBYQA return codes

Definition at line 77 of file libtpcmodel.h.

             {
   BOBYQA_INVALID_ARGS = -1,
   BOBYQA_OUT_OF_MEMORY = -2,
   BOBYQA_ROUNDOFF_LIMITED = -3,
   BOBYQA_FAIL = -4, /* generic fail code */
   BOBYQA_SUCCESS = 0, /* generic success code */
   BOBYQA_MINF_MAX_REACHED = 1,
   BOBYQA_FTOL_REACHED = 2,
   BOBYQA_XTOL_REACHED = 3,
   BOBYQA_MAXEVAL_REACHED = 4,
   BOBYQA_RELFTOL_REACHED = 5,
   BOBYQA_ABSFTOL_REACHED = 6
} bobyqa_result;

◆ linefit_method

enum linefit_method

MTGA line fit method

Enumerator
PEARSON	Traditional line fit, same as Pearson's correlation coefficient
PERP	Simple non-iterative perpendicular line fitting (Varga & Szabo, 2002)
LLSQWT	Iterative method for linear least-squares fit with errors in both coordinates (York 1966, Lybanon 1984, Reed 1992).
MEDIAN	Median-based distribution-free estimation of slope and intercept (Siegel, 1982); note that this is not LMS.

Definition at line 667 of file libtpcmodel.h.

             {
 
  PEARSON, 
 
  PERP,
 
  LLSQWT,
 
  MEDIAN
} linefit_method;

◆ linefit_range

enum linefit_range

MTGA line fit range

Definition at line 681 of file libtpcmodel.h.

             {
  PRESET, EXCLUDE_BEGIN, EXCLUDE_END
} linefit_range;

Function Documentation

◆ aicModel()

double aicModel	(	double *	w,
		int	n )

extern

Calculates a value describing the relative goodness of models, based on an array of model weights.

See also: aicSS, aicWeightedAvg, aicWeights

Returns: Returns the weighted average of model number.

Parameters

w	Array of weights
n	Length of array

Definition at line 132 of file aic.c.

  {
  int i;
  double avg;
 
  if(n<1 || w==NULL) avg=0.0;
  else for(i=0, avg=0.0; i<n; i++) avg+=w[i]*(double)(i+1);
  return(avg);
}

◆ aicSS()

double aicSS	(	double	ss,
		const int	n,
		const int	k )

extern

Computation of AICc in the special case of sum-of-squares optimization from the SS, nr of fitted points and nr of fitted parameters.

If variance is different between the data points, weighted SS must be given.

See also: parFreeNr, dftWSampleNr, aicWeights, aicWeightedAvg

Returns: Returns the AIC value.

Parameters

ss	Sum-of-Squares of the fit
n	Sample size, i.e. nr of fitted data points
k	Number of fitted model parameters; AICc calculation is valid only when (n-k)>1.

Definition at line 20 of file aic.c.

  {
  if(!(ss>=0.0) || n<1 || k<0 || (n-k)<2) return(nan(""));
 
  double aic=0.0, bias_adj, css;
  int dr, dv;
  
  dr=n-k-1; dv=2*k*(k+1);
  if(dr>0) bias_adj=((double)dv)/((double)dr); else bias_adj=0.0;
  if(ss<1.0e-50) css=1.0e-50; else css=ss; /* Because log(0) is an error */
  if(n>0) aic= n*log(css/(double)n) + 2.0*(double)k + bias_adj;
  return(aic);
}

Referenced by imgNoiseTemplate().

◆ aicWeightedAvg()

double aicWeightedAvg	(	double *	w,
		double *	p,
		int	n )

extern

Computation of the Akaike weighted model parameter average. Requires arrays of AIC weight values, and corresponding parameter values.

See also: aicSS, aicModel, aicWeights

Returns: Returns the weighted average.

Parameters

w	Array of weights
p	Array of parameters
n	Lengths of arrays

Definition at line 108 of file aic.c.

  {
  int i;
  double avg;
 
  /* Check data */
  if(n<1 || w==NULL || p==NULL) return(1);
  for(i=0, avg=0.0; i<n; i++) avg+=w[i]*p[i];
  return(avg);
}

◆ aicWeights()

int aicWeights	(	double *	aic,
		double *	w,
		int	n )

extern

Computation of the Akaike weights for model averaging. Requires an array of AIC values, and an output array for weights.

See also: aicSS, aicWeightedAvg, aicModel

Returns: Returns 0, if OK.

Parameters

aic	Array of AICs
w	Array of weights (output)
n	Lengths of arrays

Definition at line 74 of file aic.c.

  {
  int i, mini;
  double minaic, sume;
 
  /* Check data */
  if(n<1 || aic==NULL || w==NULL) return(1);
  if(n==1) {w[0]=1.0; return(0);}
  /* Find out which model gave the smallest AIC */
  mini=0; for(i=1; i<n; i++) if(aic[i]<aic[mini]) mini=i;
  minaic=aic[mini];
  /* Compute relative weights for each model */
  for(i=0, sume=0.0; i<n; i++) {
    w[i]=exp(-0.5*(aic[i]-minaic));
    sume+=w[i];
  }
  if(sume==0.0) return(2);
  for(i=0; i<n; i++) w[i]/=sume;
  return(0);
}

◆ best_llsqwt()

int best_llsqwt	(	double *	x,
		double *	y,
		double *	wx,
		double *	wy,
		int	nr,
		int	min_nr,
		int	mode,
		double *	slope,
		double *	ic,
		double *	nwss,
		double *	sslope,
		double *	sic,
		double *	cx,
		double *	cy,
		int *	bnr )

extern

Finds the best least-squares line to (x,y)-data, leaving points out either from the beginning (mode=0) or from the end (mode=1).

See also: llsqwt, llsqperp, medianline

Returns: Returns 0, if ok.

Parameters

x	Plot x axis values.
y	Plot y axis values.
wx	Weighting factors for x.
wy	Weighting factors for y.
nr	Nr of plot data points.
min_nr	Min nr of points to use in the fit; must be >=4.
mode	Leave out points from beginning (0) or from end (1).
slope	Slope is returned in here.
ic	Y axis intercept is returned in here.
nwss	sqrt(WSS)/wsum is returned here.
sslope	Expected sd of slope at calculated points.
sic	Expected sd of intercept at calculated points.
cx	Calculated x data points.
cy	Calculated y data points.
bnr	Number of points in the best fit (incl data with w=0).

Definition at line 294 of file llsqwt.c.

  {
  int from, to, ret, from_min, to_min;
  double *w, lic, lslope, lnwss=1.0E+100, nwss_min=1.0E+100;
 
  /* Check the data */
  if(x==NULL || y==NULL || nr<min_nr || nr<2) return(1);
  /* Check parameters */
  if(min_nr<4 || (mode!=0 && mode!=1)) return(2);
 
  /* Make room for work vector */
  w=(double*)malloc(nr*sizeof(double)); if(w==NULL) return(3);
 
  /* Search the plot range that gives the best nwss */
  nwss_min=9.99E+99; from_min=to_min=-1;
  if(mode==0) { /* Leave out plot data from the beginning */
    for(from=0, to=nr-1; from<nr-min_nr; from++) {
      ret=llsqwt(x+from, y+from, (to-from)+1, wx+from, wy+from, 1.0E-10, w,
                 &lic, &lslope, &lnwss, NULL, NULL, NULL, NULL);
      /*lnwss/=(double)((to-from)+1);*/
      if(0) printf("  range: %d-%d ; nwss=%g ; min=%g ; ret=%d\n", from, to, lnwss, nwss_min, ret);
      if(ret==0 && lnwss<nwss_min) {nwss_min=lnwss; from_min=from; to_min=to;}
    }
  } else { /* Leave out plot data from the end */
    for(from=0, to=min_nr-1; to<nr; to++) {
      ret=llsqwt(x+from, y+from, (to-from)+1, wx+from, wy+from, 1.0E-10, w,
                 &lic, &lslope, &lnwss, NULL, NULL, NULL, NULL);
      /*lnwss/=(double)((to-from)+1);*/
      if(0) printf("  range: %d-%d ; nwss=%g ; min=%g ; ret=%d\n", from, to, lnwss, nwss_min, ret);
      if(ret==0 && lnwss<nwss_min) {nwss_min=lnwss; from_min=from; to_min=to;}
    }
  }
  if(from_min<0) {free(w); return(4);}
 
  /* Run llsqwt() again with that range, now with better resolution      */
  /* and this time compute also SD's                                     */
  from=from_min; to=to_min;
  ret=llsqwt(x+from, y+from, (to-from)+1, wx+from, wy+from, 1.0E-15, w,
             ic, slope, nwss, sic, sslope, cx+from, cy+from);
  free(w);
  if(ret) return(5);
  *bnr=(to-from)+1;
 
  return(0);
}

◆ best_pearson()

int best_pearson	(	double *	x,
		double *	y,
		int	nr,
		int	min_nr,
		int *	first,
		int *	last,
		double *	k,
		double *	kSD,
		double *	b,
		double *	bSD,
		double *	r,
		double *	ySD )

extern

Find the best linear fit to double data (x[], y[]) with nr points.

Data may contain NaN's, which are not used.

See also: highest_slope, regr_line, pearson

Returns: Returns the nr of points actually used, or 0, in case of error.

Parameters

x	Data x values
y	Data y values
nr	Number of data sample values
min_nr	Minimum nr of data points to use
first	Index [0..last-2] of the first point to use initially, and after fitting
last	Index [first+1..nr-1] of the last point to use initially, and after fitting
k	slope
kSD	S.D. of slope
b	y axis intercept
bSD	S.D. of y axis intercept
r	Pearson's correlation coefficient, r
ySD	Residual variance of y values

Definition at line 252 of file pearson.c.

  {
  int i, n, m, x1, x2, b1, b2, bm;
  double *nx, *ny;
  double tk, tkSD, tb, tbSD, tr, tySD;
 
 
  if(0) {
    fprintf(stdout, "best_pearson(x, y, %d, %d, %d, %d, k, kSD, b, bSD, r, ySD)\n",
      nr, min_nr, *first, *last);
    fflush(stdout);
  }
  /* Remove NaN's and those outside range first-last */
  /* Allocate memory for new data pointers          */
  nx=(double*)calloc(nr, sizeof(double)); if(nx==NULL) return 0;
  ny=(double*)calloc(nr, sizeof(double)); if(ny==NULL) {free((char*)nx); return 0;}
  /* Copy data to pointers */
  if(*last>nr-1) *last=nr-1;
  if(*first<0) *first=0;
  for(i=*first, n=0; i<=*last; i++)
    if(!isnan(x[i]) && !isnan(y[i])) {nx[n]=x[i]; ny[n]=y[i]; n++;}
 
  /* Check that we have enough points */
  if(n<2 || n<min_nr) {free((char*)nx); free((char*)ny); return 0;}
  if(n==min_nr) {
    i=pearson(nx, ny, n, k, kSD, b, bSD, r, ySD);
    free((char*)nx); free((char*)ny);
    if(i) return 0; else return n;
  }
 
  /* OK, let's start  */
  *k=*kSD=*b=*bSD=*r=*ySD=0.; b1=b2=bm=0;
  for(x1=0, m=n; n-x1>min_nr; x1++) {
    /*printf("I x1=%i x2=%i m=%i n=%i\n", x1, x2, m, n);*/
    for(x2=n-1, m=x2-x1+1; m>=min_nr; x2--, m--) {
      if(pearson(nx+x1, ny+x1, m, &tk, &tkSD, &tb, &tbSD, &tr, &tySD))
        continue;
      if((tr>*r) ||
          (tr==*r && m>bm) ||
          (tr==*r && m==bm && x1>b1) ||
          (tr==*r && m==bm && x1==b1 && tk>*k) ) {
        bm=m; b1=x1; b2=x2;
        *k=tk; *kSD=tkSD; *b=tb; *bSD=tbSD; *r=tr; *ySD=tySD;
      }
      /*printf("Fit range: %2i-%2i  ;  best fit: %2i-%2i\n", x1, x2, b1, b2);*/
    }
  }
 
  /* Set first&last  */
  for(i=*first; i<=*last; i++)
    if(x[i]==nx[b1] && y[i]==ny[b1]) {*first=i; break;}
  for(i=*last; i>=*first; i--)
    if(x[i]==nx[b2] && y[i]==ny[b2]) {*last=i; break;}
  /*printf("FIRST=%i  LAST=%i\n", *first, *last);*/
 
  free((char*)nx); free((char*)ny);
  return bm;
}

◆ bobyqa()

bobyqa_result bobyqa	(	int	n,
		int	npt,
		double *	x,
		const double *	xl,
		const double *	xu,
		const double *	dx,
		const double	rhoend,
		double	xtol_rel,
		double	minf_max,
		double	ftol_rel,
		double	ftol_abs,
		int	maxeval,
		int *	nevals,
		double *	minf,
		double(*	f )(int n, double x, void objf_data),
		void *	objf_data,
		double *	working_space,
		int	verbose )

extern

BOBYQA is a derivative-free optimization code with constraints. This function interface is close to the one published by Powell.

Returns: Returns <0 in case of n error, >=0 when successful.

See also: simplex, powell, tgo, nlopt1D

Parameters

n	N must be set to the number of variables (and length of arrays below)
npt	NPT is the number of interpolation conditions. Its value must be in the interval [N+2,(N+1)(N+2)/2]. Choices that exceed 2N+1 are not recommended. If set to zero, then bobyqa uses 2N+1 as default. However, if very high precision is required, relatively high npt seems to be needed.
x	Initial values of the variables must be set in X(1),X(2),...,X(N). They will be changed to the values that give the least calculated F.
xl	Lower bounds for X[]: For I=1,2,...,N, XL(I) and XU(I) must provide the lower and upper bounds, respectively, on X(I). The construction of quadratic models requires XL(I) to be strictly less than XU(I) for each I. Further, the contribution to a model from changes to the I-th variable is damaged severely by rounding errors if XU(I)-XL(I) is too small. If xl[i]==xu[i]==x[i], then parameter x[i] is fixed to x[i] and left out of actual bobyqa procedure; parameter(s) can also be fixed by setting dx[i]=0.
xu	Upper bounds for X[]: For I=1,2,...,N, XL(I) and XU(I) must provide the lower and upper bounds, respectively, on X(I). The construction of quadratic models requires XL(I) to be strictly less than XU(I) for each I. Further, the contribution to a model from changes to the I-th variable is damaged severely by rounding errors if XU(I)-XL(I) is too small. If xl[i]==xu[i]==x[i], then parameter x[i] is fixed to x[i] and left out of actual bobyqa procedure; parameter(s) can also be fixed by setting dx[i]=0.
dx	Initial step sizes. dx should be set to 1/10 of probable distance from initial guess where the final solution could be; set dx to zero for those parameters that are to be fixed to their initial value. Too high values may lead to error.
rhoend	Rhoend must be set to the final value of a trust region radius, as a (positive) fraction of dx values given above, for example 1.0E-06. Smaller value adds precision and increases calculation time. Enter <=0 to use default value, calculated using xtol_rel.
xtol_rel	Relative X tolerance
minf_max	Stopping rule: maximal allowed function value; when reached, stops.
ftol_rel	Stopping rule: relative tolerance to function value
ftol_abs	Stopping rule: absolute tolerance to function value
maxeval	Stopping rule: max nr of function evaluations
nevals	Number of function evaluations; this function will initialize this to zero, and in the end returns the number. Enter NULL if not needed.
minf	Pointer where minimized function value will be written
f	Objective function has to be provided by the user. It must set F to the value of the objective function for the current values of the variables X(1),X(2),...,X(N), which are generated automatically in a way that satisfies the bounds given in XL and XU.
objf_data	Pointer to data that is carried over to the function. It is not needed or used by bobyqa. Enter NULL if not needed.
working_space	The array W will be used for working space. Its length can be calculated using function bobyqa_working_memory_size(). Enter NULL to leave allocating to this function.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout

Definition at line 40 of file bobyqa.c.

  {
  int i, j;
  int fixed_n, fitted_n;
  bobyqa_data bdata;
  bobyqa_result ret;
 
 
  if(verbose>0) printf("in bobyqa()\n");
  if(verbose>4) {
    printf("original dx={%g", dx[0]);
    for(j=1; j<n; j++) printf(", %g", dx[j]);
    printf("}\n");
  }
 
  /* Check if any of parameters is fixed:
     Only free parameters are given to Bobyqa for fitting, therefore
     the number is needed in allocating and setting up memory.
     BOBYQA requires that at least two parameters are fitted, but later
     a simple 1-D method is used instead when necessary */
  fixed_n=fixed_params(n, xl, xu, dx);
  fitted_n=n-fixed_n;
  if(verbose>1) {
    printf("%d parameter(s) are fixed.\n", fixed_n); fflush(stdout);
  }
  if(fitted_n<1) {
    if(verbose>0) fprintf(stderr, "Error: no free parameters.\n");
    return BOBYQA_INVALID_ARGS;
  }
  if(fitted_n==1 && verbose>0)
    fprintf(stderr, "Warning: only one free parameter.\n");
 
  /* Set npt, if user did not do that */
  if(npt<=0) npt=2*fitted_n+1;
  /* Verify that NPT is in the required interval */
  if(npt<fitted_n+2 || npt>(fitted_n+2)*(fitted_n+1)/2) {
    if(verbose>0) {
      printf("npt:=%d\n", npt);
      fprintf(stderr, "Error: bad npt.\n");
    }
    return(BOBYQA_INVALID_ARGS);
  }
 
  /* Allocate double working_space, if not done by caller */
  i=bobyqa_working_memory_size(n, fitted_n, npt, &bdata);
  ret=bobyqa_set_memory(n, fitted_n, npt, &bdata, working_space);
  if(ret!=BOBYQA_SUCCESS) return(BOBYQA_OUT_OF_MEMORY);
 
  /* Copy BOBYQA parameters to bdata struct */
  ret=bobyqa_set_optimization(n, x, dx, xl, xu, rhoend, xtol_rel,
                              minf_max, ftol_rel, ftol_abs, maxeval,
                              f, objf_data, verbose, &bdata);
  if(ret!=BOBYQA_SUCCESS) {
    bobyqa_free_memory(&bdata); return(BOBYQA_INVALID_ARGS);
  }
  if(verbose>2) bobyqa_print(&bdata, 4, stdout);
 
 
  /* Call BOBYQB */
  if(bdata.n>1) { // BOBYQA works only if at least 2 parameters are fitted
    ret = bobyqb(&bdata);
    if(bdata.verbose>1) printf("ret := %d\n", ret);
    if(bdata.verbose>0) {
      if(ret<0) printf("Error in bobyqb(): %s\n", bobyqa_rc(ret));
      else printf("Return code of bobyqb(): %s\n", bobyqa_rc(ret));
    }
  } else { // Simple local 1-D minimization when necessary
    ret=bobyqa_minimize_single_parameter(&bdata);
    if(bdata.verbose>1) printf("ret := %d\n", ret);
    if(bdata.verbose>0 && ret<0)
      printf("Error %d in 1-D optimization\n", ret);
  }
  /* Copy fitted parameters to full parameter list */
  bobyqa_xfull(&bdata);
  for(i=0; i<n; i++) x[i]=bdata.xfull[i];
  if(nevals!=NULL) *nevals=bdata.nevals;
  /* Copy min value to argument pointer */
  *minf=bdata.minf;
 
  /* Quit */
  if(verbose>1) {
    printf("prelim() called %d time(s)\n", bdata.prelim_nr);
    printf("rescue() called %d time(s)\n", bdata.rescue_nr);
    printf("altmov() called %d time(s)\n", bdata.altmov_nr);
    printf("trsbox() called %d time(s)\n", bdata.trsbox_nr);
    printf("update() called %d time(s)\n", bdata.update_nr);
  }
  bobyqa_free_memory(&bdata);
 
  if(verbose>0) printf("out of bobyqa() with return code %d\n", ret);
  return ret;
} /* bobyqa() */

Referenced by tgo().

◆ bobyqa_free_memory()

bobyqa_result bobyqa_free_memory ( bobyqa_data * bdata )

extern

Free the working memory and memory for data arrays and matrices in BOBYQA structure that was allocated by bobyqa_allocate_memory().

Returns: Returns BOBYQA_SUCCESS when successful.

Parameters

bdata Pointer to bobyqa struct

Definition at line 592 of file bobyqa.c.

  {
  if(bdata==NULL) return BOBYQA_INVALID_ARGS;
  /* Free double working memory, if it was allocated by bobyqa_set_memory() */
  if(bdata->lwmptr!=NULL) free(bdata->lwmptr);
  bdata->lwmptr=NULL;
  /* Free integer working memory */
  if(bdata->liwmptr!=NULL) free(bdata->liwmptr);
  bdata->liwmptr=NULL;
  return BOBYQA_SUCCESS;
}

Referenced by bobyqa(), and bobyqa_set_memory().

◆ bobyqa_minimize_single_parameter()

int bobyqa_minimize_single_parameter ( bobyqa_data * bdata )

extern

Local one-dimensional minimization, meant to be called from bobyqa() which does not otherwise work with 1-D problems.

Returns: BOBYQA_SUCCESS, BOBYQA_INVALID_ARGS, etc.

See also: nlopt1D

Definition at line 210 of file bobyqa.c.

  {
  if(bdata->verbose>0) {printf("bobyqa_minimize_single_parameter()\n"); fflush(stdout);}
 
  double p1=0, p2=0, p3=0, f1=0, f2=0, f3=0, begin, end;
  double d, d2;
  const double tau=0.1;
  double p_min, f_min, bracket_ratio;
 
  /* Check the input */
  if(bdata->n!=1) return BOBYQA_INVALID_ARGS;
  if(bdata->rhoend<=0.0) return BOBYQA_INVALID_ARGS;
  if(bdata->rhoend>=bdata->rhobeg) return BOBYQA_INVALID_ARGS;
  if(bdata->maxeval<2) return BOBYQA_INVALID_ARGS;
 
  begin=bdata->xl[0];
  end=bdata->xu[0];
 
  /* Update the full parameter list for objf() */
  bdata->nevals=0;
  f2 = bdata->minf = bobyqa_x_funcval(bdata, bdata->x);
  /* If parameter is fixed, then this was all that we can do */
  if(bdata->xl[0]>=bdata->xu[0]) {
    if(bdata->verbose>1) printf("Warning: the only parameter is fixed\n");
    return BOBYQA_SUCCESS;
  }
 
  /* Find three bracketing points such that f1 > f2 < f3.
     Do this by generating a sequence of points expanding away from 0.
     Also note that, in the following code, it is always the
     case that p1 < p2 < p3. */
  p2=bdata->x[0];
 
  /* Start by setting a starting set of 3 points that are inside the bounds */
  p1=p2-bdata->rhobeg; if(p1>begin) p1=begin;
  p3=p2+bdata->rhobeg; if(p3<end) p3=end;
  /* Compute their function values */
  bdata->x[0]=p1;
  f1 = bdata->minf = bobyqa_x_funcval(bdata, bdata->x);
  bdata->x[0]=p3;
 
  f3 = bdata->minf = bobyqa_x_funcval(bdata, bdata->x);
 
  if(p2==p1 || p2==p3) {
    p2=0.5*(p1+p3);
    bdata->x[0]=p2;
    f2 = bdata->minf = bobyqa_x_funcval(bdata, bdata->x);
  }
 
  /* Now we have 3 points on the function. 
     Start looking for a bracketing set such that f1 > f2 < f3 is the case. */
  double jump_size=bdata->rhobeg;
  while(!(f1>f2 && f2<f3)) {
    /* check for hitting max_iter */
    if(bdata->verbose>5) printf("  bracketing: nevals=%d\n", bdata->nevals);
    if(bdata->nevals >= bdata->maxeval) {
      bdata->x[0]=p2; bdata->minf=f2; return BOBYQA_MAXEVAL_REACHED;
    }
    /* check if required tolerance was reached */
    if((p3-p1)<bdata->rhoend) { //if (p3-p1 < eps)
      if(bdata->verbose>1)
        printf("  max tolerance was reached during bracketing\n");
      if(f1<f2 && f1<f3) {
        bdata->x[0]=p1; bdata->minf=f1; return BOBYQA_XTOL_REACHED;
      }
      if(f2<f1 && f2<f3) {
        bdata->x[0]=p2; bdata->minf=f2; return BOBYQA_XTOL_REACHED;
      }
      bdata->x[0]=p3; bdata->minf=f3; return BOBYQA_XTOL_REACHED;
    }
    if(bdata->verbose>6) printf("    jump_size=%g\n", jump_size);
    /* if f1 is small then take a step to the left */
    if(f1<f3) { 
      /* check if the minimum is colliding against the bounds. If so then pick
         a point between p1 and p2 in the hopes that shrinking the interval will
         be a good thing to do.  Or if p1 and p2 aren't differentiated then try
         and get them to obtain different values. */
      if(p1==begin || (f1==f2 && (end-begin)<jump_size )) {
        p3=p2; f3=f2; p2=0.5*(p1+p2);
        bdata->x[0]=p2;
        f2 = bdata->minf = bobyqa_x_funcval(bdata, bdata->x);
      } else {
        /* pick a new point to the left of our current bracket */
        p3=p2; f3=f2; p2=p1; f2=f1;
        p1-=jump_size; if(p1<begin) p1=begin;
        bdata->x[0]=p1;
        f1 = bobyqa_x_funcval(bdata, bdata->x);
        jump_size*=2.0;
      }
    } else { // otherwise f3 is small and we should take a step to the right
      /* check if the minimum is colliding against the bounds. If so then pick
         a point between p2 and p3 in the hopes that shrinking the interval will
         be a good thing to do.  Or if p2 and p3 aren't differentiated then
         try and get them to obtain different values. */
      if(p3==end || (f2==f3 && (end-begin)<jump_size)) {
        p1=p2; f1=f2; p2=0.5*(p3+p2);
        bdata->x[0]=p2;
        f2 = bdata->minf = bobyqa_x_funcval(bdata, bdata->x);
      } else {
        /* pick a new point to the right of our current bracket */
        p1=p2; f1=f2; p2=p3; f2=f3;
        p3+=jump_size; if(p3>end) p3=end;
        bdata->x[0]=p3;
        f3 = bdata->minf = bobyqa_x_funcval(bdata, bdata->x);
        jump_size*=2.0;
      }
    }
  }
  if(bdata->verbose>4) printf("  brackets ready\n");
 
  /* Loop until we have done the max allowable number of iterations or
     the bracketing window is smaller than eps.
     Within this loop we maintain the invariant that: f1 > f2 < f3 and 
     p1 < p2 < p3. */
  while((bdata->nevals<bdata->maxeval) && (p3-p1>bdata->rhoend)) {
    if(bdata->verbose>5) printf("  main loop: nevals=%d\n", bdata->nevals);
 
    //p_min = lagrange_poly_min_extrap(p1,p2,p3, f1,f2,f3);
    d=f1*(p3*p3-p2*p2) + f2*(p1*p1-p3*p3) + f3*(p2*p2-p1*p1);
    d2=2.0*(f1*(p3-p2) + f2*(p1-p3) + f3*(p2-p1));
    if(d2==0.0 || !isfinite(d/=d2)) { // d=d/d2
      p_min=p2;
    } else {
      if(p1<=d && d<=p3) {p_min=d;}
      else {p_min=d; if(p1>p_min) p_min=p1; if(p3<p_min) p_min=p3;}
    }
 
    /* make sure p_min isn't too close to the three points we already have */
    if(p_min<p2) {
      d=(p2-p1)*tau;
      if(fabs(p1-p_min)<d) p_min=p1+d;
      else if(fabs(p2-p_min)<d) p_min=p2-d;
    } else {
      d=(p3-p2)*tau;
      if(fabs(p2-p_min)<d) p_min=p2+d;
      else if(fabs(p3-p_min)<d) p_min=p3-d;
    }
 
    /* make sure one side of the bracket isn't super huge compared to the other
       side.  If it is then contract it. */
    bracket_ratio=fabs(p1-p2)/fabs(p2-p3);
    if(!(bracket_ratio<100.0 && bracket_ratio>0.01)) {
      /* Force p_min to be on a reasonable side. */
      if(bracket_ratio>1.0 && p_min>p2) p_min=0.5*(p1+p2);
      else if(p_min<p2) p_min=0.5*(p2+p3);
    }
 
    /* Compute function value at p_min */
    bdata->x[0]=p_min;
    f_min = bdata->minf = bobyqa_x_funcval(bdata, bdata->x);
 
    /* Remove one of the endpoints of our bracket depending on where the new point falls */
    if(p_min<p2) {
      if(f1>f_min && f_min<f2) {p3=p2; f3=f2; p2=p_min; f2=f_min;}
      else {p1=p_min; f1 = f_min;}
    } else {
      if(f2>f_min && f_min<f3) {p1=p2; f1=f2; p2=p_min; f2=f_min;}
      else {p3=p_min; f3=f_min;}
    }
  }
  bdata->x[0]=p2; bdata->minf=f2;
  if(bdata->nevals>=bdata->maxeval) return BOBYQA_MAXEVAL_REACHED;
  return BOBYQA_XTOL_REACHED;
}

Referenced by bobyqa().

◆ bobyqa_print()

void bobyqa_print	(	bobyqa_data *	bdata,
		int	sw,
		FILE *	fp )

extern

For testing: print BOBYQA data struct variables to specified file pointer.

Parameters

bdata	Pointer to bobyqa structure.
sw	Switch that tells what to print: 0=All; 1=parameters; 2=array sizes; 3=full parameter list; 4=fitted parameters, limits and deltas.
fp	File pointer where contents are printed; usually stdout.

Definition at line 640 of file bobyqa.c.

  {
  int i;
 
  if(bdata==NULL) {
    fprintf(fp, "bobyqa data struct not defined.\n");
    return;
  }
 
  if(sw==0 || sw==1) {
    fprintf(fp, "nfull=%d\n", bdata->nfull);
    fprintf(fp, "n=%d\n", bdata->n);
    fprintf(fp, "npt=%d\n", bdata->npt);
    fprintf(fp, "ndim=%d\n", bdata->ndim);
  }
 
  if(sw==0 || sw==2) {
    fprintf(fp, "nfull=%d\n", bdata->nfull);
    fprintf(fp, "x_size=%d\n", bdata->x_size);
    fprintf(fp, "xl_size=%d\n", bdata->xl_size);
    fprintf(fp, "xu_size=%d\n", bdata->xu_size);
    fprintf(fp, "xbase_size=%d\n", bdata->xbase_size);
    fprintf(fp, "xpt_size=%d\n", bdata->xpt_size);
    fprintf(fp, "fval_size=%d\n", bdata->fval_size);
    fprintf(fp, "xopt_size=%d\n", bdata->xopt_size);
    fprintf(fp, "gopt_size=%d\n", bdata->gopt_size);
    fprintf(fp, "hq_size=%d\n", bdata->hq_size);
    fprintf(fp, "pq_size=%d\n", bdata->pq_size);
    fprintf(fp, "bmat_size=%d\n", bdata->bmat_size);
    fprintf(fp, "zmat_size=%d\n", bdata->zmat_size);
    fprintf(fp, "sl_size=%d\n", bdata->sl_size);
    fprintf(fp, "su_size=%d\n", bdata->su_size);
    fprintf(fp, "xnew_size=%d\n", bdata->xnew_size);
    fprintf(fp, "xalt_size=%d\n", bdata->xalt_size);
    fprintf(fp, "dtrial_size=%d\n", bdata->dtrial_size);
    fprintf(fp, "vlag_size=%d\n", bdata->vlag_size);
    fprintf(fp, "w2npt_size=%d\n", bdata->w2npt_size);
    fprintf(fp, "wndim_size=%d\n", bdata->wndim_size);
    fprintf(fp, "wn_size=%d\n", bdata->wn_size);
    fprintf(fp, "gnew_size=%d\n", bdata->gnew_size);
    fprintf(fp, "xbdi_size=%d\n", bdata->xbdi_size);
    fprintf(fp, "s_size=%d\n", bdata->s_size);
    fprintf(fp, "hs_size=%d\n", bdata->hs_size);
    fprintf(fp, "hred_size=%d\n", bdata->hred_size);
    fprintf(fp, "glag_size=%d\n", bdata->hred_size);
    fprintf(fp, "hcol_size=%d\n", bdata->hcol_size);
    fprintf(fp, "ccstep_size=%d\n", bdata->ccstep_size);
    fprintf(fp, "xscale_size=%d\n", bdata->xscale_size);
  }
 
  if(sw==0 || sw==3) {
    fprintf(fp, "full parameter list:\n");
    for(i=0; i<bdata->nfull; i++) {
      fprintf(fp, "  xfull[%d] = %g\n", i, bdata->xfull[i]);
    }
  }
 
  if(sw==0 || sw==4) {
    fprintf(fp, "fitted parameter indices =");
    for(i=0; i<bdata->n; i++) {
      fprintf(fp, "  xplace[%d] = %d\n", i, bdata->xplace[i]);
    }
    fprintf(fp, "fitted parameter list:\n");
    for(i=0; i<bdata->n; i++) {
      fprintf(fp, "  x[%d] = %g\n", i, bdata->x[i]);
    }
    fprintf(fp, "lower limits:\n");
    for(i=0; i<bdata->n; i++) {
      fprintf(fp, "  xl[%d] = %g\n", i, bdata->xl[i]);
    }
    fprintf(fp, "upper limits:\n");
    for(i=0; i<bdata->n; i++) {
      fprintf(fp, "  xu[%d] = %g\n", i, bdata->xu[i]);
    }
    fprintf(fp, "rescaling factors:\n");
    for(i=0; i<bdata->n; i++) {
      fprintf(fp, "  xscale[%d] = %g\n", i, bdata->xscale[i]);
    }
    fprintf(fp, "rhobeg=%g\n", bdata->rhobeg);
    fprintf(fp, "rhoend=%g\n", bdata->rhoend);
 
    fprintf(fp, "scaled lower bounds:\n");
    for(i=0; i<bdata->n; i++) {
      fprintf(fp, "  sl[%d] = %g\n", i, bdata->sl[i]);
    }
    fprintf(fp, "scaled upper bounds:\n");
    for(i=0; i<bdata->n; i++) {
      fprintf(fp, "  su[%d] = %g\n", i, bdata->su[i]);
    }
  }
 
  return;
}

Referenced by bobyqa().

◆ bobyqa_rc()

char * bobyqa_rc ( bobyqa_result rc )

extern

Description of bobyqa return code as text string.

Returns: Returns text string describing the bobyqa return code.

Definition at line 381 of file bobyqa.c.

  {
  static char *bobyqa_msg[] = {
  /*  0 */ "failure",
  /*  1 */ "invalid argument",
  /*  2 */ "out of memory",
  /*  3 */ "round-off limited",
  /*  4 */ "success",
  /*  5 */ "requested function value reached",
  /*  6 */ "function value tolerance reached",
  /*  7 */ "relative function value tolerance reached",
  /*  8 */ "absolute function value tolerance reached",
  /*  9 */ "parameter tolerance reached",
  /* 10 */ "maximum number of function evaluations reached",
  0};
  switch(rc) {
    case BOBYQA_FAIL:             return bobyqa_msg[0];
    case BOBYQA_INVALID_ARGS:     return bobyqa_msg[1];
    case BOBYQA_OUT_OF_MEMORY:    return bobyqa_msg[2];
    case BOBYQA_ROUNDOFF_LIMITED: return bobyqa_msg[3];
    case BOBYQA_SUCCESS:          return bobyqa_msg[4];
    case BOBYQA_MINF_MAX_REACHED: return bobyqa_msg[5];
    case BOBYQA_FTOL_REACHED:     return bobyqa_msg[6];
    case BOBYQA_RELFTOL_REACHED:  return bobyqa_msg[7];
    case BOBYQA_ABSFTOL_REACHED:  return bobyqa_msg[8];
    case BOBYQA_XTOL_REACHED:     return bobyqa_msg[9];
    case BOBYQA_MAXEVAL_REACHED:  return bobyqa_msg[10];
  }
  return bobyqa_msg[0];
}

Referenced by bobyqa().

◆ bobyqa_reset_memory()

bobyqa_result bobyqa_reset_memory ( bobyqa_data * bdata )

extern

Initiate BOBYQA data struct variables before calling bobyqb(). Can be used to reset data variables before calling bobyqb() again with the same problem size, without need to call bobyqa_free_memory() and bobyqa_set_memory() first.

Returns: Returns BOBYQA_SUCCESS when successful.

Parameters

bdata Pointer to bobyqa struct

Definition at line 614 of file bobyqa.c.

  {
 
  if(bdata==NULL) return BOBYQA_INVALID_ARGS;
  if(bdata->npt<1 || bdata->n<1) return BOBYQA_INVALID_ARGS;
 
  /* Initiate struct variables */
  bdata->dsq=0.0;
  bdata->xoptsq=0.0;
  bdata->rc = BOBYQA_SUCCESS;
  bdata->knew = 0;
  bdata->scaden = 0.0;
  bdata->biglsq = 0.0;
  bdata->nptm = bdata->npt - (bdata->n+1);
  bdata->nevals=0;
  bdata->rescue_nr=bdata->altmov_nr=bdata->trsbox_nr=bdata->update_nr=0;
  bdata->prelim_nr=0;
 
  return BOBYQA_SUCCESS;
}

Referenced by bobyqa_set_memory().

◆ bobyqa_set_memory()

bobyqa_result bobyqa_set_memory	(	int	n,
		int	fitted_n,
		int	npt,
		bobyqa_data *	bdata,
		double *	wm )

extern

Setup working memory and memory for data arrays and matrices in BOBYQA structure. Double memory is either allocated inside this function or preallocated memory can be given as argument.

Returns: Returns BOBYQA_SUCCESS when successful.

Parameters

n	Number of all model parameters.
fitted_n	Number of fitted (not fixed) model parameters.
npt	NPT.
bdata	Pointer to bobyqa structure.
wm	Enter pointer to preallocated working memory; NULL to allocate it here.

Definition at line 501 of file bobyqa.c.

  {
  int wmsize;
  double *lwm, *wptr;
  int *liwm;
 
  if(n<1 || fitted_n<1 || npt<1 || bdata==NULL) return BOBYQA_INVALID_ARGS;
 
  /* Determine the required size of working memory and set the sizes inside data struct */
  wmsize=bobyqa_working_memory_size(n, fitted_n, npt, bdata);
 
  /* If working memory for doubles is not preallocated, then allocate it */
  if(wm!=NULL) {
    lwm=wm; bdata->lwmptr=NULL;
  } else {
    /* Allocate working memory */
    lwm=(double*)malloc(sizeof(double)*wmsize);
    if(lwm==NULL) {
      return(BOBYQA_OUT_OF_MEMORY);
    }
    bdata->lwmptr=lwm;
  }
  bdata->wmptr=lwm;
 
  /* Working memory for integers is always allocated here */
  liwm=(int*)malloc(sizeof(int)*fitted_n);
  if(liwm==NULL) {
    if(wm==NULL) bobyqa_free_memory(bdata);
    return(BOBYQA_OUT_OF_MEMORY);
  }
  bdata->liwmptr=liwm;
 
  /* Set data pointers inside bobyqa struct */
  bdata->xplace=bdata->liwmptr;
  wptr=bdata->wmptr;
  bdata->xfull=wptr; wptr+=bdata->nfull;
  bdata->x=wptr; wptr+=bdata->x_size;
  bdata->xl=wptr; wptr+=bdata->xl_size;
  bdata->xu=wptr; wptr+=bdata->xu_size;
  bdata->xbase=wptr; wptr+=bdata->xbase_size;                
  bdata->xpt=wptr; wptr+=bdata->xpt_size;
  bdata->fval=wptr; wptr+=bdata->fval_size;        
  bdata->xopt=wptr; wptr+=bdata->xopt_size;
  bdata->gopt=wptr; wptr+=bdata->gopt_size;  
  bdata->hq=wptr; wptr+=bdata->hq_size;
  bdata->pq=wptr; wptr+=bdata->pq_size;
  bdata->bmat=wptr; wptr+=bdata->bmat_size;
  bdata->zmat=wptr; wptr+=bdata->zmat_size;
  bdata->sl=wptr; wptr+=bdata->sl_size;
  bdata->su=wptr; wptr+=bdata->su_size;
  bdata->xnew=wptr; wptr+=bdata->xnew_size;
  bdata->xalt=wptr; wptr+=bdata->xalt_size;
  bdata->dtrial=wptr; wptr+=bdata->dtrial_size;
  bdata->vlag=wptr; wptr+=bdata->vlag_size;
  bdata->w2npt=wptr; wptr+=bdata->w2npt_size;
  bdata->wndim=wptr; wptr+=bdata->wndim_size;
  bdata->wn=wptr; wptr+=bdata->wn_size;
  bdata->gnew=wptr; wptr+=bdata->gnew_size;
  bdata->xbdi=wptr; wptr+=bdata->xbdi_size;
  bdata->s=wptr; wptr+=bdata->s_size;
  bdata->hs=wptr; wptr+=bdata->hs_size;
  bdata->hred=wptr; wptr+=bdata->hred_size;
  bdata->glag=wptr; wptr+=bdata->glag_size;
  bdata->hcol=wptr; wptr+=bdata->hcol_size;
  bdata->ccstep=wptr; wptr+=bdata->ccstep_size;
  bdata->xscale=wptr; wptr+=bdata->xscale_size;
 
  /* Set struct contents */
  bdata->n=fitted_n;
  bdata->nfull=n;
  bdata->npt=npt;
  bdata->ndim = npt+fitted_n;
  if(bobyqa_reset_memory(bdata)!=BOBYQA_SUCCESS) return BOBYQA_INVALID_ARGS;
 
  return BOBYQA_SUCCESS;
}

Referenced by bobyqa().

◆ bobyqa_set_optimization()

bobyqa_result bobyqa_set_optimization	(	int	full_n,
		double *	x,
		const double *	dx,
		const double *	xl,
		const double *	xu,
		const double	rhoend,
		double	xtol_rel,
		double	minf_max,
		double	ftol_rel,
		double	ftol_abs,
		int	maxeval,
		double(*	f )(int n, double x, void objf_data),
		void *	objf_data,
		int	verbose,
		bobyqa_data *	bdata )

extern

Set optimization parameters and limits in BOBYQA data struct.

Returns: Returns BOBYQA_SUCCESS when successful.

Parameters

full_n	Length of full parameter list.
x	Pointer to array of full parameters.
dx	Pointer to array of initial step sizes (deltas).
xl	Pointer to array of lower limits.
xu	Pointer to array of upper limits.
rhoend	Rhoend; enter <=0 to use default value, calculated using xtol_rel.
xtol_rel	Relative X tolerance.
minf_max	Stopping rule: maximal allowed function value; when reached, stops.
ftol_rel	Stopping rule: relative tolerance to function value.
ftol_abs	Stopping rule: absolute tolerance to function value.
maxeval	Stopping rule: max nr of function evaluations.
f	Pointer to object function
objf_data	Pointer to data that is carried over to the object function. Enter NULL if not needed.
verbose	Verbose level for all BOBYQA functions; if zero, then nothing is printed to stderr or stdout
bdata	Pointer to bobyqa structure.

Definition at line 781 of file bobyqa.c.

  {
  int i, j;
  double d, dm;
 
  if(bdata==NULL) return BOBYQA_INVALID_ARGS;
  if(full_n!=bdata->nfull) return BOBYQA_INVALID_ARGS;
  if(x==NULL || dx==NULL) return BOBYQA_INVALID_ARGS;
  if(xl==NULL || xu==NULL) return BOBYQA_INVALID_ARGS;
 
  /* Copy full parameter list */
  for(i=0; i<full_n; i++) bdata->xfull[i]=x[i];
 
  /* Make list of fitted parameters (those that are not fixed);
     and internal list of their positions in full list;
     and rescaling factor for each dimension based on initial step size
     so that initial step size would be equal in all directions
  */
  for(i=j=0; i<full_n; i++) if(dx[i]!=0.0 && xu[i]>xl[i]) {
    /* Positions in full list */
    bdata->xplace[j]=i;
    /* Set scaling factors */
    bdata->xscale[j]=fabs(dx[i]);
    /* Set initial scaled parameters */
    bdata->x[j]=x[i]/bdata->xscale[j];
    /* Set scaled limits */
    bdata->xl[j]=xl[i]/bdata->xscale[j];
    bdata->xu[j]=xu[i]/bdata->xscale[j];
    j++; // index of fitted parameters
  } // next parameter
  /* check that nr of fitted parameters is the same that was used to
     allocate memory in the data struct */
  if(j!=bdata->n) return BOBYQA_INVALID_ARGS;
 
  /* Initial step sizes are now internally scaled to 1, therefore: */
  bdata->rhobeg = 1.0;
  /* however, 2*rhobeg must be <= xu[]-xl[] */
  j=0; dm=bdata->xu[j]-bdata->xl[j];
  for(j=1; j<bdata->n; j++) {d=bdata->xu[j]-bdata->xl[j]; if(d<dm) dm=d;}
  if(dm < 2.*bdata->rhobeg) {
    if(dm>1.0E-20) {
      /* Set smaller rhobeg to have sufficient space between the bounds */
      bdata->rhobeg=0.5*dm;
    } else {
      /* Return from BOBYQA because one of the differences
         XU(I)-XL(I)s is less than 2*RHOBEG, and very small, too. */
      if(verbose>0) fprintf(stderr, "Error: stepsize<2*rhobeg\n");
      printf("smallest stepsize=%g 2*rhobeg=%g\n", dm, 2.*bdata->rhobeg);
      return(BOBYQA_INVALID_ARGS);
    }
  }
 
  /* Set rhoend; if not given by caller, then compute rhoend from
     optimization stop info */
  if(rhoend>0.0) bdata->rhoend=rhoend;
  else bdata->rhoend = xtol_rel * bdata->rhobeg;
  if(!isfinite(bdata->rhoend)) bdata->rhoend=1.0E-14;
 
  /* Return error if there is insufficient space between the bounds.
     Modify the initial estimates X[], if necessary, in order to avoid
     conflicts between the bounds and the construction of the first quadratic
     model.
     The lower and upper bounds (sl[], su[]) on moves from the updated X[]
     are set now, in order to provide useful and exact information about
     components of X[] that become within distance RHOBEG from their bounds. */
  for(j=0; j<bdata->n; j++) {
    d=bdata->xu[j]-bdata->xl[j];
    /* Set sl and su */
    bdata->sl[j]= bdata->xl[j]-bdata->x[j];
    bdata->su[j] = bdata->xu[j]-bdata->x[j];
    if(bdata->sl[j] >= -bdata->rhobeg) {
      if(bdata->sl[j] >= 0.0) {
        bdata->x[j]=bdata->xl[j];
        bdata->sl[j]=0.0;
        bdata->su[j]=d;
      } else {
        bdata->x[j]=bdata->xl[j]+bdata->rhobeg;
        bdata->sl[j]=-bdata->rhobeg;
        bdata->su[j]=fmax(bdata->xu[j]-bdata->x[j], bdata->rhobeg);
      }
    } else if(bdata->su[j] <= bdata->rhobeg) {
      if(bdata->su[j] <= 0.0) {
        bdata->x[j]=bdata->xu[j];
        bdata->sl[j]=-d;
        bdata->su[j]=0.0;
      } else {
        bdata->x[j]=bdata->xu[j]-bdata->rhobeg;
        bdata->sl[j]=fmin(bdata->xl[j]-bdata->x[j], -bdata->rhobeg);
        bdata->su[j]=bdata->rhobeg;
      }
    }
  }
 
  bdata->verbose=verbose;
  bdata->minf_max=minf_max;
  bdata->ftol_rel=ftol_rel;
  bdata->ftol_abs=ftol_abs;
  bdata->maxeval=maxeval;
 
  bdata->objf=(bobyqa_func)f;
  bdata->objf_data=objf_data;
 
  return BOBYQA_SUCCESS;
}

Referenced by bobyqa().

◆ bobyqa_working_memory_size()

int bobyqa_working_memory_size	(	int	n,
		int	fitted_n,
		int	npt,
		bobyqa_data *	bdata )

extern

Calculate the required size of memory to allocate for bobyqa().

Returns: Returns the size of double array.

Parameters

n	Number of all model parameters
fitted_n	Number of fitted (not fixed) model parameters
npt	NPT
bdata	Enter pointer to bobyqa struct to set array sizes, otherwise enter NULL

Definition at line 441 of file bobyqa.c.

  {
  int i=0, s, np, ndim;
 
  np=fitted_n+1; ndim=npt+fitted_n;
 
  s=n; i+=s; if(bdata!=NULL) bdata->nfull=s;
 
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->x_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->xl_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->xu_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->xbase_size=s;
  s=fitted_n*npt; i+=s; if(bdata!=NULL) bdata->xpt_size=s;
  s=npt; i+=s; if(bdata!=NULL) bdata->fval_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->xopt_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->gopt_size=s;
  s=fitted_n*np/2; i+=s; if(bdata!=NULL) bdata->hq_size=s;
  s=npt; i+=s; if(bdata!=NULL) bdata->pq_size=s;
  s=ndim*fitted_n; i+=s; if(bdata!=NULL) bdata->bmat_size=s;
  s=npt*(npt-np); i+=s; if(bdata!=NULL) bdata->zmat_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->sl_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->su_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->xnew_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->xalt_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->dtrial_size=s;
  s=ndim; i+=s; if(bdata!=NULL) bdata->vlag_size=s;
 
  s=2*npt; i+=s; if(bdata!=NULL) bdata->w2npt_size=s;
  s=ndim; i+=s; if(bdata!=NULL) bdata->wndim_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->wn_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->gnew_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->xbdi_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->s_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->hs_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->hred_size=s;
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->glag_size=s;
  s=npt; i+=s; if(bdata!=NULL) bdata->hcol_size=s;
  s=2*fitted_n; i+=s; if(bdata!=NULL) bdata->ccstep_size=s;
 
  s=fitted_n; i+=s; if(bdata!=NULL) bdata->xscale_size=s;
 
  //bobyqa_print(bdata, 2, stdout);
  return(i);
}

Referenced by bobyqa(), and bobyqa_set_memory().

◆ bobyqa_x_funcval()

double bobyqa_x_funcval	(	bobyqa_data *	bdata,
		double *	x )

extern

Calculate the objective function value with current scaled parameters values stored in specified array. This function back-scales the parameters to the full parameter list and calls the objective function with full set of parameters, that is, including also fixed parameters which are saved in bobyqa data struct. Also nevals is incremented.

Returns: Returns the value of objective function.

Definition at line 751 of file bobyqa.c.

  {
  int j;
  double v;
 
  for(j=0; j<bdata->n; j++) bdata->xfull[bdata->xplace[j]]=x[j]*bdata->xscale[j];
  v = bdata->objf(bdata->nfull, bdata->xfull, bdata->objf_data);
  bdata->nevals++;
  return(v);
}

Referenced by bobyqa_minimize_single_parameter(), bobyqa_prelim(), bobyqa_rescue(), and bobyqb_calc_with_xnew().

◆ bobyqa_xfull()

void bobyqa_xfull ( bobyqa_data * bdata )

extern

Add the fitted parameters (x[]) to the full parameter list (xfull[]). xfull[] will contain back-scaled parameter values. x[] is not modified.

Definition at line 769 of file bobyqa.c.

  {
  for(int j=0; j<bdata->n; j++)
    bdata->xfull[bdata->xplace[j]]=bdata->x[j]*bdata->xscale[j];
}

Referenced by bobyqa(), and bobyqb_xupdate().

◆ bobyqb()

bobyqa_result bobyqb ( bobyqa_data * bdata )

extern

bobyqb (called from bobyqa).

Returns: Returns <0 in case of n error, >0 when successful.

Parameters

bdata Data struct for BOBYQA subroutines

Definition at line 1622 of file bobyqa.c.

  {
  if(bdata->verbose>2) {printf("bobyqb()\n"); fflush(stdout);}
 
  int i, j, k;
  double curv;
  double bdtol;
  double errbig;
  double bdtest;
  double frhosq;
  bobyqa_result rc2;
  double d1; 
 
 
  /* The call of PRELIM sets the elements of XBASE, XPT, FVAL, GOPT, HQ, PQ,
     BMAT and ZMAT for the first iteration, with the corresponding values of
     of NF and KOPT, which are the number of calls of objf() so far and the
     index of the interpolation point at the trust region centre. Then the
     initial XOPT is set too. The branch to label 720 occurs if MAXFUN is
     less than NPT. GOPT will be updated if KOPT is different from KBASE. */
  rc2 = bobyqa_prelim(bdata);
 
  for(i=0, bdata->xoptsq=0.0; i<bdata->n; i++) {
    bdata->xopt[i] = bdata->xpt[bdata->kopt-1 +i*bdata->npt];
    bdata->xoptsq+=bdata->xopt[i]*bdata->xopt[i];
  }
  bdata->fsave = bdata->fval[0];
  if (rc2 != BOBYQA_SUCCESS) {
    bdata->rc = rc2; 
    if(bdata->verbose>3) printf("prelim() was not successful\n");
    bobyqb_xupdate(bdata);
    return bdata->rc;
  }
  bdata->kbase = 1;
 
  /* Complete the settings that are required for the iterative procedure. */
  bdata->rho=bdata->rhobeg;
  bdata->delta= bdata->rho;
  bdata->nresc= bdata->nevals;
  bdata->ntrits= 0;
  bdata->diffa=bdata->diffb=bdata->diffc= 0.0;
  bdata->ratio =0.0; //=1.0;
  bdata->itest= 0;
  bdata->nfsav= bdata->nevals;
 
  /* Update GOPT if necessary before the first iteration and after each
     call of RESCUE that makes a call of objf(). */
  if (bdata->kopt != bdata->kbase) bobyqb_update_gopt(bdata);
 
  do { // start main loop
    /* Generate the next point in the trust region that provides a small value 
       of the quadratic model subject to the constraints on the variables. 
       The int NTRITS is set to the number "trust region" iterations that 
       have occurred since the last "alternative" iteration. If the length 
       of XNEW-XOPT is less than 0.5*RHO, however, then there is a branch to
       label 650 or 680 with NTRITS=-1, instead of calculating F at XNEW. */
    bobyqa_trsbox(bdata);
    bdata->dnorm = fmin(bdata->delta, sqrt(bdata->dsq));
 
#if(0) // original
    if(bdata->dnorm < 0.5 * bdata->rho) {
#else
    if(bdata->dnorm>0.0 && bdata->dnorm < 0.5 * bdata->rho) {
#endif
      if(bdata->verbose>10) {
        printf("ntrits set to -1; A\n");
        printf("bdata->dnorm=%.15E 0.5*bdata->rho=%.15E\n",
                bdata->dnorm, 0.5*bdata->rho);
        printf("delta=%.15E dsq=%.15E\n", bdata->delta, bdata->dsq);
      }
      bdata->ntrits = -1;
      d1=10.0*bdata->rho; bdata->distsq = d1*d1;
      if(bdata->nevals <= bdata->nfsav + 2) {
        if(bdata->verbose>10) {
          printf("nevals<=nfsav+2 (nevals=%d nfsav=%d)\n",
                 bdata->nevals, bdata->nfsav);
        }
      } else { 
 
        /* The following choice between labels 650 and 680 depends on whether or
           not our work with the current RHO seems to be complete. Either RHO is 
           decreased or termination occurs if the errors in the quadratic model 
           at the last three interpolation points compare favourably with 
           predictions of likely improvements to the model within distance
           0.5*RHO of XOPT. */
        d1 = fmax(bdata->diffa, bdata->diffb); errbig = fmax(d1, bdata->diffc); 
        frhosq = bdata->rho * .125 * bdata->rho;
        if(bdata->_crvmin<=0.0 || errbig <= frhosq*bdata->_crvmin) {
          bdtest=bdtol= errbig/bdata->rho;
 
          for(j=0; j<bdata->n; j++) {
            bdtest=bdtol;
            if(bdata->xnew[j]==bdata->sl[j]) bdtest=bdata->gnew[j];
            if(bdata->xnew[j]==bdata->su[j]) bdtest=-bdata->gnew[j];
            if(bdtest<bdtol) {
              curv=bdata->hq[(j+1 + (j+1)*(j+1))/2 - 1];
              for(k=0; k<bdata->npt; k++) {
                d1=bdata->xpt[k+j*bdata->npt]; curv+=bdata->pq[k]*(d1*d1);
              }
              bdtest += 0.5*curv*bdata->rho;
              if(bdtest < bdtol) break;
            }
          }
          if(bdtest>=bdtol) {
            /* The calculations with the current value of RHO are complete.
               Pick the next values of RHO and DELTA. */
            if (bdata->rho > bdata->rhoend) {
              bobyqb_next_rho_delta(bdata);
              continue;
            }
 
            /* Return from the calculation, after another Newton-Raphson step,
               if it is too short to have been tried before. */
            if(bdata->ntrits != -1) {
              bobyqb_xupdate(bdata);
              return bdata->rc;
            }
            bdata->rc=bobyqb_calc_with_xnew(bdata);
            if(bdata->rc!=BOBYQA_SUCCESS) return bdata->rc;
            /* If a trust region step has provided a sufficient decrease in F,
               then branch for another trust region calculation.
               The case NTRITS=0 occurs when the new interpolation point was
               reached by an alternative step. */
            if (bdata->ntrits==0 || bdata->newf<=bdata->fopt+0.1*bdata->vquad) {
              continue;
            }
 
            /* Alternatively, find out if the interpolation points are close
               enough to the best point so far. */
            d1=fmax(2.0*bdata->delta, 10.0*bdata->rho);
            bdata->distsq=d1*d1;
          }
        }
      }
 
    } else {
 
      bdata->ntrits++;
 
      /* Severe cancellation is likely to occur if XOPT is too far from XBASE.
         If the following test holds, then XBASE is shifted so that XOPT becomes
         zero. The appropriate changes are made to BMAT and to the second
         derivatives of the current model, beginning with the changes to BMAT
         that do not depend on ZMAT.
         VLAG is used temporarily for working space */
      if(bdata->dsq <= bdata->xoptsq * .001) bobyqb_shift_xbase(bdata);
 
      if (bdata->ntrits == 0) {
        bobyqa_altmov(bdata);
        for(i=0; i<bdata->n; i++) bdata->dtrial[i]=bdata->xnew[i]-bdata->xopt[i];
      }
 
      i=bobyqb_part(bdata);
      if(i==-1) return bdata->rc;
      if(i==1) continue;
 
      bdata->rc=bobyqb_calc_with_xnew(bdata);
      if(bdata->rc!=BOBYQA_SUCCESS) return bdata->rc;
 
      /* If a trust region step has provided a sufficient decrease in F, then
         branch for another trust region calculation. The case NTRITS=0 occurs
         when the new interpolation point was reached by an alternative step. */
      if (bdata->ntrits==0 || bdata->newf <= bdata->fopt+0.1*bdata->vquad) {
        continue;
      }
 
      /* Alternatively, find out if the interpolation points are close enough
         to the best point so far. */
      d1=fmax(2.0*bdata->delta, 10.0*bdata->rho);
      bdata->distsq=d1*d1;
 
    }
    while(1) {
      /* Check if interpolation points are close enough, and update distsq
         if necessary */ 
      i=bobyqb_ip_dist(bdata);
 
      /* If not close enough (KNEW is positive), 
         then ALTMOV finds alternative new positions for
         the KNEW-th interpolation point within distance ADELT of XOPT. */
      if(i!=0) { // Tästä iffistä ei jatketa alle
        /* Find alternative new positions for the KNEWth interpolation point
           within distance ADELT of XOPT. */
        bobyqb_ip_alternative(bdata);
        i=bobyqb_part(bdata);
        if(i==-1) return bdata->rc;
        if(i==1) break;
 
        bdata->rc=bobyqb_calc_with_xnew(bdata);
        if(bdata->rc!=BOBYQA_SUCCESS) return bdata->rc;
 
        /* If a trust region step has provided a sufficient decrease in F, then
           branch for another trust region calculation. The case NTRITS=0 occurs
           when the new interpolation point was reached by an alternative step. */
        if (bdata->ntrits == 0 || bdata->newf <= bdata->fopt + 0.1*bdata->vquad) {
          break;
        }
 
        /* Alternatively, find out if the interpolation points are close enough
           to the best point so far. */
        d1=fmax(2.0*bdata->delta, 10.0*bdata->rho);
        bdata->distsq=d1*d1;
 
        continue;
      }
      /* Another trust region iteration, unless the calculations with the 
         current RHO are complete. */
      if(bdata->ntrits != -1) {
        if(bdata->ratio>0.0 || fmax(bdata->delta, bdata->dnorm) > bdata->rho) {
          break;
        }
      }
 
      /* The calculations with the current value of RHO are complete. Pick the
         next values of RHO and DELTA. */
      if (bdata->rho > bdata->rhoend) {
        bobyqb_next_rho_delta(bdata);
        break;
      }
 
      /* Return from the calculation, after another Newton-Raphson step, if
         it is too short to have been tried before */
      if (bdata->ntrits == -1) {
        bdata->rc=bobyqb_calc_with_xnew(bdata); 
        if(bdata->rc!=BOBYQA_SUCCESS) return bdata->rc;
        /* If a trust region step has provided a sufficient decrease in F, then 
           branch for another trust region calculation. The case NTRITS=0 occurs
           when the new interpolation point was reached by an alternative step. */
        if (bdata->ntrits == 0 || bdata->newf <= bdata->fopt+0.1*bdata->vquad) {
          break;
        }
        /* Alternatively, find out if the interpolation points are close enough
           to the best point so far. */
        d1=fmax(2.0*bdata->delta, 10.0*bdata->rho);
        bdata->distsq=d1*d1;
 
        continue;
      } else {
        bobyqb_xupdate(bdata);
        return bdata->rc;
      }
    }
  } while(1);
  // actually we should never reach this point
  return bdata->rc;
} /* bobyqb() */

Referenced by bobyqa().

◆ bootstrap()

int bootstrap	(	int	iterNr,
		double *	cLim1,
		double *	cLim2,
		double *	SD,
		double *	parameter,
		double *	lowlim,
		double *	uplim,
		int	frameNr,
		double *	origTac,
		double *	fitTac,
		double *	bsTac,
		int	parNr,
		double *	weight,
		double(*	objf )(int, double , void ),
		char *	status,
		int	verbose )

extern

Bootstrap method.

Original weights are assumed to be inversely proportional to variance. Square root is used, because bootstrap assumes them to be proportional to standard deviation. If only standard deviation is needed then cLim1 and cLim2 can be set to be NULL, and if only the confidence limits are wanted then SD can be set to be NULL. This function will not set seed for random number generator, therefore, make sure that it is set in your program, for example with srand(time(NULL));.

Returns

Return values:

0, if ok.
1 - 3 if some of the given parameters is not qualified.
4, if Powell fails, and 5, if out of memory.

Parameters

iterNr	Bootstrap iteration number (>=100), set to zero to use the default (200).
cLim1	Vector to put the lower confidence limits to; NULL if not needed.
cLim2	Vector to put the upper confidence limits to; NULL if not needed.
SD	Vector to put the standard deviations to; NULL if not needed.
parameter	Best parameter estimates (preserved by this function).
lowlim	Lower limits for the parameters.
uplim	Upper limits for the parameters.
frameNr	Nr of samples in tissue TAC data.
origTac	Measured tissue TAC values (not modified; local copy is used).
fitTac	Best fitted tissue TAC values (not modified; local copy is used).
bsTac	Pointer to (empty) tissue TAC vector, where bootstrapped TACs will be written in each bootstrap iteration, and which will be used by objective function to calculate WSS.
parNr	Nr of parameters.
weight	sample weights.
objf	The object function.
status	Pointer to a string (allocated for at least 64 chars) where error message or other execution status will be written; enter NULL, if not needed.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 55 of file bootstrap.c.

  {
 
  int ret, i, j, powellItNr, lowindex, upindex;
  double fret=0.0, *parMean, *chainptr, *chain, **matrix, *delta, *bsFitTac;
  double help, *error, *wError, *biasEst, *unbiasPar, *estInOrder;
  char bserrmsg[64];
 
  if(verbose>0)
    printf("%s(%d, ..., %d, ..., %d, ..., %d)\n", __func__, iterNr, frameNr, parNr, verbose);
 
  /* Checking the given parameters */
  if(status!=0) strcpy(status, "");
  if(iterNr<100) iterNr=200;
  if(frameNr<1 || parNr<1 ) {
    strcpy(bserrmsg, "either framenumber or parameternumber is negative");
    if(verbose>0) fprintf(stderr, "Error: %s.\n", bserrmsg);
    if(status!=0) strcpy(status, bserrmsg);
    return(1);
  }
  if(bsTac==NULL || parameter==NULL || objf==NULL || origTac==NULL ||
     fitTac==NULL)
  {
    strcpy(bserrmsg, "some of the given parameters are not pointing anywhere");
    if(verbose>0) fprintf(stderr, "Error: %s.\n", bserrmsg);
    if(status!=0) strcpy(status, bserrmsg);
    return(2);
  }
  for(i=0; i<parNr; i++) {
    if(lowlim[i]>uplim[i]) {
      strcpy(bserrmsg, "given limit values are not qualified");
      if(verbose>0) fprintf(stderr, "Error: %s.\n", bserrmsg);
      if(status!=0) strcpy(status, bserrmsg);
      return(3);
    }
  }
 
  /* Allocating memory */
  if(verbose>1) printf("  allocating memory\n");
  bsFitTac=(double*)malloc(frameNr*sizeof(double));
  bs_parameter=(double*)malloc(parNr*sizeof(double));
  bs_weight=(double*)malloc(frameNr*sizeof(double));
  delta=(double*)malloc(parNr*sizeof(double));
  parMean=(double*)malloc(parNr*sizeof(double));
  chain=(double*)malloc((iterNr*parNr)*sizeof(double));
  matrix=(double**)malloc(parNr*sizeof(double*));
  error=(double*)malloc(frameNr*sizeof(double));
  wError=(double*)malloc(frameNr*sizeof(double));
  biasEst=(double*)malloc(parNr*sizeof(double));
  unbiasPar=(double*)malloc(parNr*sizeof(double));
  if(bsFitTac==NULL || bs_parameter==NULL || bs_weight==NULL || delta==NULL ||
     parMean==NULL || chain==NULL || matrix==NULL || error==NULL ||
     wError==NULL || biasEst==NULL || unbiasPar==NULL) {
    strcpy(bserrmsg, "out of memory");
    if(verbose>0) fprintf(stderr, "Error: %s.\n", bserrmsg);
    if(status!=0) strcpy(status, bserrmsg);
    return(5);
  }
  for(i=0, chainptr=chain; i<parNr; i++) {
    matrix[i]=(chainptr + i*iterNr);
  }
 
  bs_parNr=parNr;
  bs_frameNr=frameNr;
  bs_func=objf;
  bs_lowlim=lowlim;
  bs_uplim=uplim;
  for(i=0; i<bs_parNr; i++) {
    bs_parameter[i]=parameter[i];
  }
 
  /* copy data and check the weights */
  /* calculate the errors and weighted errors */
  if(verbose>2) printf("  calculating errors and weighted errors");
  for(i=0; i<bs_frameNr; i++) {
    bsFitTac[i]=fitTac[i];
    if(weight[i]<=0.0) bs_weight[i]=1; else bs_weight[i]=weight[i];
    error[i]=origTac[i]-bsFitTac[i];
    wError[i]=error[i]/sqrt(bs_weight[i]);
  }
  if(verbose>3) {
    printf("  weighted errors:\n  ");
    for(i=0; i<bs_frameNr; i++) printf("%g ", wError[i]);
    printf("\n");
  }
 
  /*
   *  bootstrap iterations
   */
  if(verbose>1) printf("  bootstrap iterations\n");
  if(verbose>4) printf("Bootstrap matrix:\n");
  int powellfailNr=0;
 
  for(i=0; i<iterNr; i++) {
 
    /* sample a new error distribution (to the pointer error) */
    for(j=0; j<bs_frameNr; j++) {
      error[j]=wError[(int)((bs_frameNr)*(double)rand()/((double)(RAND_MAX)+1))];
      bsTac[j]=bsFitTac[j]+bs_weight[j]*error[j];
    }
 
    /* Powell local search */
    for(j=0; j<bs_parNr; j++) {
      delta[j]=0.01*(bs_uplim[j]-bs_lowlim[j]);
      bs_parameter[j]=parameter[j];
    }
    powellItNr=400;
    ret=powell(bs_parameter, delta, bs_parNr, 0.00001, &powellItNr, &fret, bs_func, NULL, 0);
    if(ret>1 && ret!=3) {
      sprintf(bserrmsg, "error %d in powell()", ret);
      if(verbose>0) fprintf(stderr, "Error: %s.\n", bserrmsg);
      if(status!=0) strcpy(status, bserrmsg);
      free(bsFitTac);
      free(bs_parameter);
      free(bs_weight);
      free(delta);
      free(parMean);
      free(matrix);
      free(chain);
      free(error);
      free(wError);
      free(biasEst);
      free(unbiasPar);
      return(4);
    }
    if(ret==3) { // powell sometimes fails, do not worry if not too often
      powellfailNr++;
    }
 
    for(j=0; j<bs_parNr; j++) {
      matrix[j][i]=bs_parameter[j];
    }
    if(verbose>4) {
      for(j=0; j<bs_parNr; j++) printf("%g ", bs_parameter[j]);
      printf("\n");
    }
 
  } /* end of bootstrap iterations */
  if(powellfailNr>(iterNr/3)) {
    sprintf(bserrmsg, "error %d in powell()", ret);
    if(verbose>0) fprintf(stderr, "Error: too often %s.\n", bserrmsg);
    if(status!=0) strcpy(status, bserrmsg);
    free(bsFitTac);
    free(bs_parameter);
    free(bs_weight);
    free(delta);
    free(parMean);
    free(matrix);
    free(chain);
    free(error);
    free(wError);
    free(biasEst);
    free(unbiasPar);
    return(4);
  }
 
  /* Computing the mean of each parameter and estimates for bias */
  if(verbose>1) printf("  computing parameter bias\n");
  for(i=0; i<bs_parNr; i++) {
    for(j=0, help=0.0; j<iterNr; j++) help+=matrix[i][j];
    parMean[i]=help/(double)iterNr;
    biasEst[i]=parMean[i]-parameter[i];
    /*unbiasPar[i]=parameter[i]-biasEst[i];*/
    if(verbose>1) {
      printf("parMean[%d] := %g\n", i, parMean[i]);
      printf("parameter[%d] := %g\n", i, parameter[i]);
      printf("biasEst[%d] := %g\n", i, biasEst[i]);
    }
  }
 
  /* Computing the standard deviation for each parameter estimate */
  if(SD!=NULL) {
    if(verbose>1) printf("Standard deviations:\n");
    for(i=0; i<bs_parNr; i++) {
      for(j=0, help=0; j<iterNr; j++) {
        help+=(matrix[i][j]-parMean[i])*(matrix[i][j]-parMean[i])/(iterNr-1);
      }
      SD[i]=sqrt(help); if(verbose>1) printf("  %g\n", SD[i]);
    }
  }
 
  if(cLim1!=NULL && cLim2!=NULL) {
    if(verbose>1) printf("Confidence intervals:\n");
    lowindex=(int)temp_roundf(0.025*iterNr);
    upindex=(int)temp_roundf(0.975*iterNr)-1;
    /* Computing the 95% confidence intervals for each parameter estimate */
    for(i=0; i<bs_parNr; i++) {
 
      /* Arrange estimate samples in ascending order */
      estInOrder=matrix[i];
      qsort(estInOrder, iterNr, sizeof(double), bootstrapQSort);
 
      /* Get the indices within which 95% of samples lie in */
      if(fabs(estInOrder[lowindex]-biasEst[i])<1e-99) cLim1[i]=0.0;
      else cLim1[i]=estInOrder[lowindex]-biasEst[i];
      if(fabs(estInOrder[upindex]-biasEst[i])<1e-99) cLim2[i]=0.0;
      else cLim2[i]=estInOrder[upindex]-biasEst[i];
      if(verbose>1) {
        printf("  %g - %g\n", cLim1[i], cLim2[i]);
      }
    }
    if(verbose>6) {
      printf("Sorted matrix\n");
      for(j=0; j<iterNr; j++) {
        for(i=0; i<bs_parNr; i++) printf("  %12.3e", matrix[i][j]);
        printf("\n");
      }
      printf("lowindex := %d\nupindex := %d\n", lowindex, upindex);
    }
  }
 
  free(bsFitTac);
  free(bs_parameter);
  free(bs_weight);
  free(delta);
  free(parMean);
  free(matrix);
  free(chain);
  free(error);
  free(wError);
  free(biasEst);
  free(unbiasPar);
 
  if(verbose>0) {printf("  end of bootstrap()\n");}
  return(0);
 
} /* end bootstrap() */

◆ bvls()

int bvls	(	int	key,
		const int	m,
		const int	n,
		double *	a,
		double *	b,
		double *	bl,
		double *	bu,
		double *	x,
		double *	w,
		double *	act,
		double *	zz,
		int *	istate,
		int *	iter,
		int	verbose )

extern

Bounded-value least-squares method to solve the linear problem A x ~ b , subject to limit1 <= x <= limit2.

This routine is based on the text and Fortran code in C.L. Lawson and R.J. Hanson, Solving Least Squares Problems, Prentice-Hall, Englewood Cliffs, New Jersey, 1974, and Fortran codes by R.L. Parker and P.B. Stark, and by J. Burkardt.

See also: nnls, qrLH, llsqWghtSquared, llsqWght

Returns: Returns 0 when successful, -1 if iteration count exceeded the limit, 1 in case of invalid data or settings, and 2 if problem cannot be solved.

Parameters

key	Enter 0 to solve the problem from scratch, or <>0 to initialize the routine using caller's guess about which parameters are active within their bounds, which are at their lower bounds, and which at their upper bounds, as supplied in the array istate ('warm start'). When key <> 0, the routine initially sets the active components to the averages of their upper and lower bounds.
m	Number of samples in matrix A and the length of vector b.
n	Number of parameters in matrix A and the length of vector x. The n must not be > m unless at least n-m variables are non-active (set to their bounds)..
a	Pointer to matrix A; matrix must be given as an n*m array, containing n consecutive m-length vectors. Contents of A are modified in this routine.
b	Pointer to vector b of length m. Contents of b are modified in this routine.
bl	Array BL[0..n-1] of lower bounds for parameters.
bu	Array BU[0..n-1] of upper bounds for parameters.
x	Pointer to the result vector x of length n.
w	Pointer to an array of length n, which will be used as working memory, and the minimum 2-norm \|\| a.x-b \|\|, (R^2), will be written in w[0].
act	Pointer to an array of length m(n+2), or m(m+2) if m<n, which will be used as working memory.
zz	Pointer to an array of length m, to be used as working memory.
istate	Pointer to an integer array of length n+1. If parameter key <>0, then the last position istate[n] must contain the total number of components at their bounds (nbound, the ‘bound variables’). The absolute values of the first nbound entries of istate[] are the indices of these ‘bound’ components of x[]. The sign of istate[0.. nbound-1] entries indicates whether x[\|istate[i]\|] is at its upper (positive) or lower (negative) bound. Entries istate[nbound..n-1] contain the indices of the active components.
iter	Number of performed iterations is returned in this variable. Maximum nr of iterations is set with this variable, or set it to 0 to use the default maximum, 3*n.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout

Definition at line 24 of file bvls.c.

  {
  if(verbose>0) {printf("bvls(%d, %d, %d, ...)\n", key, m, n); fflush(stdout);}
  /* Check the input */
  if(a==NULL || b==NULL || bl==NULL || bu==NULL || x==NULL || w==NULL ||
     act==NULL || zz==NULL || istate==NULL || iter==NULL || n<1 || m<1) 
  {
    if(verbose>0) fprintf(stderr, "Error: invalid input to BVLS.\n");
    return(1);
  }
 
  int maxIter=*iter; if(maxIter<3) maxIter=3*n;
  *iter=0; 
  const double eps=1.0E-13; // stopping rule
 
  /* Step 1. Initialize everything -- active and bound sets, initial values, etc. */
  if(verbose>1) {printf("step 1\n"); fflush(stdout);}
 
  /* Set mm to the smaller of matrix dimensions n and m. */
  int mm; if(m<n) mm=m; else mm=n;
  int aindx=0; // one-based index of X[] that determined the alpha; zero means not set.
  int aindxsign=0; // +1 if zz[aindx]> bu[aindx], -1 if zz[aindx]<bl[aindx]
  /* istateFromStep5 is the one-based index of the parameter that most wants to be active;
     zero value means its is currently not set. */
  int istateFromStep5 = 0;
 
  /* Check the consistency of given bounds bl[] and bu[]. */
  {
    double maxrange=0.0;
    for(int ni=0; ni<n; ni++) {
      double d=bu[ni]-bl[ni];
      if(verbose>3) printf("  bounds[%d]: %g %g\n", 1+ni, bl[ni], bu[ni]);
      if(d<0.0) {
        if(verbose>0) fprintf(stderr, "Error: inconsistent bounds in BVLS.\n"); 
        return(1);
      }
      maxrange=fmax(maxrange, d);
    }
    if(verbose>2) printf("  maxrange := %g\n", maxrange);
    if(maxrange<1.0E-10) {
      if(verbose>0) fprintf(stderr, "Error: no free variables in BVLS.\n");
      return(1);
    }
  }
 
  /* In a fresh initialization (key=0), bind all variables at their lower bounds. 
     If key<>0, use the supplied istate[] array to initialize the variables. */
  int nbound, nact; // number of bound and active parameters, respectively.
  if(key==0) {
    nbound=n;
    /* Write the indices; negative sign indicates lower limit */
    /* Note that these indices must start from 1, because 0 can not have sign */
    for(int ni=0; ni<nbound; ni++) istate[ni]=-(1+ni);
  } else {
    nbound=istate[n];
  }
  nact=n-nbound;
  if(nact>mm) {
    if(verbose>0) fprintf(stderr, "Error: too many active variables in BVLS starting solution.\n");
    return(2);
  }
  for(int ni=0; ni<nbound; ni++) {
    int i=abs(istate[ni])-1;
    if(istate[ni]<0) x[i]=bl[i]; else x[i]=bu[i];
  }
 
  /* In a warm start (key<>0, and nbound<n) initialize the active variables to the mean of
     their bounds. This is needed in case the initial QR results in active variables 
     out-of-bounds and Steps 8-11 get executed the first time through. */
  for(int ni=nbound; ni<n; ni++) {
    int i=abs(istate[ni])-1; // indices of active variables should not have signs, but let's be sure
    x[i]=0.5*(bl[i]+bu[i]);
  }
 
  /* Compute bnorm, the norm of the data vector b, for reference. */
  double bnorm=0.0;
  for(int mi=0; mi<m; mi++) bnorm+=b[mi]*b[mi];
  bnorm=sqrt(bnorm); if(verbose>2) printf("  initial_bnorm := %g\n", bnorm);
 
 
  /*
   *  Main loop
   */
  int skipStep2=0;
  double obj=0.0;
  int iact=0; // The component x[iact] is the one that most wants to become active
 
  for(*iter=1; *iter<=maxIter; ++(*iter)) {
 
    if(verbose>1) {printf("iteration %d\n", *iter); fflush(stdout);}
 
    if(!skipStep2) {
      /* Step 2. */ if(verbose>1) {printf("  step 2\n"); fflush(stdout);}
 
      /*  Initialize the negative gradient vector w(*). */
      for(int ni=0; ni<n; ni++) w[ni]=0.0;
 
      /* Compute the residual vector b-a.x , the negative gradient vector w[*], and 
         the current objective value obj = || a.x - b ||.
         The residual vector is stored in the mm+1'st column of act[*,*]. */
      obj=0.0;
      for(int mi=0; mi<m; mi++) {
        double ri=b[mi];
        for(int ni=0; ni<n; ni++) ri-=a[mi+ni*m]*x[ni];
        obj+=ri*ri;
        for(int ni=0; ni<n; ni++) w[ni]+=a[mi+ni*m]*ri;
        act[mi+mm*m]=ri;
      }
      if(verbose>3) {printf("    obj := %g\n", obj); fflush(stdout);}
 
      /* Converged?  Stop if the misfit << || b ||, or if all components are active 
        (unless this is the first iteration from a 'warm start'). */
      if((sqrt(obj)<=bnorm*eps) || ((*iter)>1 && nbound==0)) {
        if(verbose>1) {printf("bvls converged.\n"); fflush(stdout);}
        istate[n]=nbound;
        w[0]=sqrt(obj);
        return(0);
      }
 
      /* Add the contribution of the active components back into the residual. */
      for(int ni=nbound; ni<n; ni++) {
        int i=abs(istate[ni])-1;
        for(int mi=0; mi<m; mi++) act[mi+mm*m] += a[mi+i*m]*x[i];
      }
      if(verbose>9) {
        printf("Residual vector:\n");
        for(int mi=0; mi<m; mi++) printf("\t%g", act[mi+mm*m]);
        printf("\n");
      }
 
    }
 
 
 
    /* The first iteration in a 'warm start' requires immediate QR in Step 6
       but mostly we want go through Steps 3-5 first . */
    if(key!=0 && (*iter)==1) {
      if(verbose>1) printf("  'warm start' requires immediate QR in Step 6\n");
    } else {
 
      int it; // variable indicating the element in istate that most wants to be active
 
      do {
        /* Steps 3, 4. */ if(verbose>1) {printf("  steps 3 and 4\n"); fflush(stdout);}
        /* Find the bound element that most wants to be active. */
        double worst=0.0;
        it=1;
        for(int ni=0; ni<nbound; ni++) {
          int i=abs(istate[ni])-1;
          double bad; if(istate[ni] < 0) bad=-w[i]; else bad=+w[i];
          if(bad < worst) { it=ni+1; worst=bad; iact=i; }
        }
 
        /* Test whether the Kuhn-Tucker condition is met. */
        if(worst>=0.0) {
          if(verbose>1) {printf("Kuhn-Tucker condition is met.\n"); fflush(stdout);}
          istate[n]=nbound;
          w[0]=sqrt(obj);
          return(0);
        }
 
        /* The component x[iact] is the one that most wants to become active.
           If the last successful change in the active set was to move x[iact] to a bound, 
           don't let x[iact] in now: set the derivative of the misfit with respect to x[iact] 
           to zero and return to the Kuhn-Tucker test. */
        if(iact==(aindx-1)) w[aindx-1]=0.0;
      } while(iact==(aindx-1)); // Step 3 again
 
      /* Step 5. */ if(verbose>1) {printf("  step 5\n"); fflush(stdout);}
 
      /* Undo the effect of the new (potentially) active variable on the residual vector. */
      if(istate[it-1]==0) { // remove this if never happening
        if(verbose>0) fprintf(stderr, "Error: BVLS istate is zero!\n"); 
        return(1);
      }
      {
        double bnd;
        if(istate[it-1]>0) bnd=bu[iact]; else bnd=bl[iact];
        for(int mi=0; mi<m; mi++) act[mi+mm*m]+=bnd*a[mi+iact*m];
      }
 
      /* Set flag istateFromStep5, indicating that Step 6 was entered from Step 5.
         This forms the basis of a test for instability: the gradient calculation shows that x[iact] 
         wants to join the active set; if QR puts x[iact] beyond the bound from which it came, 
         the gradient calculation was in error and the variable should not have been introduced. */
      istateFromStep5=istate[it-1]; 
 
      /* Swap the indices (in istate) of the new active variable and the rightmost bound variable; 
         `unbind' that location by decrementing nbound. */
      istate[it-1]=istate[nbound-1];
      nbound--;  nact++;
      istate[nbound]=1+iact;
      if(mm<nact) {
        if(verbose>0) fprintf(stderr, "Error: too many free variables in BVLS.\n");
        return(2);
      }
 
    } // finalized steps 3-5
 
    do {
 
      skipStep2=0;
 
      /* Step 6. */ if(verbose>1) {printf("  step 6\n"); fflush(stdout);}
 
      /* Load array act with the appropriate columns of A for QR. For added stability, reverse 
         the column ordering so that the most recent addition to the active set is in the last 
         column. Also copy the residual vector from act[., mm] into act[., mm+1]. */
      for(int mi=0; mi<m; mi++) {
        act[mi+(mm+1)*m]=act[mi+mm*m]; // vector b for QR
        for(int ni=nbound; ni<n; ni++) {
          int i=abs(istate[ni])-1;
          act[mi+(nact+nbound-ni-1)*m]=a[mi+i*m];
        }
      }
      if(verbose>9) {
        printf("Matrix A for QR:\n");
        for(int ni=0; ni<nact; ni++) {
          for(int mi=0; mi<m; mi++) printf("\t%g", act[mi+ni*nact]);
          printf("\n");
        }
        printf("Vector B for QR:\n");
        for(int mi=0; mi<m; mi++) printf("\t%g", act[(mm+1)*m + mi]);
        printf("\n");
      }
 
      /* Test for linear dependence in QR, and for an instability that moves the variable 
         just introduced away from the feasible region (rather than into the region or 
         all the way through it). In either case, remove the latest vector introduced from 
         the active set and adjust the residual vector accordingly.
         Set the gradient component (w[iact]) to zero and return to the Kuhn-Tucker test. */
      double r2;
      if(qrLH(m, nact, act, &act[(mm+1)*m], zz, &r2) !=0 || 
         (istateFromStep5>0 && zz[nact-1]>bu[iact]) || 
         (istateFromStep5<0 && zz[nact-1]<bl[iact]) )
      {
        nbound++;
        if(bu[iact]>x[iact]) istate[nbound-1]=-istate[nbound-1];
        nact--;
        for(int mi=0; mi<m; mi++) act[mi+mm*m]-=x[iact]*a[mi+iact*m];
        istateFromStep5 = 0; // not from step 5
        w[iact]=0.0;
        skipStep2=1; // we want to skip Step 2 and go directly to Step 3
        if(verbose>3) {printf("    going from step 6 to step 3\n"); fflush(stdout);}
        break; // go to step 3
      }
 
      /* If Step 6 was entered from Step 5 and we are here, a new variable has been successfully 
         introduced into the active set; the last variable that was fixed at a bound is again 
         permitted to become active. */
      if(istateFromStep5!=0) aindx=0;
      istateFromStep5=0;
 
      /* Step 7. */ if(verbose>1) {printf("  step 7\n"); fflush(stdout);}
      /* Check for strict feasibility of the new QR solution. */
      int qr_solution_feasible=1;
      int indexHolder=0;
      if(verbose>8) printf("    nact=%d  nbound=%d\n", nact, nbound);
      for(int ni=0; ni<nact; ni++) {
        indexHolder=ni; // Loop in step 8 will start from this
        int i=abs(istate[ni+nbound])-1;
        if(verbose>8) {
          printf("      istate[%d]=%d\n", ni+nbound, 1+i);
          printf("      zz[%d]=%g  bl[%d]=%g  bu[%d]=%g\n", nact-ni-1, zz[nact-ni-1], i, bl[i], i, bu[i]);
        }
        if(zz[nact-ni-1]<bl[i] || zz[nact-ni-1]>bu[i]) {
          if(verbose>3) {printf("    new iterate is not feasible\n"); fflush(stdout);}
          qr_solution_feasible=0; break; // go to Step 8
        }
      }
      if(verbose>8) printf("    indexHolder=%d\n", indexHolder);
      if(qr_solution_feasible) {
        if(verbose>3) {printf("    new iterate is feasible\n"); fflush(stdout);}
        for(int ni=0; ni<nact; ni++) {
          int i=abs(istate[ni+nbound])-1;
          x[i]=zz[nact-ni-1];
        }
        /* New iterate is feasible; back to the top. */
        break; // Back to the start of the main loop
      }
 
      { // keep local variables alpha and alf local
        double alpha=2.0;
        /* Steps 8 and 9 */ if(verbose>1) {printf("  steps 8 and 9\n"); fflush(stdout);}
        double alf=alpha;
        for(int ni=indexHolder; ni<nact; ni++) {
          int i=abs(istate[ni+nbound])-1;
          if(zz[nact-ni-1] > bu[i]) alf=(bu[i]-x[i])/(zz[nact-ni-1]-x[i]);
          if(zz[nact-ni-1] < bl[i]) alf=(bl[i]-x[i])/(zz[nact-ni-1]-x[i]);
          if(alf<alpha) {
            alpha=alf;
            aindx=1+i;
            if((zz[nact-ni-1]-bl[i])<0.0) aindxsign=-1; else aindxsign=+1;
          }
        }
        /* Step 10 */ if(verbose>1) {printf("  step 10\n"); fflush(stdout);}
        for(int ni=0; ni<nact; ni++) {
          int i=abs(istate[ni+nbound])-1;
          x[i]+=alpha*(zz[nact-ni-1]-x[i]);
        }
      }
 
      /* Step 11 */ if(verbose>1) {printf("  step 11\n"); fflush(stdout);}
      /* Move the variable that determined alpha to the appropriate bound
         (aindx is its index; sj is + if zz[aindx]> bu[aindx], - if zz[aindx]<bl[aindx] ).
         If any other component of  x  is infeasible at this stage, it must be due to round-off.
         Bind every infeasible component and every component at a bound to the appropriate bound.
         Correct the residual vector for any variables moved to bounds. Since at least one 
         variable is removed from the active set in this step, Loop B
         (Steps 6-11) terminates after at most nact steps. */
      {
        int noldb=nbound;
        for(int ni=0; ni<nact; ni++) {
          int i=abs(istate[ni+noldb])-1;
          if((bu[i]-x[i]<=0.0) || (i==(aindx-1) && aindxsign>0)) {
            /* Move x[i] to its upper bound. */
            x[i]=bu[i];
            istate[ni+noldb]=istate[nbound]; istate[nbound]=+(1+i); nbound++;
            for(int mi=0; mi<m; mi++) act[mi+mm*m]-=bu[i]*a[mi+i*m];
          } else if( ((x[i]-bl[i])<=0.0) || (i==(aindx-1) && aindxsign<0)) {
            /* Move x(j) to its lower bound. */
            x[i]=bl[i];
            istate[ni+noldb]=istate[nbound]; istate[nbound]=-(1+i); nbound++;
            for(int mi=0; mi<m; mi++) act[mi+mm*m]-=bl[i]*a[mi+i*m];
          }
        }
        nact=n-nbound;
      }
      /* If there are still active variables left, repeat the QR; if not, go back to step 6. */
    } while(nact>0);
 
  } // main loop
 
  /* iterMax reached */
  if(verbose>0) fprintf(stderr, "Error: BVLS fails to converge.\n");
  return(-1);
}

◆ d_kth_smallest()

double d_kth_smallest	(	double *	data,
		int	n,
		int	k )

extern

Returns the kth smallest value in data[0..n-1]. Array is partially sorted. Algorithm is based on the book Wirth N. Algorithms + data structures = programs. Englewood Cliffs, Prentice-Hall, 1976.

Returns: Returns the kth smallest value in data[0..n-1].

Parameters

data	Pointer to data; array is partially sorted.
n	Length of data array.
k	kth smallest value will be returned.

Definition at line 15 of file median.c.

  {
  int i, j, l, m;
  double x, s;
 
  l=0; m=n-1;
  while(l<m) {
    x=data[k]; i=l; j=m;
    do {
      while(data[i]<x) i++;
      while(x<data[j]) j--;
      if(i<=j) {s=data[i]; data[i]=data[j]; data[j]=s; i++; j--;}
    } while(i<=j);
    if(j<k) l=i;
    if(k<i) m=j;
  }
  return(data[k]);
}

Referenced by dmedian().

◆ dmean()

double dmean	(	double *	data,
		int	n,
		double *	sd )

extern

Returns the mean in array data[0..n-1], and optionally calculates also the (sample) standard deviation of the mean.

See also: dmedian, mean, dmean_nan, fmean

Returns: Returns the mean in array data[0..n-1].

Parameters

data	Pointer to data; data is not changed in any way.
n	Length of data array.
sd	Pointer to variable where SD will be written; enter NULL if not needed.

Definition at line 73 of file median.c.

  {
  int i;
  double sumsqr=0.0, sqrsum=0.0, avg;
 
  if(n<1 || data==NULL) {if(sd!=NULL) *sd=0.0; return(0.0);}
 
  for(i=0; i<n; i++) {sumsqr+=data[i]*data[i]; sqrsum+=data[i];}
  avg=sqrsum/(double)n; if(sd==NULL) return(avg);
  if(n==1) {
    *sd=0.0;
  } else {
    sqrsum*=sqrsum;
    *sd=sqrt( (sumsqr - sqrsum/(double)n) / (double)(n-1) );
  }
  return(avg);
}

◆ dmean_nan()

double dmean_nan	(	double *	data,
		int	n,
		double *	sd,
		int *	vn )

extern

Returns the mean in array data[0..n-1], and optionally calculates also the standard deviation of the mean. Data may contain missing samples marked as NaNs.

See also: dmedian, mean, dmean

Returns: Returns the mean in array data[0..n-1].

Parameters

data	Pointer to data; data is not changed in any way.
n	Length of data array.
sd	Pointer to variable where SD will be written; enter NULL if not needed.
vn	Pointer to variable where number of valid (not NaN) samples will be written; enter NULL if not needed.

Definition at line 104 of file median.c.

  {
  int i, m;
  double sumsqr=0.0, sqrsum=0.0, avg;
 
  if(n<1 || data==NULL) {
    if(sd!=NULL) *sd=0.0; 
    if(vn!=NULL) *vn=0; 
    return(0.0);
  }
  for(i=m=0; i<n; i++) if(!isnan(data[i])) m++;
  if(vn!=NULL) *vn=m;
  if(m<1) {
    if(sd!=NULL) *sd=nan(""); 
    return(nan(""));
  }
  
 
  for(i=0; i<n; i++) if(!isnan(data[i])) {
    sumsqr+=data[i]*data[i]; sqrsum+=data[i];
  }
  avg=sqrsum/(double)m; if(sd==NULL) return(avg); // SD not requested
  if(m==1) {
    *sd=0.0;
  } else {
    sqrsum*=sqrsum;
    *sd=sqrt( (sumsqr - sqrsum/(double)m) / (double)(m-1) );
  }
  return(avg);
}

◆ dmedian()

double dmedian	(	double *	data,
		int	n )

extern

Returns the median in array data[0..n-1]. Array is partially sorted. Algorithm is based on the book Wirth N. Algorithms + data structures = programs. Englewood Cliffs, Prentice-Hall, 1976.

See also: dmean, mean, fmedian

Returns: Returns the median in array data[0..n-1].

Parameters

data	Pointer to data; array is partially sorted.
n	Length of data array.

Definition at line 48 of file median.c.

  {
  int k;
  double d1, d2;
 
  if(n<1) return(0.0);
  if(n%2) {
    k=(n-1)/2; return(d_kth_smallest(data, n, k));
  } else {
    k=n/2; d1=d_kth_smallest(data, n, k-1); d2=d_kth_smallest(data, n, k);
    return(0.5*(d1+d2));
  }
}

Referenced by dftRobustMinMaxTAC(), least_trimmed_square(), and mEstim().

◆ drand()

double drand ( )

extern

Alternative function to rand() which returns a double precision floating point number in the range of [0,1].

Returns: Random value in the range [0,1].

See also: rand_range, gaussdev

Definition at line 142 of file gaussdev.c.

{
  double d, s;
  s=1.0/(1.0+RAND_MAX);
  do {
    d = ( ( s*rand() + rand() )*s + rand() ) * s;
  } while(d>=1.0);
  return d;
}

Referenced by gaussdev(), gaussdev2(), rand_range(), tgoRandomParameters(), and tgoRandomParametersST().

◆ drandSeed()

unsigned int drandSeed ( short int seed )

extern

Make and optionally set the seed for rand(), drand, drandRange, and drandGaussian().

Uses microseconds from the computer clock and process ID to reduce the chance of getting the same seed for simultaneously executing program threads and instances.

Returns: Returns the seed for srand().

Parameters

seed	Also sets seed with srand (1) or not (0)

Definition at line 63 of file gaussdev.c.

  {
  unsigned int li;
#ifdef HAVE_TIMESPEC_GET
  struct timespec ts;
  timespec_get(&ts, TIME_UTC);
  li=((ts.tv_sec % 10000)*523 ^ ts.tv_nsec*10) ^ ((getpid() % 1000)*983);
#elif defined HAVE_CLOCK_GETTIME
  struct timespec ts;
  clock_gettime(CLOCK_REALTIME, &ts);
  li=((ts.tv_sec % 10000)*523 ^ ts.tv_nsec*10) ^ ((getpid() % 1000)*983);
#elif defined HAVE_GETTIMEOFDAY
  struct timeval tv;
  gettimeofday(&tv, 0);
  li=((tv.tv_sec % 10000)*523 ^ tv.tv_usec*13) ^ ((getpid() % 1000)*983);
#else
  li=(unsigned int)time(NULL)+(unsigned int)getpid();
#endif
  li+=(unsigned int)rand();
  if(seed) srand(li);
  //printf("seed := %u\n", li); printf("RAND_MAX := %u\n", RAND_MAX);
  return(li);
}

Referenced by tgo().

◆ fintegrate()

int fintegrate	(	float *	x,
		float *	y,
		int	nr,
		float *	yi )

extern

float version of integrate().

Linear integration from time 0 to x[0..nr-1]. If x[0] is >0 and x[0]<=(x[1]-x[0]), then the beginning is interpolated from it to (0,0).

Returns: Returns 0 if OK, or 1, if error.

See also: integrate, fpetintegrate, finterpolate

Parameters

x	Original x values; duplicates are not allowed, all must be >=0. Data must be sorted by ascending x
y	Original y values
nr	Nr of values
yi	Array for integrals

Definition at line 300 of file integr.c.

  {
  int j;
 
  if(nr==1 || x[0]<=(x[1]-x[0])) yi[0]=0.5*y[0]*x[0];
  else yi[0]=0; /*If the gap in the beginning is longer than time 
                 between first and second time point */
  for(j=1; j<nr; j++) yi[j]=yi[j-1]+0.5*(y[j]+y[j-1])*(x[j]-x[j-1]);
 
  return 0;
}

◆ finterpolate()

int finterpolate	(	float *	x,
		float *	y,
		int	nr,
		float *	newx,
		float *	newy,
		float *	newyi,
		float *	newyii,
		int	newnr )

extern

float version of interpolate().

It is assumed that both original and new interpolated data represent the actual values at specified time points (not from framed data). The integration is calculated dot-by-dot.

If NULL is specified for newy[], newyi[] and/or newyii[], their values are not calculated.

Original data and new x values must be sorted by ascending x. Subsequent x values can have equal values, enabling the use of step functions. Negative x (time) values can be processed. If necessary, the data is extrapolated assuming that: 1) y[inf]=y[nr-1] and 2) if x[0]>0, y[0]>0 and x[0]<=x[1]-x[0], then an imaginary line is drawn from (0,0) to (x[0],y[0]).

Returns: Non-zero in case of an error.

See also: interpolate, fintegrate

Parameters

x	Input data x (time) values
y	Input data y values
nr	Number of values in input data
newx	Output data x values
newy	Interpolated (extrapolated) y values; NULL can be given if not needed
newyi	Integrals; NULL can be given if not needed
newyii	2nd integrals; NULL can be given if not needed
newnr	Nr of values in output data

Definition at line 161 of file integr.c.

  {
  int i, j;
  float ty, tyi, tyii;
  float ox1, ox2, oy1, oy2, oi1, oi2, oii1, oii2, dt, ndt;
  int verbose=0;
 
  if(verbose>0) printf("in finterpolate()\n");
  /* Check for data */
  if(nr<1 || newnr<1) return 1;
  /* Check that programmer understood that outp data must've been allocated */
  if(newy==NULL && newyi==NULL && newyii==NULL) return 2;
 
  /* Initiate first two input samples */
  ox1=ox2=x[0];
  oy1=oy2=y[0];
  /* Extrapolate the initial phase with triangle... */
  if(ox1>0.0) {
    oy1=0.0;
    /* unless:
       -first input sample y<=0
       -initial gap is longer than input TAC sampling frequency
    */
    if(y[0]>0.0 && (nr>1 && x[0]<=x[1]-x[0])) ox1=0.0;
  }
  /* Integrals too */
  oi1=oii1=0.0;
  oi2=oi1 + (ox2-ox1)*(oy1+oy2)/2.0;
  oii2=oii1 + (ox2-ox1)*(oi1+oi2)/2.0;
 
  /* Set interpolated data before input data (even imaginary) to zero */
  j=0; while(j<newnr && newx[j]<ox1) {
    ty=tyi=tyii=0.0;
    if(newy!=NULL) newy[j]=ty;
    if(newyi!=NULL) newyi[j]=tyi;
    if(newyii!=NULL) newyii[j]=tyii;
    j++;
  } 
 
  /* Set interpolated data between ox1 and ox2 */
  dt=ox2-ox1; if(dt>0.0) while(j<newnr && newx[j]<=ox2) {
    ndt=newx[j]-ox1;
    ty=((oy2-oy1)/dt)*ndt + oy1; if(newy!=NULL) newy[j]=ty;
    tyi=oi1 + 0.5*(ty+oy1)*ndt; if(newyi!=NULL) newyi[j]=tyi;
    if(newyii!=NULL) newyii[j]=tyii= oii1 + 0.5*(tyi+oi1)*ndt;
    j++;
  }
 
  /* Go through input data, sample-by-sample */
  for(i=0; i<nr && j<newnr; i++) {
 
    ox1=ox2; oy1=oy2; oi1=oi2; oii1=oii2;
    ox2=x[i]; oy2=y[i];
    oi2=oi1 + (ox2-ox1)*(oy1+oy2)/2.0;
    oii2=oii1 + (ox2-ox1)*(oi1+oi2)/2.0;
    
    /* Calculate input sample distance */
    dt=ox2-ox1; if(dt<0.0) return 3; else if(dt==0.0) continue;
 
    /* Any need for interpolation between ox1 and ox2? */
    while(j<newnr && newx[j]<=ox2) {
      ndt=newx[j]-ox1;
      ty=((oy2-oy1)/dt)*ndt + oy1; if(newy!=NULL) newy[j]=ty;
      tyi=oi1 + 0.5*(ty+oy1)*ndt; if(newyi!=NULL) newyi[j]=tyi;
      if(newyii!=NULL) newyii[j]=tyii= oii1 + 0.5*(tyi+oi1)*ndt;
      j++;
    }
 
  } // next input sample
 
  /* Set interpolated data after input data, assuming steady input */
  while(j<newnr) {
    ndt=newx[j]-ox2;
    ty=oy2;
    tyi=oi2 + oy2*ndt;
    tyii=oii2 + 0.5*(tyi+oi2)*ndt;
    if(newy!=NULL) newy[j]=ty;
    if(newyi!=NULL) newyi[j]=tyi;
    if(newyii!=NULL) newyii[j]=tyii;
    j++;
  } 
 
  if(verbose>0) printf("out finterpolate()\n");
  return 0;
}

Referenced by finterpolate4pet(), and imgTimeIntegral().

◆ finterpolate4pet()

int finterpolate4pet	(	float *	x,
		float *	y,
		int	nr,
		float *	newx1,
		float *	newx2,
		float *	newy,
		float *	newyi,
		float *	newyii,
		int	newnr )

extern

Interpolate and integrate TAC to PET frames. Float version of interpolate4pet().

It is assumed, that original data is not from framed data, but that the values represent the actual value at specified time point, which allows the integration to be calculated dot-by-dot.

If NULL is specified for *newy, *newyi and/or *newyii, their values are not calculated.

Original data and new x values must be sorted by ascending x. Subsequent x values can have equal values, enabling the use of step functions. PET frames can overlap, but interpolation may then be slower. Negative x (time) values can be processed. If necessary, the data is extrapolated assuming that 1) y[inf]=y[nr-1] and 2) if x[0]>0 and y[0]>0 and x[0]>x[1]-x[0], then an imaginary line is drawn from (0,0) to (x[0],y[0]).

Returns: Non-zero in case of an error.

See also: fpetintegral, interpolate4pet, fintegrate

Parameters

x	Times of original data
y	Values of original data
nr	Number of original data values
newx1	PET frame start times; frames may overlap
newx2	PET frame end times; frames may overlap
newy	Mean value during PET frame, or NULL if not needed; calculation may be faster if newyi is calculated too
newyi	Integral at frame mid time, or NULL if not needed
newyii	2nd integral at frame mid time, or NULL if not needed
newnr	Number of PET frames

Definition at line 646 of file integr.c.

  {
  int ret, fi, overlap=0, zeroframe=0;
  float petx[3], pety[3], petyi[3], petyii[3], fdur;
  int verbose=0;
 
  if(verbose>0) printf("in finterpolate4pet()\n");
 
  /* Check for data */
  if(nr<1 || newnr<1) return 1;
  /* Check that programmer understood that outp data must've been allocated */
  if(newy==NULL && newyi==NULL && newyii==NULL) return 2;
  /* Check that input data is not totally outside the input data */
  if(newx2[newnr-1]<=x[0] || newx1[0]>=x[nr-1]) return 3;
 
  /* Check frame lengths, also for overlap and zero length frames */
  for(fi=0; fi<newnr; fi++) {
    /* Calculate frame length */
    fdur=newx2[fi]-newx1[fi];
    /* If frame length is <0, that is an error */
    if(fdur<0.0) return 4;
    if(fdur==0.0) zeroframe++;
    /* Overlap? */
    if(fi>0 && newx2[fi-1]>newx1[fi]) overlap++;
  }
  if(verbose>1) {
    printf("overlap := %d\n", overlap);
    printf("zeroframe := %d\n", zeroframe);
  }
 
  /* Interpolate and integrate one frame at a time, if there is:
     -overlap in frames
     -frames of zero length
     -only few interpolated frames
     -if only integrals are needed
     -if neither of integrals is needed, then there is no temp memory to
      do otherwise
  */
  if(overlap>0 || zeroframe>0 || newnr<=3 || newy==NULL || (newyi==NULL && newyii==NULL) ) {
 
    if(verbose>1) printf("frame-by-frame interpolation/integration\n");
    for(fi=0; fi<newnr; fi++) {
      /* Set frame start, middle and end times */
      petx[0]=newx1[fi]; petx[2]=newx2[fi]; petx[1]=0.5*(petx[0]+petx[2]);
      /* Calculate frame length */
      fdur=petx[2]-petx[0];
      /* If frame length is <0, that is an error */
      if(fdur<0.0) return 4;
      /* If frame length is 0, then use direct interpolation */
      if(fdur==0.0) {
        ret=finterpolate(x, y, nr, petx, pety, petyi, petyii, 1);
        if(ret) return 10+ret;
        if(newy!=NULL) newy[fi]=petyi[0];
        if(newyi!=NULL) newyi[fi]=petyi[0];
        if(newyii!=NULL) newyii[fi]=petyii[0];
        continue;
      }
      /* Calculate integrals at frame start, middle, and end */
      ret=finterpolate(x, y, nr, petx, NULL, petyi, petyii, 3);
      if(ret) return 20+ret;
      /* Set output integrals, if required */
      if(newyi!=NULL) newyi[fi]=petyi[1];
      if(newyii!=NULL) newyii[fi]=petyii[1];
      /* Calculate frame mean, if required */
      if(newy!=NULL) newy[fi]=(petyi[2]-petyi[0])/fdur;
    } // next frame
 
  } else {
 
    if(verbose>1) printf("all-frames-at-once interpolation/integration\n");
    /* Set temp array */
    float *tp; if(newyii!=NULL) tp=newyii; else tp=newyi;
    /* Integrate at frame start times */
    ret=finterpolate(x, y, nr, newx1, NULL, tp, NULL, newnr);
    if(ret) return 10+ret;
    /* Integrate at frame end times */
    ret=finterpolate(x, y, nr, newx2, NULL, newy, NULL, newnr);
    if(ret) return 10+ret;
    /* Calculate average frame value */
    for(fi=0; fi<newnr; fi++)
      newy[fi]=(newy[fi]-tp[fi])/(newx2[fi]-newx1[fi]);
    /* Calculate integrals */
    if(newyi!=NULL || newyii!=NULL) {
      for(fi=0; fi<newnr; fi++) newx1[fi]+=0.5*(newx2[fi]-newx1[fi]);
      ret=finterpolate(x, y, nr, newx1, NULL, newyi, newyii, newnr);
      if(ret) return 10+ret;
      for(fi=0; fi<newnr; fi++) newx1[fi]-=(newx2[fi]-newx1[fi]);
    }
 
  }
 
  if(verbose>0) printf("out finterpolate4pet()\n");
  return 0;
}

◆ fitExpDecayNNLS()

int fitExpDecayNNLS	(	double *	x,
		double *	y,
		int	n,
		double	fittime,
		double	kmin,
		double	kmax,
		int	pnr,
		double *	a,
		double *	k,
		int *	fnr,
		int	verbose )

extern

Estimate initial values for sum of exponentials to be fitted on decaying x,y-data.

Returns: 0 when successful, otherwise <>0.

Parameters

x	Pointer to array of x values; must not contain NaNs; data is not changed; samples must be sorted by increasing x.
y	Pointer to array of y values; must not contain NaNs; data is not changed.
n	Nr of x and y samples (x and y array lengths); data is not changed.
fittime	Fittime is usually set to <=0 or a very high value to start the search for the best line fit from the last x,y sample towards the first sample; However, to exclude the end phase you may want to set fittime to include only certain time range from the beginning.
kmin	Minimum eigenvalue, must be >0; for example, 1.0E-06.
kmax	Maximum eigenvalue; for example, 1.0E+03.
pnr	Max number of exp functions to save; length of a[] and k[] arrays.
a	Pointer to an array of length pnr where exp function coefficients will be written; enter NULL if not needed.
k	Pointer to an array of length pnr where exp function eigenvalues will be written; enter NULL if not needed.
fnr	The number of fitted exponentials will be written in here; note that this number may be higher than pnr; enter NULL if not needed.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout

Definition at line 100 of file constraints.c.

  {
  if(verbose>0) 
    printf("fitExpDecayNNLS(x, y, %d, %g, %g, %g, ...)\n", n, fittime, kmin, kmax);
  if(n<3) return(1);
  if(fittime>0.0) {
    while(x[n-1]>fittime && n>0) n--;
    if(verbose>1) printf("  n := %d\n", n);
  } 
  if(kmin<1.0E-100) kmin=1.0E-100;
  if(kmax<=kmin) return(1);
 
  /* Allocate memory for NNLS */
  int      NNLS_N=100;
  int      nn, mm, nnls_n, nnls_m, nnls_index[NNLS_N];
  double  *nnls_a[NNLS_N], *nnls_b, *nnls_zz, nnls_x[NNLS_N], *nnls_mat,
           nnls_wp[NNLS_N], *dptr, nnls_rnorm;
 
  nnls_n=NNLS_N;
  nnls_m=n;
  nnls_mat=(double*)malloc(((nnls_n+2)*nnls_m)*sizeof(double));
  if(nnls_mat==NULL) return(2);
  for(nn=0, dptr=nnls_mat; nn<nnls_n; nn++) {nnls_a[nn]=dptr; dptr+=nnls_m;}
  nnls_b=dptr; dptr+=nnls_m; nnls_zz=dptr;
 
  /* Set exponent function decay parameters */
  double epar[NNLS_N];
  {
    double elnmin, elnmax;
    elnmin=log(kmin); elnmax=log(kmax);
    //double elnmin=-12.5, elnmax=6.7;
    double d, r;
    r=elnmax-elnmin;
    d=r/(double)(NNLS_N-1);
    for(nn=0; nn<nnls_n; nn++) epar[nn]=-exp(elnmin+(double)nn*d);
  }
 
  /* Fill NNLS matrix */
  for(mm=0; mm<nnls_m; mm++) {
    nnls_b[mm]=y[mm];
  }
  for(nn=0; nn<nnls_n; nn++)
    for(mm=0; mm<nnls_m; mm++)
      nnls_a[nn][mm]=exp(epar[nn]*x[mm]);
 
  /* NNLS */
  int ret;
  ret=nnls(nnls_a, nnls_m, nnls_n, nnls_b, nnls_x, &nnls_rnorm,
           nnls_wp, nnls_zz, nnls_index);
  if(ret>1) {
    if(verbose>0) fprintf(stderr, "Error: NNLS solution not possible.\n");
    free(nnls_mat);
    return(3);
  } else if(ret==1) {
    if(verbose>0) fprintf(stderr, "Warning: max iteration count exceeded in NNLS.\n");
  }
  if(verbose>2) {
    printf("NNLS results:\n");
    for(nn=0; nn<nnls_n; nn++) 
      printf("\t%e\t%g\t%g\n", epar[nn], nnls_x[nn], nnls_wp[nn]);
  }
  if(verbose>1) {
    printf("Reasonable NNLS results:\n");
    for(nn=0; nn<nnls_n; nn++) 
      if(nnls_wp[nn]==0.0) printf("\t%e\t%g\n", epar[nn], nnls_x[nn]);
  }
 
  /* Reset exponent function decay parameters with the clusters found above */
  {
    if(verbose>1) printf("Cluster means:\n");
    int i, j, nr;
    double ev;
    i=j=0;    
    while(1) {
      /* jump over functions with wp<0 */
      while(i<nnls_n && nnls_wp[i]<0.0) i++;
      if(i==nnls_n) break;
      /* calculate mean of this cluster */
      nr=0; ev=0.0;
      while(i<nnls_n && nnls_wp[i]==0.0) {nr++; ev+=epar[i]; i++;}
      ev/=(double)nr;
      if(verbose>1) printf("mean_e := %e\n", ev);
      epar[j++]=ev;
    }
    nnls_n=j;
  }
 
  /* Fill NNLS matrix with these functions */
  for(mm=0; mm<nnls_m; mm++) {
    nnls_b[mm]=y[mm];
  }
  for(nn=0; nn<nnls_n; nn++)
    for(mm=0; mm<nnls_m; mm++)
      nnls_a[nn][mm]=exp(epar[nn]*x[mm]);
 
  /* NNLS */
  ret=nnls(nnls_a, nnls_m, nnls_n, nnls_b, nnls_x, &nnls_rnorm,
           nnls_wp, nnls_zz, nnls_index);
  if(ret>1) {
    if(verbose>0) fprintf(stderr, "Error: NNLS solution not possible.\n");
    free(nnls_mat);
    return(3);
  } else if(ret==1) {
    if(verbose>0) fprintf(stderr, "Warning: max iteration count exceeded in NNLS.\n");
  }
  if(verbose>1) {
    printf("NNLS results:\n");
    for(nn=0; nn<nnls_n; nn++) 
      printf("\t%e\t%g\t%g\n", epar[nn], nnls_x[nn], nnls_wp[nn]);
  }
  
  /* Return the results */
  int nr=0;
  for(nn=0; nn<nnls_n; nn++) {
    if(nnls_wp[nn]<0.0) continue;
    if(nr>=pnr) {nr++; continue;}
    if(a!=NULL) a[nr]=nnls_x[nn];
    if(k!=NULL) k[nr]=epar[nn];
    nr++;
  }
  if(fnr!=NULL) *fnr=nr;
 
  free(nnls_mat);
  return(0);
}

◆ fixed_params()

int fixed_params	(	int	n,
		const double *	lower,
		const double *	upper,
		const double *	delta )

extern

Determine how many of model parameters are fixed.

Returns: Returns the nr of fixed parameters.

Parameters

n	Total nr of parameters
lower	List of lower parameter limits
upper	List of upper parameter limits
delta	List of parameter deltas; enter NULL if not available

Definition at line 418 of file bobyqa.c.

  {
  int i, fixed_n=0;
  for(i=0; i<n; i++) {
    if(upper[i]<=lower[i]) {fixed_n++; continue;}
    if(delta!=NULL && delta[i]==0.0) fixed_n++;
  }
  return(fixed_n);
}

Referenced by bobyqa().

◆ fpetintegral()

int fpetintegral	(	float *	x1,
		float *	x2,
		float *	y,
		int	nr,
		float *	ie,
		float *	iie )

extern

Integrate PET TAC data to frame mid times. Float version of petintegral().

Any of output arrays may be set to NULL if that is not needed. Frames must be in ascending time order. Gaps and small overlap are allowed. If x1[0]>0 and x1[0]<=x2[0]-x1[0], then an imaginary line is drawn from (0,0) to (x[0],y[0]).

Returns: Returns 0 if ok.

See also: petintegral, finterpolate4pet

Parameters

x1	frame start times
x2	frame end times
y	avg value during frame
nr	number of frames
ie	integrals at frame mid time
iie	2nd integrals at frame mid time

Definition at line 838 of file integr.c.

  {
  int i;
  float x, last_x, last_x2, last_y, last_integral, box_integral, half_integral;
  float gap_integral, integral, integral2, frame_len, xdist, s;
 
  /* Check for data */
  if(nr<1 || nr<1) return(1);
  /* Check that programmer understood that output must've been allocated */
  if(ie==NULL && iie==NULL) return(2);
 
  /* Initiate values to zero */
  last_x=last_x2=last_y=last_integral=0.0;
  box_integral=gap_integral=integral=integral2=frame_len=0.0;
 
  for(i=0; i<nr; i++) {
    frame_len=x2[i]-x1[i]; if(frame_len<0.0) return(5);
    x=0.5*(x1[i]+x2[i]); xdist=x-last_x; if(last_x>0.0 && xdist<=0.0) return(6);
    if(x<0) {
      if(ie!=NULL) ie[i]=integral;
      if(iie!=NULL) iie[i]=integral2;
      continue;
    }
    s=(y[i]-last_y)/xdist; /* slope */
    /*If there is a big gap in the beginning it is eliminated */
    if(i==0)if(x1[0]>x2[0]-x1[0]){last_x2=last_x=x1[0];}
    /*Integral of a possible gap between frames*/
    gap_integral=(x1[i]-last_x2)*(last_y+s*((last_x2+x1[i])/2.0-last_x));
    /*Integral from the beginning of the frame i to the middle of the frame */
    half_integral=(x-x1[i])*(last_y+s*((x1[i]+x)/2.0-last_x));
    integral=box_integral+gap_integral+half_integral; 
    /* half_integral is not added to box because it is more accurate to 
       sum integrals of full frames */
    box_integral+=gap_integral+frame_len*y[i];
    integral2+=xdist*(integral+last_integral)*0.5;
    if(ie!=NULL) ie[i]=integral;
    if(iie!=NULL) iie[i]=integral2;
    last_x=x; last_x2=x2[i];
    last_y=y[i]; last_integral=integral;
  }
 
  return(0);
}

Referenced by img_logan(), and img_patlak().

◆ fpetintegrate()

int fpetintegrate	(	float *	x1,
		float *	x2,
		float *	y,
		int	nr,
		float *	newyi,
		float *	newyii )

extern

Calculates integrals of PET data at frame end times. Float version of petintegrate().

Data does not have to be continuous, but it must be increasing in time. For faster performance in repetitive calls, allocate memory for integral[] even if it is not needed. If x1[0] is >0 AND x1[0] is <=(x2[0]-x1[0]), then the beginning is interpolated from (0, 0) to (x1[0], y1[0]*x1[0]/x) where x is midtime of the first frame.

Returns: Returns 0 if ok.

See also: petintegrate, finterpolate, fintegrate, finterpolate4pet, fpetintegrate2fe

Parameters

x1	Array of frame start times
x2	Array of frame end times
y	Array of y values (avg during each frame)
nr	Nr of frames
newyi	Output: integral values at frame end times, or NULL
newyii	Output: 2nd integral values at frame end times, or NULL

Definition at line 418 of file integr.c.

  {
  int i, allocated=0;
  float *ti, x, a;
 
 
  /* Check that data is increasing in time and is not (much) overlapping */
  if(nr<1 || x1[0]<0) return 1;
  for(i=0; i<nr; i++) if(x2[i]<x1[i]) return 2;
  for(i=1; i<nr; i++) if(x1[i]<=x1[i-1]) return 3;
 
  /* Allocate memory for temp data, if necessary */
  if(newyi==NULL) {
    allocated=1;
    ti=(float*)malloc(nr*sizeof(float)); if(ti==NULL) return 4;
  } else
    ti=newyi;
 
  /* Calculate the integral at the end of first frame */
  ti[0]=(x2[0]-x1[0])*y[0];
  /* If frame does not start at 0 time, add the area in the beginning */
  /* But only if the gap in the beginning is less than the lenght of the 
     first frame */
  if(x1[0]>0) {
    if(x1[0]<=x2[0]-x1[0]) {
       x=(x1[0]+x2[0])/2.0; 
       a=(x1[0]*(y[0]/x)*x1[0])/2.0; 
       ti[0]+=a;
    }
  }
 
  /* Calculate integrals at the ends of following frames */
  for(i=1; i<nr; i++) {
    /* Add the area of this frame to the previous integral */
    a=(x2[i]-x1[i])*y[i]; ti[i]=ti[i-1]+a;
    /* Check whether frames are contiguous */
    if(x1[i]==x2[i-1]) continue;
    /* When not, calculate the area of an imaginary frame */
    x=(x1[i]+x2[i-1])/2.0;
    a=(x1[i]-x2[i-1])*
      (y[i]-(y[i]-y[i-1])*(x2[i]+x1[i]-2.0*x)/(x2[i]+x1[i]-x2[i-1]-x1[i-1]));
    ti[i]+=a;
  }
 
  /* Copy integrals to output if required */
  if(allocated) for(i=0; i<nr; i++) newyi[i]=ti[i];
 
  /* Calculate 2nd integrals if required */
  if(newyii!=NULL) {
    newyii[0]=x2[0]*ti[0]/2.0;
    for(i=1; i<nr; i++)
      newyii[i]=newyii[i-1]+(x2[i]-x2[i-1])*(ti[i-1]+ti[i])/2.0;
  }
  
  /* Free memory */
  if(allocated) free((char*)ti);
 
  return 0;
}

◆ fpetintegrate2fe()

int fpetintegrate2fe	(	float *	x1,
		float *	x2,
		float *	y,
		int	nr,
		float *	e,
		float *	ie,
		float *	iie )

extern

Integrate PET TAC data to frame end times. Float version of petintegrate2fe().

Any of output arrays may be set to NULL if that is not needed. Frames must be in ascending time order. Gaps and small overlap are allowed. If x1[0]>0 and x1[0]<=x2[0]-x1[0], then an imaginary line is drawn from (0,0) to (x[0],y[0]).

Returns: Returns 0 if ok.

See also: petintegrate2fe

Parameters

x1	frame start times
x2	frame end times
y	avg value during frame
nr	number of frames
e	values at frame end time
ie	integrals at frame end time
iie	2nd integrals at frame end time

Definition at line 974 of file integr.c.

  {
  int i;
  float x, last_x, last_x2, last_y, last_integral;
  float value, integral, integral2, frame_len, xdist, s;
 
  /* Check for data */
  if(nr<1 || nr<1) return(1);
  /* Check that programmer understood that output must've been allocated */
  if(e==NULL && ie==NULL && iie==NULL) return(2);
 
  /* Initiate values to zero */
  last_x=last_x2=last_y=last_integral=value=integral=integral2=frame_len=s=0.0;
 
  for(i=0; i<nr; i++) {
    frame_len=x2[i]-x1[i]; if(frame_len<0.0) return(5);
    x=0.5*(x1[i]+x2[i]); xdist=x-last_x; if(last_x>0.0 && xdist<=0.0) return(6);
    if(x<0) {
      if(e!=NULL) e[i]=value;
      if(ie!=NULL) ie[i]=integral;
      if(iie!=NULL) iie[i]=integral2;
      continue;
    }
    s=(y[i]-last_y)/xdist; /* slope between x[i-1] and x[i] */
    /* If there is a big gap in the beginning, it is eliminated */
    if(i==0 && x1[0]>x2[0]-x1[0]) {last_x2=last_x=x1[0];}
    integral+=(x1[i]-last_x2)*(last_y+s*((last_x2+x1[i])/2.0-last_x)); /*gap*/
    integral+=frame_len*y[i];
    integral2+=(x2[i]-last_x2)*(integral+last_integral)*0.5;
    if(e!=NULL && i>0) {
      value=last_y+s*(last_x2-last_x); /* value at previous frame end */
      e[i-1]=value;
    }
    if(ie!=NULL) ie[i]=integral;
    if(iie!=NULL) iie[i]=integral2;
    last_x=x; last_x2=x2[i]; last_y=y[i]; last_integral=integral;
  }
  if(e!=NULL) {
    value=last_y+s*(last_x2-last_x); /* Value for the last frame */
    e[i-1]=value;
  }
 
  return(0);
}

◆ gaussdev()

double gaussdev ( )

extern

Applies the polar form of Box-Müller transform to produce pseudo-random numbers with Gaussian (normal) distribution which has a zero mean and standard deviation of one. Box GEP, Muller ME. A note on the generation of random normal deviates. Annals of Mathematical Statistics, Volume 29, Issue 2, 1958, 610-611. Available from JSTOR https://www.jstor.org/

Returns: Returns the pseudo-random number.

See also: gaussdev2, drand

Definition at line 30 of file gaussdev.c.

{
  static int ready=0, first=1;
  static double dev;
  double fac, rsq, a, b;
  if(first) {first=0; init_gaussdev();}
 
  /* If we don't have deviate already, then we'll have to make one */
  if(!ready) {
    do {
      //a = 2.*(double)rand()/(double)RAND_MAX - 1.0; 
      //b = 2.*(double)rand()/(double)RAND_MAX - 1.0; 
      a = 2.*drand() - 1.0; 
      b = 2.*drand() - 1.0; 
      rsq = a*a + b*b; 
    } while (rsq>=1.0 || rsq==0.0);
   
    fac = sqrt(-2.0*log(rsq)/rsq);
    dev=a*fac; ready=1; 
    return(b*fac); 
  } else { /* dev is ready so return it */
    ready=0;
    return(dev);
  }
}

◆ gaussdev2()

double gaussdev2 ( )

extern

Applies the polar form of Box-Müller transform to produce pseudo-random numbers with Gaussian (normal) distribution which has a zero mean and standard deviation of one. This function does never set seed, like gaussdev() does, therefore set seed for random number generator before first calling this routine, for example with srand(time(NULL));

Box GEP, Muller ME. A note on the generation of random normal deviates. Annals of Mathematical Statistics, Volume 29, Issue 2, 1958, 610-611. Available from JSTOR https://www.jstor.org/

Returns: Returns the pseudo-random number.

See also: gaussdev, drand

Definition at line 112 of file gaussdev.c.

{
  static int ready=0;
  static double dev;
  double fac, rsq, a, b;
 
  /* If we don't have deviate already, then we'll have to make one */
  if(!ready) {
    do {
      a = 2.*drand() - 1.0; 
      b = 2.*drand() - 1.0; 
      rsq = a*a + b*b; 
    } while (rsq>=1.0 || rsq==0.0);
   
    fac = sqrt(-2.0*log(rsq)/rsq);
    dev=a*fac; ready=1; 
    return(b*fac); 
  } else { /* dev is ready so return it */
    ready=0;
    return(dev);
  }
}

◆ highest_slope()

int highest_slope	(	double *	x,
		double *	y,
		int	n,
		int	slope_n,
		double *	m,
		double *	c,
		double *	xi,
		double *	xh )

extern

Finds the regression line with the highest slope for x,y data.

See also: highest_slope_after, regr_line, best_pearson

Returns: Return 0 if ok.

Parameters

x	An array of x axis values
y	An array of y axis values
n	The number of values in x and y arrays
slope_n	The number of samples used to fit the line
m	Pointer where calculated slope is written; NULL if not needed
c	Pointer where calculated y axis intercept is written; NULL if not needed
xi	Pointer where calculated x axis intercept is written; NULL if not needed
xh	Pointer where the place (x) of the highest slope is written; NULL if not needed

Definition at line 424 of file pearson.c.

  {
  int i, ret, i_at_max=0;
  double slope, ic, max_slope, ic_at_max=0.0;
 
  /* Check the data */
  if(x==NULL || y==NULL) return(1);
  if(n<2) return(2);
  if(slope_n>n) return(3);
 
  /* Compute */
  max_slope=-1.0E200;
  for(i=0; i<=n-slope_n; i++) {
    ret=regr_line(x+i, y+i, slope_n, &slope, &ic); if(ret) continue;
    if(slope>max_slope) {max_slope=slope; ic_at_max=ic; i_at_max=i;}
  } /* next slope */
  if(max_slope==-1.0E200) return(10);
  if(m!=NULL) *m=max_slope;
  if(c!=NULL) *c=ic_at_max;
  if(xi!=NULL) {if(max_slope!=0.0) *xi=-ic_at_max/max_slope; else *xi=0.0;}
  if(xh!=NULL) {
    *xh=0.0; for(i=i_at_max; i<i_at_max+slope_n; i++) *xh+=x[i];
    *xh/=(double)slope_n;
  }
 
  return(0);
}

Referenced by dftFixPeak().

◆ highest_slope_after()

int highest_slope_after	(	double *	x,
		double *	y,
		int	n,
		int	slope_n,
		double	x_start,
		double *	m,
		double *	c,
		double *	xi,
		double *	xh )

extern

Finds the regression line with the highest slope for x,y data after specified x.

See also: highest_slope, regr_line

Returns: Return 0 if ok.

Parameters

x	An array of x axis values.
y	An array of y axis values.
n	The number of values in x and y arrays.
slope_n	The number of samples used to fit the line.
x_start	Estimation start x value, samples with smaller x are ignored; can usually be set to zero.
m	Pointer where calculated slope is written; NULL if not needed.
c	Pointer where calculated y axis intercept is written; NULL if not needed.
xi	Pointer where calculated x axis intercept is written; NULL if not needed.
xh	Pointer where the place (x) of the highest slope is written; NULL if not needed.

Definition at line 475 of file pearson.c.

  {
  int i, ret, i_at_max=0;
  double slope, ic, max_slope, ic_at_max=0.0;
 
  /* Check the data */
  if(x==NULL || y==NULL) return(1);
  if(n<2) return(2);
  if(slope_n>n) return(3);
 
  /* Compute */
  max_slope=-1.0E200;
  for(i=0; i<=n-slope_n; i++) if(x[i]>=x_start) {
    ret=regr_line(x+i, y+i, slope_n, &slope, &ic); if(ret) continue;
    if(slope>max_slope) {max_slope=slope; ic_at_max=ic; i_at_max=i;}
  } /* next slope */
  if(max_slope==-1.0E200) return(10);
  if(m!=NULL) *m=max_slope;
  if(c!=NULL) *c=ic_at_max;
  if(xi!=NULL) {if(max_slope!=0.0) *xi=-ic_at_max/max_slope; else *xi=0.0;}
  if(xh!=NULL) {
    *xh=0.0; for(i=i_at_max; i<i_at_max+slope_n; i++) *xh+=x[i];
    *xh/=(double)slope_n;
  }
 
  return(0);
}

◆ householder_hm()

int householder_hm	(	double	tau,
		double *	vector,
		double **	matrix,
		int	rowNr,
		int	columnNr )

extern

Applies a householder transformation defined by vector "vector" and scalar tau to the left-hand side of the matrix. (I - tau vector vector^T)*matrix The result of the transform is stored in matrix.

Returns: Returns 0 if ok.

Parameters

tau	Coefficient defining householder transform.
vector	Vector defining householder transform (of size rowNr).
matrix	the matrix that is to be transformed.
rowNr	Nr of rows in matrix.
columnNr	Nr of columns in matrix.

Definition at line 68 of file hholder.c.

  {
  int i, j;
  double wj;
 
  if(tau==0.0) return(0); // success
  if(rowNr<1 || columnNr<1) return(1);
  for(j=0; j<columnNr; j++) {
    /* Compute wj = vk Akj */
    wj=matrix[0][j];
    for(i=1; i<rowNr; i++)  /* note, computed for v(0) = 1 above */
      wj += vector[i]*matrix[i][j];
    /* Aij = Aij - tau vi wj */
    /* i = 0 */
    matrix[0][j]-=tau*wj;
    /* i = 1 .. M-1 */
    for(i=1; i<rowNr; i++) matrix[i][j]-=tau*vector[i]*wj;
  }
  return(0);
}

Referenced by qr_decomp().

◆ householder_hv()

int householder_hv	(	double	tau,
		int	size,
		double *	v,
		double *	w )

extern

Applies a householder transformation defined by vector v and coefficient tau to vector w w = (I - tau v v^T) w.

Returns: Returns 0 if ok.

Parameters

tau	Coefficient defining householder transform.
size	Size of vectors v and w.
v	Vector v.
w	Vector w.

Definition at line 107 of file hholder.c.

  {
  int i;
  double d;
 
  if(tau==0) return(0); // success
  if(size<1) return(1);
  /* d = v'w */
  d=w[0]; for(i=1; i<size; i++) d+=v[i]*w[i];
  /* w = w - tau (v) (v'w) */
  w[0]-=tau*d;
  for(i=1; i<size; i++) w[i]-=tau*v[i]*d;
  return(0);
}

Referenced by qr_solve().

◆ householder_norm()

double householder_norm	(	double *	v,
		int	size )

extern

Calculates the euclidean norm of vector v[].

Returns: Returns the euclidean norm of a vector.

Parameters

v	Vector v
size	Size of vector v[]

Definition at line 136 of file hholder.c.

  {
  double help;
  int i;
 
  for(i=0, help=0; i<size; i++) help+=v[i]*v[i];
  return sqrt(help);
}

◆ householder_transform()

double householder_transform	(	double *	v,
		int	N )

extern

This function prepares a Householder transformation P = I - tau h h^T which can be used to zero all the elements of the input vector except the first one that will get value beta. On output the elements 1 - size-1 of the vector h are stored in locations vector[1] - vector[size-1] of the input vector and value of beta is stored in location vector[0].

Returns: The scalar tau is returned.

Parameters

v	The N-vector to be transformed.
N	size of the vector.

Definition at line 23 of file hholder.c.

  {
  double vnorm, alpha, beta, tau;
 
  if(N<1) return 0.0; // tau = 0
  /* Euclidean norm of the vector starting from the second value */
  vnorm=0.0; for(int n=1; n<N; n++) vnorm+=v[n]*v[n];
  vnorm=sqrt(vnorm); if(isnan(vnorm) || vnorm==0.0) return 0.0; // tau = 0
 
  /* Computing the coefficient tau */
  alpha=v[0];
  beta= - (alpha >= 0.0 ? +1.0 : -1.0) * hypot(alpha, vnorm);
  tau=(beta-alpha)/beta ;
 
  /* Scale the Householder vector so that the first element will be 1.
   * (Scaling is also affecting the coefficient tau).
   * Without scaling, the first element would have value (alpha - beta). */
  {
    double s=alpha-beta;
    if(fabs(s)>DBL_MIN) {
      v[0]=beta;
      for(int n=1; n<N; n++) v[n]*=(1.0/s);
    } else {
      v[0]=beta;
      for(int n=1; n<N; n++) v[n]*=(doubleMachEps()/s);
      for(int n=1; n<N; n++) v[n]*=(1.0/doubleMachEps());
    }
  }
 
  return tau;
}

Referenced by qr_decomp().

◆ huber()

double huber	(	double	x,
		double	b )

extern

Hubers function.

Returns: Returns x if |x|<b, and b otherwise.

Parameters

x	parameter x
b	cutoff point

Definition at line 53 of file mestim.c.

  {
  double help;
 
  if(x<-b) help=-b; else help=x;
  if(help<b) {return help;} else {return b;}
}

Referenced by mEstim().

◆ init_gaussdev()

void init_gaussdev ( )

extern

Initiate random number generator for gaussdev()

Definition at line 92 of file gaussdev.c.

{
  if(GAUSSDEV_SEED<1L) GAUSSDEV_SEED=893165470L;
  srand(GAUSSDEV_SEED);
}

Referenced by gaussdev().

◆ integrate()

int integrate	(	double *	x,
		double *	y,
		int	nr,
		double *	yi )

extern

Linear integration from time 0 to x[0..nr-1]. If x[0] is >0 and x[0]<=(x[1]-x[0]), then the beginning is interpolated from it to (0,0).

Returns: Returns 0 if OK, or 1, if error.

See also: fintegrate, petintegrate, interpolate

Parameters

x	Original x values; duplicates are not allowed, all must be >=0. Data must be sorted by ascending x
y	Original y values
nr	Nr of values
yi	Array for integrals

Definition at line 271 of file integr.c.

  {
  int j;
 
  if(nr==1 || x[0]<=(x[1]-x[0])) yi[0]=0.5*y[0]*x[0];
  else yi[0]=0; /*If the gap in the beginning is longer than time 
                 between first and second time point */
  for(j=1; j<nr; j++) yi[j]=yi[j-1]+0.5*(y[j]+y[j-1])*(x[j]-x[j-1]);
 
  return 0;
}

Referenced by dftReadReference().

◆ interpolate()

int interpolate	(	double *	x,
		double *	y,
		int	nr,
		double *	newx,
		double *	newy,
		double *	newyi,
		double *	newyii,
		int	newnr )

extern

Linear interpolation and integration.

It is assumed that both original and new interpolated data represent the actual values at specified time points (not from framed data). The integration is calculated dot-by-dot.

If NULL is specified for newy[], newyi[] and/or newyii[], their values are not calculated.

Original data and new x values must be sorted by ascending x. Subsequent x values can have equal values, enabling the use of step functions. Negative x (time) values can be processed. If necessary, the data is extrapolated assuming that: 1) y[inf]=y[nr-1] and 2) if x[0]>0, y[0]>0 and x[0]<=x[1]-x[0], then an imaginary line is drawn from (0,0) to (x[0],y[0]).

Returns: Non-zero in case of an error.

See also: finterpolate, integrate, petintegrate, petintegral, dftTimeIntegral

Parameters

x	Input data x (time) values
y	Input data y values
nr	Number of values in input data
newx	Output data x values
newy	Interpolated (extrapolated) y values; NULL can be given if not needed
newyi	Integrals; NULL can be given if not needed
newyii	2nd integrals; NULL can be given if not needed
newnr	Nr of values in output data

Definition at line 28 of file integr.c.

  {
  int i, j;
  double ty, tyi, tyii;
  double ox1, ox2, oy1, oy2, oi1, oi2, oii1, oii2, dt, ndt;
  int verbose=0;
 
  if(verbose>0) printf("in interpolate()\n");
  /* Check for data */
  if(nr<1 || newnr<1) return 1;
  /* Check that programmer understood that outp data must've been allocated */
  if(newy==NULL && newyi==NULL && newyii==NULL) return 2;
 
  /* Initiate first two input samples */
  ox1=ox2=x[0];
  oy1=oy2=y[0];
  /* Extrapolate the initial phase with triangle... */
  if(ox1>0.0) {
    oy1=0.0;
    /* unless:
       -first input sample y<=0
       -initial gap is longer than input TAC sampling frequency
    */
    if(y[0]>0.0 && (nr>1 && x[0]<=x[1]-x[0])) ox1=0.0;
  }
  /* Integrals too */
  oi1=oii1=0.0;
  oi2=oi1 + (ox2-ox1)*(oy1+oy2)/2.0;
  oii2=oii1 + (ox2-ox1)*(oi1+oi2)/2.0;
  if(verbose>2) {
    printf("ox1=%g oy1=%g oi1=%g oii1=%g\n", ox1, oy1, oi1, oii1);
    printf("ox2=%g oy2=%g oi2=%g oii2=%g\n", ox2, oy2, oi2, oii2);
  }
 
  /* Set interpolated data before input data (even imaginary) to zero */
  j=0; while(j<newnr && newx[j]<ox1) {
    ty=tyi=tyii=0.0; if(verbose>4) printf("  ndt=%g\n", ox1-newx[j]);
    if(verbose>4) printf("  j=%d newx=%g ty=%g tyi=%g tyii=%g\n", j, newx[j], ty, tyi, tyii);
    if(newy!=NULL) newy[j]=ty;
    if(newyi!=NULL) newyi[j]=tyi;
    if(newyii!=NULL) newyii[j]=tyii;
    j++;
  } 
 
  /* Set interpolated data between ox1 and ox2 */
  dt=ox2-ox1; if(dt>0.0) while(j<newnr && newx[j]<=ox2) {
    ndt=newx[j]-ox1; if(verbose>4) printf("  ndt=%g\n", ndt);
    ty=((oy2-oy1)/dt)*ndt + oy1; if(newy!=NULL) newy[j]=ty;
    tyi=oi1 + 0.5*(ty+oy1)*ndt; if(newyi!=NULL) newyi[j]=tyi;
    if(newyii!=NULL) newyii[j]=tyii= oii1 + 0.5*(tyi+oi1)*ndt;
    if(verbose>4) printf("  j=%d newx=%g ty=%g tyi=%g\n", j, newx[j], ty, tyi);
    j++;
  }
 
  /* Go through input data, sample-by-sample */
  for(i=0; i<nr && j<newnr; i++) {
 
    ox1=ox2; oy1=oy2; oi1=oi2; oii1=oii2;
    ox2=x[i]; oy2=y[i];
    oi2=oi1 + (ox2-ox1)*(oy1+oy2)/2.0;
    oii2=oii1 + (ox2-ox1)*(oi1+oi2)/2.0;
    if(verbose>>3) {
      printf("ox1=%g oy1=%g oi1=%g oii1=%g\n", ox1, oy1, oi1, oii1);
      printf("ox2=%g oy2=%g oi2=%g oii2=%g\n", ox2, oy2, oi2, oii2);
    }
    
    /* Calculate input sample distance */
    dt=ox2-ox1; if(dt<0.0) return 3; else if(dt==0.0) continue;
 
    /* Any need for interpolation between ox1 and ox2? */
    while(j<newnr && newx[j]<=ox2) {
      ndt=newx[j]-ox1;
      ty=((oy2-oy1)/dt)*ndt + oy1; if(newy!=NULL) newy[j]=ty;
      tyi=oi1 + 0.5*(ty+oy1)*ndt; if(newyi!=NULL) newyi[j]=tyi;
      if(newyii!=NULL) newyii[j]=tyii= oii1 + 0.5*(tyi+oi1)*ndt;
      if(verbose>5) printf("  j=%d newx=%g ty=%g tyi=%g\n", j, newx[j], ty, tyi);
      j++;
    }
 
  } // next input sample
 
  /* Set interpolated data after input data, assuming steady input */
  while(j<newnr) {
    ndt=newx[j]-ox2;
    ty=oy2;
    tyi=oi2 + oy2*ndt;
    tyii=oii2 + 0.5*(tyi+oi2)*ndt;
    if(newy!=NULL) newy[j]=ty;
    if(newyi!=NULL) newyi[j]=tyi;
    if(newyii!=NULL) newyii[j]=tyii;
    if(verbose>5) printf("  j=%d newx=%g ty=%g tyi=%g\n", j, newx[j], ty, tyi);
    j++;
  } 
 
  if(verbose>0) printf("out interpolate()\n");
  return 0;
}

Referenced by bfIrr2TCM(), bfRadiowater(), dftDivideFrames(), dftDoubleFrames(), dftInterpolate(), dftInterpolateInto(), dftReadinput(), dftTimeIntegral(), and interpolate4pet().

◆ interpolate4pet()

int interpolate4pet	(	double *	x,
		double *	y,
		int	nr,
		double *	newx1,
		double *	newx2,
		double *	newy,
		double *	newyi,
		double *	newyii,
		int	newnr )

extern

Interpolate and integrate TAC to PET frames.

It is assumed, that original data is not from framed data, but that the values represent the actual value at specified time point, which allows the integration to be calculated dot-by-dot.

If NULL is specified for *newy, *newyi and/or *newyii, their values are not calculated.

Original data and new x values must be sorted by ascending x. Subsequent x values can have equal values, enabling the use of step functions. PET frames can overlap, but interpolation may then be slower. Negative x (time) values can be processed. If necessary, the data is extrapolated assuming that 1) y[inf]=y[nr-1] and 2) if x[0]>0 and y[0]>0 and x[0]>x[1]-x[0], then an imaginary line is drawn from (0,0) to (x[0],y[0]).

Returns: Non-zero in case of an error.

See also: petintegrate, finterpolate4pet, interpolate, integrate, petintegral

Parameters

x	Times of original data
y	Values of original data
nr	Number of original data values
newx1	PET frame start times; frames may overlap
newx2	PET frame end times; frames may overlap
newy	Mean value during PET frame, or NULL if not needed; calculation may be faster if newyi is calculated too
newyi	Integral at frame mid time, or NULL if not needed
newyii	2nd integral at frame mid time, or NULL if not needed
newnr	Number of PET frames

Definition at line 510 of file integr.c.

  {
  int ret, fi, overlap=0, zeroframe=0;
  double petx[3], pety[3], petyi[3], petyii[3], fdur;
  int verbose=0;
 
  if(verbose>0) printf("in interpolate4pet()\n");
 
  /* Check for data */
  if(nr<1 || newnr<1) return 1;
  /* Check that programmer understood that outp data must've been allocated */
  if(newy==NULL && newyi==NULL && newyii==NULL) return 2;
  /* Check that input data is not totally outside the input data */
  if(newx2[newnr-1]<=x[0] || newx1[0]>=x[nr-1]) return 3;
 
  /* Check frame lengths, also for overlap and zero length frames */
  for(fi=0; fi<newnr; fi++) {
    /* Calculate frame length */
    fdur=newx2[fi]-newx1[fi];
    /* If frame length is <0, that is an error */
    if(fdur<0.0) return 4;
    if(fdur==0.0) zeroframe++;
    /* Overlap? */
    if(fi>0 && newx2[fi-1]>newx1[fi]) overlap++;
  }
  if(verbose>1) {
    printf("overlap := %d\n", overlap);
    printf("zeroframe := %d\n", zeroframe);
  }
 
  /* Interpolate and integrate one frame at a time, if there is:
     -overlap in frames
     -frames of zero length
     -only few interpolated frames
     -if only integrals are needed
     -if neither of integrals is needed, then there is no temp memory to
      do otherwise
  */
  if(overlap>0 || zeroframe>0 || newnr<=3 || newy==NULL || (newyi==NULL && newyii==NULL) ) {
 
    if(verbose>1) printf("frame-by-frame interpolation/integration\n");
    for(fi=0; fi<newnr; fi++) {
      /* Set frame start, middle and end times */
      petx[0]=newx1[fi]; petx[2]=newx2[fi]; petx[1]=0.5*(petx[0]+petx[2]);
      /* Calculate frame length */
      fdur=petx[2]-petx[0];
      /* If frame length is <0, that is an error */
      if(fdur<0.0) return 4;
      /* If frame length is 0, then use direct interpolation */
      if(fdur==0.0) {
        ret=interpolate(x, y, nr, petx, pety, petyi, petyii, 1);
        if(ret) return 10+ret;
        if(newy!=NULL) newy[fi]=petyi[0];
        if(newyi!=NULL) newyi[fi]=petyi[0];
        if(newyii!=NULL) newyii[fi]=petyii[0];
        continue;
      }
      /* Calculate integrals at frame start, middle, and end */
      ret=interpolate(x, y, nr, petx, NULL, petyi, petyii, 3);
      if(ret) return 20+ret;
      /* Set output integrals, if required */
      if(newyi!=NULL) newyi[fi]=petyi[1];
      if(newyii!=NULL) newyii[fi]=petyii[1];
      /* Calculate frame mean, if required */
      if(newy!=NULL) newy[fi]=(petyi[2]-petyi[0])/fdur;
    } // next frame
 
  } else {
 
    if(verbose>1) printf("all-frames-at-once interpolation/integration\n");
    /* Set temp array */
    double *tp; if(newyii!=NULL) tp=newyii; else tp=newyi;
    /* Integrate at frame start times */
    ret=interpolate(x, y, nr, newx1, NULL, tp, NULL, newnr);
    if(ret) return 10+ret;
    /* Integrate at frame end times */
    ret=interpolate(x, y, nr, newx2, NULL, newy, NULL, newnr);
    if(ret) return 10+ret;
    /* Calculate average frame value */
    for(fi=0; fi<newnr; fi++)
      newy[fi]=(newy[fi]-tp[fi])/(newx2[fi]-newx1[fi]);
    /* Calculate integrals */
    if(newyi!=NULL || newyii!=NULL) {
      for(fi=0; fi<newnr; fi++) newx1[fi]+=0.5*(newx2[fi]-newx1[fi]);
      ret=interpolate(x, y, nr, newx1, NULL, newyi, newyii, newnr);
      if(ret) return 10+ret;
      for(fi=0; fi<newnr; fi++) newx1[fi]-=(newx2[fi]-newx1[fi]);
    }
  }
 
  if(verbose>0) printf("out interpolate4pet()\n");
  return 0;
}

Referenced by bfIrr2TCM(), bfRadiowater(), dftAutointerpolate(), dftInterpolate(), dftInterpolateForIMG(), dftInterpolateInto(), img_k1_using_ki(), img_logan(), and img_patlak().

◆ least_median_of_squares()

double least_median_of_squares	(	double *	data,
		int	n )

extern

Fit a constant (horisontal straight line) to the data by minimising the median of squared residuals.

The algorithm is described in P.J. Rousseeuw: Least Median of Squares Regression, Journal of the American Statistical Association, Vol. 79, No. 388 (1984), 871-880.

Returns: Returns the LMS estimate.

Parameters

data	Data array
n	Number of data values

Definition at line 21 of file lms.c.

  {
  int i, odd=1, half=floor(n/2), smallnr;
  double small, *help;
  if(fmod((double)n, 2.0)<1e-99) odd=0;
  double *halfs_data;
 
  halfs_data=(double*)malloc((half+odd) * sizeof(double)); 
 
  help=data;
  /* sort data in ascending order*/
  qsort(help, n, sizeof(double), lmsQSort); 
 
  /* if n is even number */
  for(i=0; i<half+odd; i++) {
    halfs_data[i]=data[half+i]-data[i];
  }
 
  i=smallnr=0;
  for(i=1, small=halfs_data[0]; i<half+odd; i++) {
    if(halfs_data[i]<small) {
      small=halfs_data[i];
      smallnr=i;
    }
  }
 
  return (data[half+smallnr]+data[smallnr])/2.0;
}

◆ least_trimmed_square()

int least_trimmed_square	(	double	data[],
		long int	n,
		double *	mean,
		double *	variance )

extern

Least trimmed squares estimates for univariate location and variance. Data samples are expected to be truly real valued (i.e too many samples having the same value might lead to problems. The algorithm (exact) is described in P.J. Rousseeuw and A.M. Leroy: Robust Regression and Outlier Detection John Wiley & Sons 1987.

Returns: Returns 0, if successful.

Parameters

data	Input vector of n sample values; data samples are expected to be truly real valued (i.e too many samples having the same value might lead to problems.
n	Number of samples
mean	Output: Mean of sample values
variance	Output: Variance of sample values

Definition at line 27 of file lts.c.

  {
  int i, j, h, h2;
  double score, best_score, loc, best_loc, old_sum, new_sum, medd;
  double old_power_sum, new_power_sum;
  double *scaled_data;
 
  h = n - n/2;
  h2 = n/2;
 
  qsort(data, n, sizeof(double),ltsQSort); 
  
  old_sum=old_power_sum=0.0;
  for(i=0; i<h; i++) {
    old_sum = old_sum + data[i];
    old_power_sum = old_power_sum + data[i]*data[i];
  }
 
  loc = old_sum/h;  
  /* For better understanding of the algorithm: 
    O(N^2) implementation of the algorithm would compute score as:
    score = 0.0;
    for(i = 0;i < h;i++) {
      score = score + (data[i] - loc)*(data[i] - loc);
    } 
    But there is a faster way to this: */
  score = old_power_sum - old_sum*loc; 
  best_score = score;
  best_loc = loc;
  for(j=1; j<h2+1; j++) {
    new_sum = old_sum - data[j-1] + data[h-1+j];
    old_sum = new_sum;
    loc = old_sum/h;
    new_power_sum = old_power_sum - data[j-1]*data[j-1] 
                  + data[h-1+j]*data[h-1+j];
    old_power_sum = new_power_sum;
    score = old_power_sum - old_sum*loc; 
    if(score < best_score) {
      best_score = score;
      best_loc = loc;
    }
  }  
  *mean = best_loc;
 
  /* For the variance, it is needed to calculate the ellipsoid covering
     one half of samples. This is not implemented optimally here because
     data has already been sorted. */
  scaled_data = malloc(n*sizeof(double));
  if(scaled_data == NULL) return(1);
  for(i=0; i<n; i++)
    scaled_data[i] = (data[i]-best_loc)*((h-1)/best_score)*(data[i]-best_loc);
  medd = dmedian(scaled_data, n);
  free(scaled_data);
  *variance = (best_score/(h-1))*(medd/CHI2INV_1);
  return(0);
}

◆ llsqperp()

int llsqperp	(	double *	x,
		double *	y,
		int	nr,
		double *	slope,
		double *	ic,
		double *	ssd )

extern

Simple non-iterative perpendicular line fitting. This function is fully based on the article [1].

References:

Varga J & Szabo Z. Modified regression model for the Logan plot. J Cereb Blood Flow Metab 2002; 22:240-244.

See also: llsqperp3, medianline, llsqwt, mtga_best_perp

Returns: If successful, function returns value 0.

Parameters

x	Coordinates of data points (dimension nr).
y	Coordinates of data points (dimension nr).
nr	Number of data points.
slope	Estimated slope.
ic	Estimated intercept.
ssd	Sum of squared distances / nr.

Definition at line 382 of file llsqwt.c.

  {
  int i, rnr;
  double qxx, qyy, qxy, mx, my, a, b, c, d, m1, m2, ssd1, ssd2;
 
  if(0) {fprintf(stdout, "llsqperp()\n"); fflush(stdout);}
  /* Check the data */
  if(nr<2 || x==NULL || y==NULL) return(1);
  /* Calculate the means */
  for(i=0, mx=my=0; i<nr; i++) {mx+=x[i]; my+=y[i];}
  mx/=(double)nr; my/=(double)nr;
  /* Calculate the Q's */
  for(i=0, qxx=qyy=qxy=0; i<nr; i++) {
    a=x[i]-mx; b=y[i]-my; qxx+=a*a; qyy+=b*b; qxy+=a*b;
  }
  if(qxx<1.0E-100 || qyy<1.0E-100) return(2);
  /* Calculate the slope as real roots of quadratic equation */
  a=qxy; b=qxx-qyy; c=-qxy;
  rnr=quadratic(a, b, c, &m1, &m2);
  if(0) {
    fprintf(stdout, "%d quadratic roots", rnr);
    if(rnr>0) fprintf(stdout, " %g", m1);
    if(rnr>1) fprintf(stdout, " %g", m2);
    fprintf(stdout, " ; traditional slope %g\n", qxy/qxx);
  }
  if(rnr==0) return(3);
  /* Calculate the sum of squared distances for the first root */
  a=m1; b=-1; c=my-m1*mx;
  for(i=0, ssd1=0; i<nr; i++) {
    /* calculate the distance from point (x[i],y[i]) to line ax+by+c=0 */
    //d=(a*x[i]+b*y[i]+c)/sqrt(a*a+b*b);
    d=(a*x[i]+b*y[i]+c)/hypot(a, b);
    ssd1+=d*d;
  }
  /* Also to the 2nd root, if there is one */
  if(rnr==2) {
    a=m2; b=-1; c=my-m2*mx;
    for(i=0, ssd2=0; i<nr; i++) {
      /* calculate the distance from point (x[i],y[i]) to line ax+by+c=0 */
      //d=(a*x[i]+b*y[i]+c)/sqrt(a*a+b*b);
      d=(a*x[i]+b*y[i]+c)/hypot(a, b);
      ssd2+=d*d;
    }
  } else ssd2=ssd1;
  /* If there were 2 roots, select the one with smaller ssd */
  if(rnr==2 && ssd2<ssd1) {ssd1=ssd2; m1=m2;}
  /* Set the slope and intercept */
  *slope=m1; *ic=my-m1*mx; *ssd=ssd1/(double)nr;
 
  return(0);
}

Referenced by img_logan(), img_patlak(), llsqperp3(), and mtga_best_perp().

◆ llsqperp3()

int llsqperp3	(	double *	x,
		double *	y,
		int	nr,
		double *	slope,
		double *	ic,
		double *	ssd )

extern

Simple non-iterative perpendicular line fitting. This version of the function accepts data that contains NaN's.

See also: llsqperp, medianline

Returns: If successful, function returns value 0.

Parameters

x	Coordinates of data points (dimension nr).
y	Coordinates of data points (dimension nr).
nr	Number of data points.
slope	Estimated slope.
ic	Estimated intercept.
ssd	Sum of squared distances / nr.

Definition at line 453 of file llsqwt.c.

  {
  int i, j;
  double *nx, *ny;
 
  /* Allocate memory for new data pointers  */
  nx=(double*)calloc(nr, sizeof(double)); if(nx==NULL) return 1;
  ny=(double*)calloc(nr, sizeof(double));
  if(ny==NULL) {free((char*)nx); return 1;}
 
  /* Copy data to pointers  */
  for(i=0, j=0; i<nr; i++)
    if(!isnan(x[i]) && !isnan(y[i])) {nx[j]=x[i]; ny[j]=y[i]; j++;}
 
  /* Use llsqperp() */
  i=llsqperp(nx, ny, j, slope, ic, ssd);
  free((char*)nx); free((char*)ny);
  return(i);
}

◆ llsqWght()

int llsqWght	(	int	N,
		int	M,
		double **	A,
		double *	a,
		double *	b,
		double *	weight )

extern

Algorithm for weighting the problem that is given to a LLSQ algorithm.

Square roots of weights are used because in LLSQ algorithms the difference w*A-w*b is squared.

See also: llsqWghtSquared

Returns: Algorithm returns zero if successful, 1 if arguments are inappropriate.

Parameters

N	Matrix A dimension N (nr of parameters).
M	Matrix A dimension M (nr of samples).
A	Pointer to matrix A[N][M]; enter NULL to use following matrix format instead.
a	Pointer to matrix A[N*M]; enter NULL to use previous matrix format instead.
b	Vector B of length M.
weight	Weights for each sample (array of length M).

Definition at line 419 of file bvls.c.

  {
  int n, m;
  double *w;
 
  /* Check the arguments */
  if(N<1 || M<1 || (A==NULL && a==NULL) || b==NULL || weight==NULL) return(1);
 
  /* Allocate memory */
  w=(double*)malloc(M*sizeof(double)); if(w==NULL) return(2);
 
  /* Check that weights are not zero and get the square roots of them to w[] */
  for(m=0; m<M; m++) {
    if(weight[m]<=1.0e-20) w[m]=0.0;
    else w[m]=sqrt(weight[m]);
  }
 
  /* Multiply rows of matrix A and elements of vector b with weights*/
  for(m=0; m<M; m++) {
    for(n=0; n<N; n++) {
      if(A!=NULL) A[n][m]*=w[m];
      if(a!=NULL) a[m+n*M]*=w[m];
    }
    b[m]*=w[m];
  }
 
  free(w);
  return(0);
}

◆ llsqWghtSquared()

int llsqWghtSquared	(	int	N,
		int	M,
		double **	A,
		double *	a,
		double *	b,
		double *	sweight )

extern

Algorithm for weighting the problem that is given to a LLSQ algorithm.

Square roots of weights are used because in LLSQ algorithms the difference w*A-w*b is squared.

Here user must give squared weights; this makes calculation faster, when this function needs to be called many times.

See also: llsqWght

Returns: Algorithm returns zero if successful, 1 if arguments are inappropriate.

Parameters

N	Matrix A dimension N (nr of parameters).
M	Matrix A dimension M (nr of samples).
A	Pointer to matrix A[N][M]; enter NULL to use following matrix format instead.
a	Pointer to matrix A[N*M]; enter NULL to use previous matrix format instead.
b	Vector B of length M.
sweight	Squared weights for each sample (array of length M).

Definition at line 474 of file bvls.c.

  {
  int n, m;
 
  /* Check the arguments */
  if(N<1 || M<1 || (A==NULL && a==NULL) || b==NULL || sweight==NULL) return(1);
 
  /* Multiply rows of matrix A and elements of vector b with weights*/
  for(m=0; m<M; m++) {
    for(n=0; n<N; n++) {
      if(A!=NULL) A[n][m]*=sweight[m];
      if(a!=NULL) a[m+n*M]*=sweight[m];
    }
    b[m]*=sweight[m];
  }
 
  return(0);
}

◆ llsqwt()

int llsqwt	(	double *	x,
		double *	y,
		int	n,
		double *	wx,
		double *	wy,
		double	tol,
		double *	w,
		double *	ic,
		double *	slope,
		double *	nwss,
		double *	sic,
		double *	sslope,
		double *	cx,
		double *	cy )

extern

Iterative method for linear least-squares fit with errors in both coordinates.

This function is fully based on article [3].

For n data-point pairs (x[i], y[i]) each point has its own weighting factors in (wx[i], wy[i]). This routine finds the values of the parameters m (slope) and c (intercept, ic) that yield the "best-fit" of the model equation Y = mX + c to the data, where X and Y are the predicted or calculated values of the data points.

Weighting factors wx and wy must be assigned as the inverses of the variances or squares of the measurement uncertainties (SDs), i.e. w[i]=1/(sd[i])^2

If true weights are unknown but yet the relative weights are correct, the slope, intercept and residuals (WSS) will be correct. The applied term S/(N-2) makes also the estimate of sigma (sd) of slope less dependent on the scaling of weights. The sigmas are not exact, since only the lowest-order terms in Taylor-series expansion are incorporated; anyhow sigmas are more accurate than the ones based on York algorithm.

One or more data points can be excluded from the fit by setting either x or y weight to 0.

References:

York, D. Linear-squares fitting of a straight line. Can J Phys. 1966;44:1079-1086.
Lybanon, M. A better least squares method when both variables have uncertainties. Am J Phys. 1984;52:22-26 and 276-278.
Reed BC. Linear least-squares fits with errors in both coordinates. II: Comments on parameter variances. Am J Phys. 1992;60:59-62.

See also: llsqperp, best_llsqwt, medianline

Returns: If successful, function returns value 0.

Parameters

x	coordinates of data points (of dimension n).
y	coordinates of data points (of dimension n).
n	number of data points.
wx	weighting factors in x.
wy	weighting factors in y.
tol	allowed tolerance in slope estimation.
w	work vector (of dimension n); effective weights w[i] are returned in it.
ic	Estimated intercept.
slope	Estimated slope.
nwss	sqrt(WSS)/wsum of the residuals.
sic	expected sd of intercept at calculated points; If NULL, then not calculated and variable is left unchanged.
sslope	Expected sd of slope at calculated points; If NULL, then not calculated and variable is left unchanged.
cx	Estimated data points (X,y); If NULL, then not calculated and variable is left unchanged.
cy	Estimated data points (x,Y); If NULL, then not calculated and variable is left unchanged.

Definition at line 48 of file llsqwt.c.

  {
  int i, j, niter=0, nn, calcVar=1;
  double c, m, f, xb=0.0, yb=0.0, qa=0.0, qb=0.0, qc, ss=0.0, s1, s2, wsum=0.0;
  double xsum=0.0, x2sum=0.0, ysum=0.0, xysum=0.0, delta, discr, sqdis;
  double m_1, m_2, bcont, m2=0.0, w2;
  double u, v, AA, BB, CC, DD, EE, FF, GG, HH, JJ;
  double varc, varm, dmx, dmy, dcx, dcy;
 
 
  /*
   *  Lets look what we got for arguments
   */
  if(0) {fprintf(stdout, "llsqwt()\n"); fflush(stdout);}
  /* Check that there is some data */
  if(n<2) return(1);
  if(0) {
    for(i=0; i<n; i++) printf("%e +- %e    %e +- %e\n",
      x[i], wx[i], y[i], wy[i]);
  }
  if(tol<1.0e-100) return(1);
  if(w==NULL) return(1);
  /* Check if variances and fitted data will be calculated */
  if(sic==NULL || sslope==NULL || cx==NULL || cy==NULL) calcVar=0;
  else calcVar=1;
 
  /* If only 2 datapoints */
  if(n==2) {
    f=x[1]-x[0];
    if(f==0.0) {*slope=*ic=*sic=*sslope=*nwss=w[0]=w[1]=0.0; return(0);}
    *slope=(y[1]-y[0])/f; *ic=y[0]-(*slope)*x[0];
    *sic=*sslope=0.; w[0]=1.0; w[1]=1.0; *nwss=0.0;
    return(0);
  }
 
  /*
   *  Fit the LLSQ line
   */
 
  /* First estimation of the slope and intercept by unweighted regression */
  for(i=0; i<n; i++) {
    xsum+=x[i]; ysum+=y[i]; x2sum+=x[i]*x[i]; xysum+=x[i]*y[i];
  }
  delta=(double)n*x2sum - xsum*xsum;
  /* Initial guesses of the slope and intercept */
  if(delta==0.0) {
    if(0) printf("x axis values contain only zeroes.\n");
    *slope=*ic=*sic=*sslope=*nwss=w[0]=w[1]=0.0;
    return(0);
  }
  m=((double)n*xysum - xsum*ysum)/delta;
  c=(x2sum*ysum - xsum*xysum)/delta;
  if(0) printf("initial guesses: a=%e b=%e\n", c, m);
 
  /* Begin the iterations */
  bcont=m+2.0*tol;
  while(fabs(m-bcont)>tol && niter<20) {
    if(0) printf(" %d. iteration, improvement=%g, tol=%g\n", niter, fabs(m-bcont), tol);
    bcont=m; niter++; 
    /* Compute the weighting factors */
    m2=m*m;
    for(i=0, nn=0; i<n; i++) {
      if(wx[i]<=0.0 || wy[i]<=0.0) w[i]=0.0;
      else {w[i]=wx[i]*wy[i]/(m2*wy[i]+wx[i]); nn++;}
      //printf("wx[i]=%g wy[i]=%g -> w[%d]=%g\n", wx[i], wy[i], i, w[i]);
    }
    if(nn<2) {
      if(0) printf("less than two points with weight > 0.\n");
      *slope=*ic=*sic=*sslope=*nwss=0.0;
      return(0);   
    }
    /* Compute the barycentre coordinates */
    for(i=0, xb=yb=wsum=0.0; i<n; i++) {xb+=w[i]*x[i]; yb+=w[i]*y[i]; wsum+=w[i];}
    if(wsum<=0.0) return(2);
    xb/=wsum; yb/=wsum;
    if(0) printf("barycentre: xb=%g yb=%g\n", xb, yb);
    /* Estimate the slope as either of the roots of the quadratic */
    /* compute the coefficients of the quadratic */
    for(i=0, qa=qb=qc=0.0; i<n; i++) if(w[i]>0.0) {
      u=x[i]-xb; v=y[i]-yb; w2=w[i]*w[i];
      qa += w2*u*v/wx[i];
      qb += w2*(u*u/wy[i] - v*v/wx[i]);
      qc += -w2*u*v/wy[i];
    }
    if(0) printf("quadratic coefs: qa=%g qb=%g qc=%g\n", qa, qb, qc);
    if(qa==0.0) {
      m=0.0;
      /* Calculate WSS */
      for(i=0, ss=0.0; i<n; i++) {f=v=y[i]-yb; ss+=w[i]*f*f;}
    } else if(qa==1.0) { /* check if quadratic reduces to a linear form */
      m=-qc/qb;
      /* Calculate WSS */
      for(i=0, ss=0.0; i<n; i++) {u=x[i]-xb; v=y[i]-yb; f=v-m*u; ss+=w[i]*f*f;}
    } else {
      /* discriminant of quadratic */
      discr=qb*qb-4.0*qa*qc; if(discr<=0.0) sqdis=0.0; else sqdis=sqrt(discr);
      /* compute the two solutions of quadratic */
      m_1=(-qb+sqdis)/(2.0*qa); m_2=(-qb-sqdis)/(2.0*qa);
      /* Calculate WSS for both solutions */
      for(i=0, s1=s2=0.0; i<n; i++) {
        u=x[i]-xb; v=y[i]-yb;
        f=v-m_1*u; s1+=w[i]*f*f;
        f=v-m_2*u; s2+=w[i]*f*f;
      }
      /* choose the solution with lower WSS */
      if(s1<=s2) {m=m_1; ss=s1;} else {m=m_2; ss=s2;}
    }
    /* Calculate the intercept */
    c = yb - m*xb;
    if(0) printf("iterated parameters: c=%e m=%e\n", c, m);
 
  } /* end of iteration loop */
  *ic=c; *slope=m; *nwss=sqrt(ss)/wsum; /* Set function return values */
  if(0) {
    fprintf(stdout, "c=%14.7e m=%14.7e ss=%14.7e niter=%d\n", c, m, ss, niter);
  }
 
  /* Return here, if variances are not to be calculated */
  if(!calcVar) return(0);
 
  /*
   *  Calculate the fitted line
   */
  for(i=0; i<n; i++) {
    if(w[i]>0.0) {
      f=w[i]*(c + m*x[i] - y[i]); /* Lagrangian multiplier */ 
      cx[i]=x[i]-f*m/wx[i]; cy[i]=y[i]+f/wy[i];
    } else {
      cx[i]=x[i]; cy[i]=y[i];
    }
  }
 
  /*
   *  Estimate the variances of the parameters (Reed 1992)
   */
  /* varm = var of slope ; varc = var of intercept  */
 
  /* Use the true nr of data points, i.e. exclude the ones with zero weight */
  for(i=nn=0; i<n; i++) if(w[i]>0.0) nn++;
  if(nn<3) {*sslope=*sic=0.0; return(0);}
 
  /* Compute the barycentre coordinates again from computed data points */
  for(i=0, xb=yb=wsum=0.0; i<n; i++) {xb+=w[i]*cx[i]; yb+=w[i]*cy[i]; wsum+=w[i];}
  if(wsum<=0.0) return(2);
  xb/=wsum; yb/=wsum;
  if(0) printf("barycentre: xb=%g yb=%g\n", xb, yb);
 
  /* common factors */
  HH=JJ=qa=qb=qc=0.0;
  for(i=0; i<n; i++) if(w[i]>0.0) {
    u=cx[i]-xb; v=cy[i]-yb; w2=w[i]*w[i];
    qa += w2*u*v/wx[i];
    qb += w2*(u*u/wy[i] - v*v/wx[i]);
    qc += -w2*u*v/wy[i];
    HH += w2*v/wx[i];
    JJ += w2*u/wx[i];
  }
  HH*=-2.0*m/wsum; JJ*=-2.0*m/wsum;
  if(0) printf("quadratic coefs: qa=%g qb=%g qc=%g ; HH=%g JJ=%g\n", qa, qb, qc, HH, JJ);
  AA=BB=CC=0.0;
  for(i=0; i<n; i++) if(w[i]>0.0) {
    u=cx[i]-xb; v=cy[i]-yb; w2=w[i]*w[i];
    AA += w[i]*w[i]*w[i]*u*v / (wx[i]*wx[i]);
    BB -= w2 * (4.0*m*(w[i]/wx[i])*(u*u/wy[i]-v*v/wx[i]) - 2.0*v*HH/wx[i] + 2.0*u*JJ/wy[i]);
    CC -= (w2/wy[i]) * (4.0*m*w[i]*u*v/wx[i] + v*JJ + u*HH);
  }
  if(m!=0) AA = 4.0*m*AA - wsum*HH*JJ/m; else AA=0.0;
  if(0) printf("AA=%g BB=%g CC=%g\n", AA, BB, CC);
  /* sigmas */
  varc=varm=0.0;
  for(j=0; j<n; j++) if(w[j]>0.0) {
    /* factors for this j */
    DD=EE=FF=GG=0.0;
    for(i=0; i<n; i++) if(w[i]>0.0) {
      u=cx[i]-xb; v=cy[i]-yb; w2=w[i]*w[i];
      if(i==j) delta=1.0; else delta=0.0; /* Kronecker delta */
      f = delta - w[j]/wsum;
      DD += (w2*v/wx[i])*f;
      EE += (w2*u/wy[i])*f;
      FF += (w2*v/wy[i])*f;
      GG += (w2*u/wx[i])*f;
    }
    EE*=2.0;
    /* derivatives at jth data point */
    f = (2.0*m*qa + qb - AA*m2 + BB*m - CC); m2=m*m;
    dmx = -(m2*DD + m*EE - FF) / f;
    dmy = -(m2*GG - 2.0*m*DD - EE/2.0) / f;
    dcx = (HH - m*JJ - xb)*dmx - m*w[j]/wsum;
    dcy = (HH - m*JJ - xb)*dmy + w[j]/wsum;
    /* sum terms for sigmas */
    varm += dmy*dmy/wy[j] + dmx*dmx/wx[j];
    varc += dcy*dcy/wy[j] + dcx*dcx/wx[j];
    if(0)
      printf("DD=%g EE=%g FF=%g GG=%g dmx=%g dmy=%g dcx=%g dcy=%g\n",
             DD, EE, FF, GG, dmx, dmy, dcx, dcy);
  }
  varm *= ss/(double)(nn-2);
  varc *= ss/(double)(nn-2);
  if(0) printf("varm=%g varc=%g\n", varm, varc);
  *sslope = sqrt(varm);
  *sic = sqrt(varc);
  if(0) {fprintf(stdout, "sslope=%14.7e sic=%14.7e\n", *sslope, *sic);}
  return(0);
}

Referenced by best_llsqwt(), and best_logan_reed().

◆ logan_data()

int logan_data	(	int	data_nr,
		double *	i,
		double *	ii,
		double *	c,
		double *	ci,
		double	k2,
		double *	x,
		double *	y )

extern

Calculates Logan plot x,y values from the measured input and ROI concentration TACs.

Plot will not include data where: 1) any of the values is not available (NaN), 2) integral is negative at this or later point, 3) divider is too close to zero.

See also: patlak_data, img_logan, llsqperp, mtga_best_perp

Returns: Returns the number of acceptable Logan plot data pairs, or <0 in case of an error. Note that zero or one return values prevent the line fitting, but are here not considered as errors.

Parameters

data_nr	Nr of samples.
i	Array of input concentrations.
ii	Array of integrals (from zero to sample time) of input concentrations; if reference region input, then remember to consider the frame length.
c	Array of ROI concentrations.
ci	Array of ROI integrals (from zero to frame middle time).
k2	Reference region k2; set to <=0 if not needed.
x	Pointer to preallocated memory (at least size dnr) where MTGA plot x values will be written.
y	Pointer to preallocated memory (at least size dnr) where MTGA plot y values will be written.

Definition at line 81 of file mtga.c.

  {
  int fi, plot_nr=0;
  double divider_limit=1.0E-18;
 
  if(data_nr<0 || i==NULL || ii==NULL || c==NULL || ci==NULL) return -1;
  if(x==NULL || y==NULL) return -1;
 
  for(fi=0; fi<data_nr; fi++) {
    // check that all measured data is available
    if(isnan(i[fi]) || isnan(ii[fi]) || isnan(c[fi]) || isnan(ci[fi])) continue;
    if(!(i[fi]>-1.0E+30 && i[fi]<+1.0E+30)) continue; 
    if(!(ii[fi]>-1.0E+30 && ii[fi]<+1.0E+30)) continue; 
    if(!(c[fi]>-1.0E+30 && c[fi]<+1.0E+30)) continue; 
    if(!(ci[fi]>-1.0E+30 && ci[fi]<+1.0E+30)) continue; 
    // check that integrals have been >=0 all the time
    if(ii[fi]<0.0) {plot_nr=0; continue;}
    if(ci[fi]<0.0) {plot_nr=0; continue;}
    // check that dividers are not too close to zero
    if(fabs(c[fi])<divider_limit) continue;
    // calculate plot x axis value
    if(k2>0.0) x[plot_nr]=(ii[fi]+i[fi]/k2)/c[fi];
    else x[plot_nr]=ii[fi]/c[fi];
    if(!(x[plot_nr]>-1.0E+30 && x[plot_nr]<+1.0E+30)) continue;
    // calculate plot y axis value
    y[plot_nr]=ci[fi]/c[fi];
    if(!(y[plot_nr]>-1.0E+30 && y[plot_nr]<+1.0E+30)) continue;
    // so this plot data point is fine
    plot_nr++;
  }
  return(plot_nr);
}

Referenced by img_logan().

◆ mean()

int mean	(	double *	x,
		double *	y,
		int	nr,
		double *	xmean,
		double *	xsd,
		double *	ymean,
		double *	ysd )

extern

Calculates the mean and SD of data. Data (y data) may contain NaN's.

See also: dmean, dmedian, dmean_nan, regr_line, pearson

Returns: Returns !=0 in case of an error.

Parameters

x	Data x values
y	Data y values
nr	Number of data sample values
xmean	Calculated x mean
xsd	Calculated SD of x mean
ymean	Calculated y mean
ysd	Calculated SD of y mean

Definition at line 341 of file pearson.c.

  {
  int   i, n;
  double sumsqr, sqrsum;
 
  for(i=0, sumsqr=sqrsum=0.0, n=0; i<nr; i++) if(!isnan(x[i]) && !isnan(y[i])) {
    sumsqr+=x[i]*x[i]; sqrsum+=x[i]; n++;}
  if(n<=0) return -1;
  *xmean=sqrsum/(double)n;
  if(n==1) *xsd=0.0; else {
    sqrsum*=sqrsum;
    *xsd=sqrt( (sumsqr - sqrsum/(double)n) / (double)(n-1) );
  }
  for(i=0, sumsqr=sqrsum=0.0, n=0; i<nr; i++) if(!isnan(x[i]) && !isnan(y[i])) {
    sumsqr+=y[i]*y[i]; sqrsum+=y[i]; n++;}
  if(n<=0) return -1;
  *ymean=sqrsum/(double)n;
  if(n==1) *ysd=0.0; else {
    sqrsum*=sqrsum;
    *ysd=sqrt( (sumsqr - sqrsum/(double)n) / (double)(n-1) );
  }
  return 0;
}

Referenced by dftMeanTAC(), doubleMatchRel(), imgsegmClusterExpand(), least_trimmed_square(), mertwiRandomExponential(), noiseSD4SimulationFromDFT(), and resMean().

◆ medianline()

int medianline	(	double *	x,
		double *	y,
		int	nr,
		double *	slope,
		double *	ic )

extern

Median-based distribution-free estimation of slope and intercept. This method has no need for weighting and is insensitive to outliers. Note that this is not LMS !

Reference (containing reference to the original idea):

Siegel AF. Robust regression using repeated medians. Biometrika 1982;69(1):242-244.

See also: llsqperp

Returns: If successful, function returns value 0.

Parameters

x	Coordinates of data points (dimension nr).
y	Coordinates of data points (dimension nr).
nr	Number of data points.
slope	Estimated slope.
ic	Estimated intercept.

Definition at line 533 of file llsqwt.c.

  {
  int i, j, snr;
  double *sp, *ip, d;
 
  if(0) fprintf(stdout, "medianline()\n");
  /* Check the data */
  if(nr<2 || x==NULL || y==NULL) return(1);
  /* Allocate memory for slopes and intercepts */
  for(i=0, snr=0; i<nr-1; i++) for(j=i+1; j<nr; j++) snr++;
  sp=(double*)malloc(snr*sizeof(double));
  ip=(double*)malloc(snr*sizeof(double));
  if(sp==NULL || ip==NULL) return(2);
  /* Calculate the slopes and intercepts */
  for(i=0, snr=0; i<nr-1; i++) for(j=i+1; j<nr; j++) {
    if(isnan(x[i]) || isnan(x[j]) || isnan(y[i]) || isnan(y[j])) continue;
    d=x[j]-x[i]; if(d==0) continue;
    sp[snr]=(y[j]-y[i])/d; ip[snr]=y[i]-sp[snr]*x[i];
    snr++;
  }
  if(snr<2) {free(sp); free(ip); return(3);}
  /* Get the medians of slope and intercept */
  qsort(sp, snr, sizeof(double), _medianline_cmp);
  qsort(ip, snr, sizeof(double), _medianline_cmp);
  if(snr%2==1) {*slope=sp[snr/2]; *ic=ip[snr/2];}
  else {*slope=0.5*(sp[snr/2]+sp[(snr/2)-1]); *ic=0.5*(ip[snr/2]+ip[(snr/2)-1]);}
  free(sp); free(ip);
  return(0);
}

◆ mertwiInit()

void mertwiInit ( MERTWI * mt )

extern

Prepare data struct Mersenne Twister MT19937 for usage. Do not call any mertwi* functions before calling this function!

Definition at line 23 of file mertwi.c.

  {
  mt->n=TPCCLIB_MERTWI_NN; // Length of mt array
  mt->m=mt->n/2; // N/2
  mt->a=TPCCLIB_MERTWI_A;
  mt->um=UINT64_C(0xFFFFFFFF80000000);
  mt->lm=UINT64_C(0x7FFFFFFF);
  mt->mti=mt->n+1; // means that mt[] is not initialized
}

◆ mertwiInitByArray64()

void mertwiInitByArray64	(	MERTWI *	mt,
		uint64_t	init_key[],
		uint64_t	key_length )

extern

Initialize the state vector mt[] inside data struct for Mersenne Twister MT19937 pseudorandom number generator using given array.

Call either this or mertwiInitWithSeed64 before generating random numbers with MT19937 using functions.

Precondition: Initialize MERTWI data struct by calling mertwiInit() before this.

See also: mertwiSeed64, mertwiInitWithSeed64, mertwiInit

Parameters

mt	Data struct for Mersenne Twister MT19937 pseudorandom number generator
init_key	The array for initializing keys
key_length	Length of initialization array init_key[]

Definition at line 111 of file mertwi.c.

  {
  unsigned int i, j;
  uint64_t k;
  mertwiInitWithSeed64(mt, UINT64_C(19650218));
  i=1; j=0; if(mt->n>key_length) k=mt->n; else k=key_length;
  for(; k; k--) {
    mt->mt[i] = 
      (mt->mt[i] ^ ((mt->mt[i-1] ^ (mt->mt[i-1]>>62)) * UINT64_C(3935559000370003845)))
      + init_key[j] + j;
    i++; j++;
    if(i>=mt->n) {mt->mt[0]=mt->mt[mt->n-1]; i=1;}
    if(j>=key_length) j=0;
  }
  for(k=mt->n-1; k; k--) {
    mt->mt[i]=
      (mt->mt[i] ^ ((mt->mt[i-1] ^ (mt->mt[i-1] >> 62)) * UINT64_C(2862933555777941757)))
       - i;
    i++;
    if(i>=mt->n) {mt->mt[0]=mt->mt[mt->n-1]; i=1;}
  }
  mt->mt[0] = UINT64_C(1) << 63; /* MSB is 1; assuring non-zero initial array */ 
}

◆ mertwiInitWithSeed64()

void mertwiInitWithSeed64	(	MERTWI *	mt,
		uint64_t	seed )

extern

Initialize the state vector mt[] inside data struct for Mersenne Twister MT19937 pseudorandom number generator using given seed.

Call either this or mertwiInitByArray64 before generating random numbers with MT19937 using functions.

Precondition: Initialize MERTWI data struct by calling mertwiInit() before this.

See also: mertwiSeed64, mertwiInitByArray64, mertwiInit

Parameters

mt	Data struct for Mersenne Twister MT19937 pseudorandom number generator
seed	Seed, for example from mertwiSeed64()

Definition at line 91 of file mertwi.c.

  {
  mt->mt[0]=seed;
  for(mt->mti=1; mt->mti<mt->n; mt->mti++) 
    mt->mt[mt->mti]=
      (UINT64_C(6364136223846793005)*(mt->mt[mt->mti-1] ^ (mt->mt[mt->mti-1]>>62)) + mt->mti);
}

Referenced by mertwiInitByArray64(), and mertwiRandomInt64().

◆ mertwiRandomDouble1()

double mertwiRandomDouble1 ( MERTWI * mt )

extern

Generate a 64-bit double precision floating point pseudorandom number in the range of [0,1] with uniform distribution using Mersenne Twister MT19937.

With uniform distribution, the SD=(up-low)/sqrt(12), and CV=(up-low)/(sqrt(3)*(low+up)).

Precondition: Initialize MERTWI data struct by calling mertwiInit() before using this function. Preferably also initialize state vector by calling either mertwiInitWithSeed64() or mertwiInitByArray64; if you do not do that, mertwiInitWithSeed64() is called automatically with predetermined seed.

See also: mertwiInit, mertwiInitWithSeed64, mertwiInitByArray64

Returns: Returns the random double value in the range [0,1].

Parameters

mt	Data struct for Mersenne Twister MT19937 pseudorandom number generator

Definition at line 218 of file mertwi.c.

  {
  return(mertwiRandomInt64(mt) >> 11) * (1.0/9007199254740991.0);
}

Referenced by mertwiRandomBetween(), mertwiRandomExponential(), and mertwiRandomGaussian().

◆ mertwiRandomDouble2()

double mertwiRandomDouble2 ( MERTWI * mt )

extern

Generate a 64-bit double precision floating point pseudorandom number in the range of [0,1) with uniform distribution using Mersenne Twister MT19937.

Precondition: Initialize MERTWI data struct by calling mertwiInit() before using this function. Preferably also initialize state vector by calling either mertwiInitWithSeed64() or mertwiInitByArray64; if you do not do that, mertwiInitWithSeed64() is called automatically with predetermined seed.

See also: mertwiInit, mertwiInitWithSeed64, mertwiInitByArray64

Returns: Returns the random double value in the range [0,1).

Parameters

mt	Data struct for Mersenne Twister MT19937 pseudorandom number generator

Definition at line 235 of file mertwi.c.

  {
  return(mertwiRandomInt64(mt) >> 11) * (1.0/9007199254740992.0);
}

◆ mertwiRandomDouble3()

double mertwiRandomDouble3 ( MERTWI * mt )

extern

Generate a 64-bit double precision floating point pseudorandom number in the range of (0,1) with uniform distribution using Mersenne Twister MT19937.

Precondition: Initialize MERTWI data struct by calling mertwiInit() before using this function. Preferably also initialize state vector by calling either mertwiInitWithSeed64() or mertwiInitByArray64; if you do not do that, mertwiInitWithSeed64() is called automatically with predetermined seed.

See also: mertwiInit, mertwiInitWithSeed64, mertwiInitByArray64

Returns: Returns the random double value in the range (0,1).

Parameters

mt	Data struct for Mersenne Twister MT19937 pseudorandom number generator

Definition at line 252 of file mertwi.c.

  {
  return((mertwiRandomInt64(mt) >> 12) + 0.5) * (1.0/4503599627370496.0);
}

◆ mertwiRandomInt63()

int64_t mertwiRandomInt63 ( MERTWI * mt )

extern

Generate a random number on [0, 2^63-1]-interval using Mersenne Twister MT19937.

Precondition: Initialize MERTWI data struct by calling mertwiInit() before using this function. Preferably also initialize state vector by calling either mertwiInitWithSeed64() or mertwiInitByArray64; if you do not do that, mertwiInitWithSeed64() is called automatically with predetermined seed.

See also: mertwiInit, mertwiInitWithSeed64, mertwiInitByArray64

Returns: Returns the random number with range from 0 to INT64_MAX.

Parameters

mt	Data struct for Mersenne Twister MT19937 pseudorandom number generator

Definition at line 197 of file mertwi.c.

  {
  return(int64_t)(mertwiRandomInt64(mt) >> 1);
}

◆ mertwiRandomInt64()

uint64_t mertwiRandomInt64 ( MERTWI * mt )

extern

Generate a random number on [0, 2^64-1]-interval using Mersenne Twister MT19937.

Precondition: Initialize MERTWI data struct by calling mertwiInit() before using this function. Preferably also initialize state vector by calling either mertwiInitWithSeed64() or mertwiInitByArray64; if you do not do that, mertwiInitWithSeed64() is called automatically with predetermined seed.

See also: mertwiInit, mertwiInitWithSeed64, mertwiInitByArray64

Returns: Returns the random number with range from 0 to UINT64_MAX.

Parameters

mt	Data struct for Mersenne Twister MT19937 pseudorandom number generator

Definition at line 152 of file mertwi.c.

  {
  unsigned int i;
  uint64_t x;
  static uint64_t mag01[2]={UINT64_C(0), TPCCLIB_MERTWI_A};
 
  if(mt->mti>=mt->n) { /* generate NN words at one time */
 
    /* if init_genrand64() has not been called, a default initial seed is used */
    if(mt->mti==mt->n+1) mertwiInitWithSeed64(mt, UINT64_C(5489)); 
 
    for(i=0; i<mt->n-mt->m; i++) {
      x=(mt->mt[i]&mt->um)|(mt->mt[i+1]&mt->lm);
      mt->mt[i] = mt->mt[i+mt->m] ^ (x>>1) ^ mag01[(int)(x&UINT64_C(1))];
    }
    for(; i<mt->n-1; i++) {
      x = (mt->mt[i]&mt->um)|(mt->mt[i+1]&mt->lm);
      mt->mt[i] = mt->mt[i+(mt->m-mt->n)] ^ (x>>1) ^ mag01[(int)(x&UINT64_C(1))];
    }
    x = (mt->mt[mt->n-1]&mt->um)|(mt->mt[0]&mt->lm);
    mt->mt[mt->n-1] = mt->mt[mt->m-1] ^ (x>>1) ^ mag01[(int)(x&UINT64_C(1))];
    mt->mti=0;
  }
  x = mt->mt[mt->mti];
 
  x ^= (x>>29) & UINT64_C(0x5555555555555555);
  x ^= (x<<17) & UINT64_C(0x71D67FFFEDA60000);
  x ^= (x<<37) & UINT64_C(0xFFF7EEE000000000);
  x ^= (x>>43);
  mt->mti++;
 
  return(x);
}

Referenced by mertwiRandomDouble1(), mertwiRandomDouble2(), mertwiRandomDouble3(), and mertwiRandomInt63().

◆ mertwiSeed32()

uint32_t mertwiSeed32 ( void )

extern

Make uint32_t seed for pseudorandom number generators.

Uses microseconds from the computer clock and process ID to reduce the chance of getting the same seed for simultaneously executing program threads and instances.

Returns: Returns the seed.

See also: mertwiSeed64

Definition at line 43 of file mertwi.c.

{
  uint32_t li;
#if defined HAVE_TIMESPEC_GET
  struct timespec ts;
  timespec_get(&ts, TIME_UTC);
  li=((ts.tv_sec % 10000)*523 ^ ts.tv_nsec*10) ^ ((getpid() % 1000)*983);
#elif defined HAVE_CLOCK_GETTIME
  struct timespec ts;
  clock_gettime(CLOCK_REALTIME, &ts);
  li=((ts.tv_sec % 10000)*523 ^ ts.tv_nsec*10) ^ ((getpid() % 1000)*983);
#elif defined HAVE_GETTIMEOFDAY
  struct timeval tv;
  gettimeofday(&tv, 0);
  li=((tv.tv_sec % 10000)*523 ^ tv.tv_usec*13) ^ ((getpid() % 1000)*983);
#else
  li=(unsigned int)time(NULL)+(unsigned int)getpid();
#endif
  li+=(uint32_t)rand();
  return(li);
}

Referenced by mertwiSeed64().

◆ mertwiSeed64()

uint64_t mertwiSeed64 ( void )

extern

Make uint64_t seed for pseudorandom number generators.

Uses microseconds from the computer clock and process ID to reduce the chance of getting the same seed for simultaneously executing program threads and instances.

Returns: Returns the seed.

See also: mertwiSeed32

Definition at line 72 of file mertwi.c.

{
  uint32_t li;
  uint64_t lli;
  lli=li=mertwiSeed32();
  lli=li; lli<<=32; lli+=li;
  return(lli);
}

◆ mEstim()

double mEstim	(	double *	data,
		int	nr,
		int	iterNr,
		double	cutoff )

extern

Fit a constant (horizontal straight line) to the data with M-estimator.

The algorithm was described in the lecture notes of Nonlinear signal processing course of Tampere university of technology www.cs.tut.fi/~eeroh/nonlin.html

Returns: Returns Hubers M-estimator for single dataset.

Parameters

data	Data array
nr	Number of data values
iterNr	Number of iterations
cutoff	cutoff point

Definition at line 18 of file mestim.c.

  {
  double theta, sum1, sum2, help;
 
  theta=dmedian(data, nr);
  for(int ii=0; ii<iterNr; ii++){
    sum1=sum2=0;
    for(int in=0; in<nr; in++){
      if(data[in]<0.9999*theta || data[in]>1.0001*theta){
        help=huber(data[in]-theta, cutoff);
        sum1=sum1+data[in]*help/(data[in]-theta);
        sum2=sum2+help/(data[in]-theta);
      } else {
        sum1=sum1+cutoff*data[in];
        sum2=sum2+cutoff; 
      }
    }
    theta=sum1/sum2;
  }
  return theta;
}

◆ mo2k1k2()

double mo2k1k2	(	const double	OER,
		const double	SaO2,
		const double	p50Hb,
		const double	p50Mb,
		const double	nHb,
		const double	cHb,
		const double	cMb,
		const int	verbose )

extern

Calculates K1/k2 ratio for [O-15]O2 in muscle, based on OER.

Returns: Returns K1/k2.

Parameters

OER	Oxygen extraction ratio; assumptions hold only in the range OER=0.2-0.9
SaO2	Arterial oxygen saturation fraction; you can enter DEFAULT_SAO2
p50Hb	Half-saturation pressure p50 (kPa) for hemoglobin; you can enter DEFAULT_P50HB
p50Mb	Half-saturation pressure p50 (kPa) p50 for myoglobin; you can enter DEFAULT_P50MB
nHb	Hill coefficient n for hemoglobin; you can enter DEFAULT_NHB
cHb	Hemoglobin concentration in blood (mg/g); you can enter DEFAULT_CHB
cMb	Myoglobin concentration in muscle (mg/g); you can enter DEFAULT_CMB
verbose	Verbose level; if zero, then nothing is printed into stdout or stderr

Definition at line 29 of file o2.c.

  {
  if(verbose>0) printf("mo2k1k2()\n");
  if(verbose>1) {
    printf("input:\n");
    printf("  OER := %g\n", OER);
    printf("  SaO2 := %g\n", SaO2);
    printf("  p50Hb := %g\n", p50Hb);
    printf("  p50Mb := %g\n", p50Mb);
    printf("  nHb := %g\n", nHb);
    printf("  cHb := %g\n", cHb);
    printf("  cMb := %g\n", cMb);
  }
  double SHb=(1.0-OER)*SaO2;
  if(verbose>2) printf("SHb := %g\n", SHb);
 
  double pO2=p50Hb*pow(SHb/(1.0-SHb), 1.0/nHb);
  if(verbose>2) printf("pO2 := %g\n", pO2);
 
  double SMb=pO2/(pO2+p50Mb);
  if(verbose>2) printf("SMb := %g\n", SMb);
 
  double rO2=cMb/cHb;
  if(verbose>2) printf("rO2 := %g\n", rO2);
 
  double k1k2=rO2*(SMb/SHb);
  if(verbose>1) printf("K1/k2 := %g\n", k1k2);
 
  return(k1k2);
}

◆ mo2pO2()

double mo2pO2	(	const double	OER,
		const double	K1k2,
		const double	SaO2,
		const double	p50Mb,
		const double	cHb,
		const double	cMb,
		const int	verbose )

extern

Calculates the partial pressure of oxygen in muscle, based on OER and K1/k2.

Returns: Returns pO2 (kPa).

Parameters

OER	Oxygen extraction ratio; assumptions hold only in the range OER=0.2-0.9
K1k2	K1/k2 ratio for [O-15]O2
SaO2	Arterial oxygen saturation fraction; you can enter DEFAULT_SAO2
p50Mb	Half-saturation pressure p50 (kPa) p50 for myoglobin; you can enter DEFAULT_P50MB
cHb	Hemoglobin concentration in blood (mg/g); you can enter DEFAULT_CHB
cMb	Myoglobin concentration in muscle (mg/g); you can enter DEFAULT_CMB
verbose	Verbose level; if zero, then nothing is printed into stdout or stderr

Definition at line 83 of file o2.c.

  {
  if(verbose>0) printf("mo2pO2()\n");
  if(verbose>1) {
    printf("input:\n");
    printf("  OER := %g\n", OER);
    printf("  K1/k2 := %g\n", K1k2);
    printf("  SaO2 := %g\n", SaO2);
    printf("  cHb := %g\n", cHb);
    printf("  cMb := %g\n", cMb);
    printf("  p50Mb := %g\n", p50Mb);
  }
  double SHb=(1.0-OER)*SaO2;
  if(verbose>2) printf("SHb := %g\n", SHb);
 
  double rO2=cMb/cHb;
  if(verbose>2) printf("rO2 := %g\n", rO2);
 
  double SMb=K1k2*(1.0-OER)*SaO2/rO2;
  if(verbose>2) printf("SMb := %g\n", SMb);
 
  double pO2=SMb*p50Mb/(1.0-SMb);
  if(verbose>1) printf("pO2 := %g\n", pO2);
 
  return(pO2);
}

◆ modelCheckLimits()

int modelCheckLimits	(	int	par_nr,
		double *	lower_p,
		double *	upper_p,
		double *	test_p )

extern

Check if model parameters have collided with given limits.

If parameter is fixed (equal lower and upper limit) then it is not counted as collision.

Returns: Return the number of parameters that too close to the limits; 0 in case all are well inside the limits.

Parameters

par_nr	Nr of parameters
lower_p	Lower limits
upper_p	Upper limits
test_p	Parameters to test

Definition at line 59 of file constraints.c.

  {
  int pi, collision_nr=0;
  double range, range_factor=0.00001;
  
  for(pi=0; pi<par_nr; pi++) {
    // fixed parameters are not checked
    range=upper_p[pi]-lower_p[pi]; if(range<=0.0) continue;
    // if parameter exceeds the limit, then that is a collision for sure
    if(test_p[pi]<=lower_p[pi]) {
      collision_nr++; continue;
    } else if(test_p[pi]>upper_p[pi]) {
      collision_nr++; continue;
    }
    // but in addition, accepted range is a bit smaller than constrained range
    // except if limit is 0, then it is ok that parameter is close to zero
    range*=range_factor;
    if(test_p[pi]<lower_p[pi]+range) {
      if(fabs(lower_p[pi])>=1.0E-06) collision_nr++;
    } else if(test_p[pi]>upper_p[pi]-range) {
      if(fabs(upper_p[pi])>=1.0E-06) collision_nr++;
    }
  }
  return collision_nr;
}

◆ modelCheckParameters()

int modelCheckParameters	(	int	par_nr,
		double *	lower_p,
		double *	upper_p,
		double *	test_p,
		double *	accept_p,
		double *	penalty )

extern

Check that model parameters are within given limits. If not, then compute a penalty factor.

Returns: Return the number of parameters that are inside or at the limits; 0 in case of error or if all are outside of the limits.

Parameters

par_nr	Nr of parameters
lower_p	Lower limits
upper_p	Upper limits
test_p	Parameters to test
accept_p	Pointer to corrected parameters (NULL if not needed)
penalty	Pointer to variable in which the possible penalty factor will be written; 1 if no penalty, or >1. Set to NULL if not needed.

Definition at line 15 of file constraints.c.

  {
  int pi, accept_nr=0;
  double range;
  
  if(penalty!=NULL) *penalty=1.0;
  for(pi=0; pi<par_nr; pi++) {
    range=upper_p[pi]-lower_p[pi]; if(range<=0.0) range=1.0;
    if(test_p[pi]<lower_p[pi]) {
      if(accept_p!=NULL) accept_p[pi]=lower_p[pi];
      if(penalty!=NULL) *penalty += (lower_p[pi]-test_p[pi])/range;
    } else if(test_p[pi]>upper_p[pi]) {
      if(accept_p!=NULL) accept_p[pi]=upper_p[pi];
      if(penalty!=NULL) *penalty += (test_p[pi]-upper_p[pi])/range;
    } else {
      if(accept_p!=NULL) accept_p[pi]=test_p[pi];
      accept_nr++;
    }
  }
  return accept_nr;
}

◆ mrl_between_tacs()

int mrl_between_tacs	(	double	y1[],
		double	y2[],
		int	n )

extern

Calculates the maximum run length between given two arrays of data.

Returns: Returns the MRL.

Definition at line 103 of file runs_test.c.

  {
  int mrl=0, rl=0;
  char last_sign=0, sign;
 
  if(y1==NULL || y2==NULL) return(0);
  for(int i=0; i<n; i++) {
    if(isnan(y1[i]) || isnan(y2[i])) continue;
    if(y1[i]>y2[i]) sign=1; else if(y1[i]<y2[i]) sign=-1; else sign=0;
    if(sign!=last_sign) {
      rl=0; last_sign=sign;
    } else {
      if(sign!=0) {rl++; if(rl>mrl) mrl=rl;}
    }
  }
  return(mrl);
}

◆ mtga_best_perp()

int mtga_best_perp	(	double *	x,
		double *	y,
		int	nr,
		double *	slope,
		double *	ic,
		double *	ssd,
		int *	fnr )

extern

Finds the best regression line to (x,y)-data, leaving points out from the beginning, because Gjedde-Patlak and Logan plots reach linearity at some later phase.

This function applies llsqperp() which is a non-iterative perpendicular line fitting routine.

See also: llsqperp(), logan_data, patlak_data

Returns: Returns 0, if successful, and <>0 in case of an error

Parameters

x	Plot x axis values.
y	Plot y axis values.
nr	Nr of plot data points.
slope	Slope is returned in here.
ic	Y axis intercept is returned in here.
ssd	Sum of squared distances / fnr, or NULL if not needed.
fnr	Number of points in the best fit, or NULL if not needed.

Definition at line 141 of file mtga.c.

  {
  int from, to, ret, from_min, to_min;
  double lic, lslope, lssd, ssd_min;
 
  /* Search the plot range that gives the lowest ssd */
  ssd_min=9.99E+99; from_min=to_min=-1;
  for(from=0, to=nr-1; ((to-from)+1)>=MTGA_BEST_MIN_NR; from++) {
    ret=llsqperp(x+from, y+from, (to-from)+1, &lslope, &lic, &lssd);
    if(ret==0 && lssd<ssd_min) {
      ssd_min=lssd; from_min=from; to_min=to;
      *slope=lslope; *ic=lic; if(ssd!=NULL) *ssd=lssd;
    }
  }
  if(from_min<0) {
    if(fnr!=NULL) *fnr=0;
    if(ssd!=NULL) *ssd=0.0;
    return(5);
  }
  if(fnr!=NULL) *fnr=(to_min-from_min)+1;
  return(0);
}

Referenced by img_logan(), and img_patlak().

◆ ndtr()

double ndtr ( double a )

extern

Calculates the area under the Gaussian probability density function integrated from minus infinity to given value a. For more information search for the Cephes C codes.

Returns: Returns the area under the Gaussian probability density function, integrated from minus infinity to a.

Parameters

a	variable a

Definition at line 17 of file normaldistr.c.

  {
  double x, y, z;
 
  x=a*M_SQRT1_2;
  z=fabs(x);
 
  if(z<1.0) {
    y=0.5+0.5*erf(x);
  } else {
    y=0.5*erfc(z);
    if(x>0) y=1.0-y;
  }
  return(y);
}

Referenced by normal_pvalue_1(), normal_pvalue_2(), and runs_test().

◆ nlopt1D()

int nlopt1D	(	double(*	_fun )(double, void *),
		void *	_fundata,
		double	x,
		double	xl,
		double	xu,
		double	delta,
		double	tol,
		const int	maxeval,
		double *	nx,
		double *	nf,
		int	verbose )

extern

Local one-dimensional minimization by bracketing.

Returns: 0 in case of no errors.

See also: simplex, tgo, bobyqa, powell, pearson

Parameters

_fun	Pointer to the function to be minimized. It must be defined in main program as: double func(double p, void *data); where p is the parameter, and data points to user-defined data structure needed by the function.
_fundata	Pointer to data that will be passed on to the _fun().
x	Parameter initial value.
xl	Parameter lower limit.
xu	Parameter upper limit.
delta	Initial parameter delta.
tol	Required tolerance.
maxeval	Maximum number of function evaluations.
nx	Pointer for optimized parameter value.
nf	Pointer for function value at optimum; NULL if not needed.
verbose	Verbose level

Definition at line 14 of file nlopt1d.c.

  {
  if(verbose>0) {
    printf("%s(f, fdata, %g, %g, %g, %g, %g, %d, ...)\n", __func__, x, xl, xu, delta, tol, maxeval); 
    fflush(stdout);
  }
 
 
  /* Check the input */
  if(_fun==NULL) return(1);
  if(xl>xu || x<xl || x>xu) return(1);
  if(!(delta>0.0) || !(tol>0.0)) return(1);
  if(tol>=delta) return(1);
  if(maxeval<5) return(1);
  if(nx==NULL) return(1);
 
  double begin=xl;
  double end=xu;
  int nevals=0;
 
  double p1=0, p2=0, p3=0, f1=0, f2=0, f3=0;
  /* Calculate function value with initial parameter value */
  double minf=f2=_fun(x, _fundata); nevals++;
  /* If parameter is fixed, then this was all that we can do */
  if(xl>=xu) {
    *nx=x; if(nf!=NULL) *nf=minf;
    return(0);
  }
 
  /* Find three bracketing points such that f1 > f2 < f3.
     Do this by generating a sequence of points expanding away from 0.
     Also note that, in the following code, it is always the
     case that p1 < p2 < p3. */
  p2=x;
 
  /* Start by setting a starting set of 3 points that are inside the bounds */
  p1=p2-delta; if(p1>begin) p1=begin;
  p3=p2+delta; if(p3<end) p3=end;
  /* Compute their function values */
  f1=_fun(p1, _fundata); nevals++;
  f3=_fun(p3, _fundata); nevals++;
  if(p2==p1 || p2==p3) {
    p2=0.5*(p1+p3);
    f2=minf=_fun(p2, _fundata); nevals++;
  }
 
  /* Now we have 3 points on the function. 
     Start looking for a bracketing set such that f1 > f2 < f3 is the case. */
  double jump_size=delta;
  while(!(f1>f2 && f2<f3)) {
    /* check for hitting max_iter */
    if(verbose>5) printf("  bracketing: nevals=%d\n", nevals);
    if(nevals >= maxeval) {
      *nx=p2; minf=f2; if(nf!=NULL) *nf=minf; 
      return(0);
    }
    /* check if required tolerance was reached */
    if((p3-p1)<tol) { //if (p3-p1 < eps)
      if(verbose>1) printf("  max tolerance was reached during bracketing\n");
      if(f1<f2 && f1<f3) {
        *nx=p1; minf=f1; if(nf!=NULL) *nf=minf;
        return(0);
      }
      if(f2<f1 && f2<f3) {
        *nx=p2; minf=f2; if(nf!=NULL) *nf=minf;
        return(0);
      }
      *nx=p3; minf=f3; if(nf!=NULL) *nf=minf;
      return(0);
    }
    if(verbose>6) printf("    jump_size=%g\n", jump_size);
    /* if f1 is small then take a step to the left */
    if(f1<f3) { 
      /* check if the minimum is colliding against the bounds. If so then pick
         a point between p1 and p2 in the hopes that shrinking the interval will
         be a good thing to do.  Or if p1 and p2 aren't differentiated then try
         and get them to obtain different values. */
      if(p1==begin || (f1==f2 && (end-begin)<jump_size )) {
        p3=p2; f3=f2; p2=0.5*(p1+p2);
        f2=minf=_fun(p2, _fundata); nevals++;
      } else {
        /* pick a new point to the left of our current bracket */
        p3=p2; f3=f2; p2=p1; f2=f1;
        p1-=jump_size; if(p1<begin) p1=begin;
        f1=_fun(p1, _fundata); nevals++;
        jump_size*=2.0;
      }
    } else { // otherwise f3 is small and we should take a step to the right
      /* check if the minimum is colliding against the bounds. If so then pick
         a point between p2 and p3 in the hopes that shrinking the interval will
         be a good thing to do.  Or if p2 and p3 aren't differentiated then
         try and get them to obtain different values. */
      if(p3==end || (f2==f3 && (end-begin)<jump_size)) {
        p1=p2; f1=f2; p2=0.5*(p3+p2);
        f2=minf=_fun(p2, _fundata); nevals++;
      } else {
        /* pick a new point to the right of our current bracket */
        p1=p2; f1=f2; p2=p3; f2=f3;
        p3+=jump_size; if(p3>end) p3=end;
        f3=minf=_fun(p3, _fundata); nevals++;
        jump_size*=2.0;
      }
    }
  }
  if(verbose>4) printf("  brackets ready\n");
 
  /* Loop until we have done the max allowable number of iterations or
     the bracketing window is smaller than eps.
     Within this loop we maintain the invariant that: f1 > f2 < f3 and 
     p1 < p2 < p3. */
  double d, d2;
  const double tau=0.1;
  double p_min, f_min;
  while((nevals<maxeval) && (p3-p1>tol)) {
    if(verbose>5) printf("  main loop: nevals=%d\n", nevals);
 
    //p_min = lagrange_poly_min_extrap(p1,p2,p3, f1,f2,f3);
    d=f1*(p3*p3-p2*p2) + f2*(p1*p1-p3*p3) + f3*(p2*p2-p1*p1);
    d2=2.0*(f1*(p3-p2) + f2*(p1-p3) + f3*(p2-p1));
    if(d2==0.0 || !isfinite(d/=d2)) { // d=d/d2
      p_min=p2;
    } else {
      if(p1<=d && d<=p3) {p_min=d;}
      else {p_min=d; if(p1>p_min) p_min=p1; if(p3<p_min) p_min=p3;}
    }
 
    /* make sure p_min isn't too close to the three points we already have */
    if(p_min<p2) {
      d=(p2-p1)*tau;
      if(fabs(p1-p_min)<d) p_min=p1+d;
      else if(fabs(p2-p_min)<d) p_min=p2-d;
    } else {
      d=(p3-p2)*tau;
      if(fabs(p2-p_min)<d) p_min=p2+d;
      else if(fabs(p3-p_min)<d) p_min=p3-d;
    }
 
    /* make sure one side of the bracket isn't super huge compared to the other
       side.  If it is then contract it. */
    double bracket_ratio=fabs(p1-p2)/fabs(p2-p3);
    if(!(bracket_ratio<100.0 && bracket_ratio>0.01)) {
      /* Force p_min to be on a reasonable side. */
      if(bracket_ratio>1.0 && p_min>p2) p_min=0.5*(p1+p2);
      else if(p_min<p2) p_min=0.5*(p2+p3);
    }
 
    /* Compute function value at p_min */
    *nx=p_min;
    f_min=minf=_fun(p_min, _fundata); nevals++;
 
    /* Remove one of the endpoints of our bracket depending on where the new point falls */
    if(p_min<p2) {
      if(f1>f_min && f_min<f2) {p3=p2; f3=f2; p2=p_min; f2=f_min;}
      else {p1=p_min; f1=f_min;}
    } else {
      if(f2>f_min && f_min<f3) {p1=p2; f1=f2; p2=p_min; f2=f_min;}
      else {p3=p_min; f3=f_min;}
    }
  }
  *nx=p2; minf=f2; if(nf!=NULL) *nf=minf;
  return(0);
}

◆ nnls()

int nnls	(	double **	a,
		int	m,
		int	n,
		double *	b,
		double *	x,
		double *	rnorm,
		double *	wp,
		double *	zzp,
		int *	indexp )

extern

Algorithm NNLS (Non-negative least-squares).

Given an m by n matrix A, and an m-vector B, computes an n-vector X, that solves the least squares problem A * X = B , subject to X>=0

Instead of pointers for working space, NULL can be given to let this function to allocate and free the required memory.

See also: qrLSQ, nnlsWghtSquared

Returns: Function returns 0 if successful, 1, if iteration count exceeded 3*N, or 2 in case of invalid problem dimensions or memory allocation error.

Parameters

a	On entry, a[ 0... N ][ 0 ... M ] contains the M by N matrix A. On exit, a[][] contains the product matrix Q*A, where Q is an m by n orthogonal matrix generated implicitly by this function.
m	Matrix dimension m
n	Matrix dimension n
b	On entry, b[] must contain the m-vector B. On exit, b[] contains Q*B
x	On exit, x[] will contain the solution vector
rnorm	On exit, rnorm contains the squared Euclidean norm of the residual vector, R^2. If NULL is given, no rnorm is calculated
wp	An n-array of working space, wp[]. On exit, wp[] will contain the dual solution vector. wp[i]=0.0 for all i in set p and wp[i]<=0.0 for all i in set z. Can be NULL, which causes this algorithm to allocate memory for it.
zzp	An m-array of working space, zz[]. Can be NULL, which causes this algorithm to allocate memory for it.
indexp	An n-array of working space, index[]. Can be NULL, which causes this algorithm to allocate memory for it.

Definition at line 38 of file nnls.c.

  {
  /* Check the parameters and data */
  if(m<=0 || n<=0 || a==NULL || b==NULL || x==NULL) return(2);
  /* Allocate memory for working space, if required */
  int *index=NULL, *indexl=NULL;
  double *w=NULL, *zz=NULL, *wl=NULL, *zzl=NULL;
  if(wp!=NULL) w=wp; else w=wl=(double*)calloc(n, sizeof(double));
  if(zzp!=NULL) zz=zzp; else zz=zzl=(double*)calloc(m, sizeof(double));
  if(indexp!=NULL) index=indexp; else index=indexl=(int*)calloc(n, sizeof(int));
  if(w==NULL || zz==NULL || index==NULL) return(2);
 
  /* Initialize the arrays INDEX[] and X[] */
  for(int ni=0; ni<n; ni++) {x[ni]=0.; index[ni]=ni;}
  int iz1=0;
  int iz2=n-1;
  int nsetp=0;
  int npp1=0;
 
  /* Main loop; quit if all coefficients are already in the solution or
     if M cols of A have been triangulated */
  double up=0.0;
  int itmax; if(n<3) itmax=n*3; else itmax=n*n;
  int iter=0; 
  int k, j=0, jj=0;
  while(iz1<=iz2 && nsetp<m) {
    /* Compute components of the dual (negative gradient) vector W[] */
    for(int iz=iz1; iz<=iz2; iz++) {
      int ni=index[iz];
      double sm=0.;
      for(int mi=npp1; mi<m; mi++) sm+=a[ni][mi]*b[mi];
      w[ni]=sm;
    }
 
    double wmax;
    int izmax=0;
    while(1) {
 
      /* Find largest positive W[j] */
      wmax=0.0;
      for(int iz=iz1; iz<=iz2; iz++) {
        int i=index[iz];
        if(w[i]>wmax) {wmax=w[i]; izmax=iz;}
      }
 
      /* Terminate if wmax<=0.; */
      /* it indicates satisfaction of the Kuhn-Tucker conditions */
      if(wmax<=0.0) break;
      j=index[izmax];
 
      /* The sign of W[j] is ok for j to be moved to set P.
         Begin the transformation and check new diagonal element to avoid
         near linear dependence. */
      double asave=a[j][npp1];
      up=0.0;
      _lss_h12(1, npp1, npp1+1, m, &a[j][0], 1, &up, NULL, 1, 1, 0);
      double unorm=0.0;
      if(nsetp!=0) for(int mi=0; mi<nsetp; mi++) unorm+=a[j][mi]*a[j][mi];
      unorm=sqrt(unorm);
      double d=unorm+fabs(a[j][npp1])*0.01;
      if((d-unorm)>0.0) {
        /* Col j is sufficiently independent. Copy B into ZZ, update ZZ
           and solve for ztest ( = proposed new value for X[j] ) */
        for(int mi=0; mi<m; mi++) zz[mi]=b[mi];
        _lss_h12(2, npp1, npp1+1, m, &a[j][0], 1, &up, zz, 1, 1, 1);
        double ztest=zz[npp1]/a[j][npp1];
        /* See if ztest is positive */
        if(ztest>0.) break;
      }
 
      /* Reject j as a candidate to be moved from set Z to set P. Restore
         A[npp1,j], set W[j]=0., and loop back to test dual coefficients again */
      a[j][npp1]=asave; w[j]=0.;
    } /* while(1) */
    if(wmax<=0.0) break;
 
    /* Index j=INDEX[izmax] has been selected to be moved from set Z to set P.
       Update B and indices, apply householder transformations to cols in
       new set Z, zero sub-diagonal elements in col j, set W[j]=0. */
    for(int mi=0; mi<m; mi++) b[mi]=zz[mi];
    index[izmax]=index[iz1]; index[iz1]=j; iz1++; nsetp=npp1+1; npp1++;
    if(iz1<=iz2)
      for(int jz=iz1; jz<=iz2; jz++) {
        jj=index[jz];
        _lss_h12(2, nsetp-1, npp1, m, &a[j][0], 1, &up, &a[jj][0], 1, m, 1);
      }
    if(nsetp!=m) for(int mi=npp1; mi<m; mi++) a[j][mi]=0.;
    w[j]=0.;
    
    /* Solve the triangular system; store the solution temporarily in Z[] */
    for(int mi=0; mi<nsetp; mi++) {
      int ip=nsetp-(mi+1);
      if(mi!=0) for(int ii=0; ii<=ip; ii++) zz[ii]-=a[jj][ii]*zz[ip+1];
      jj=index[ip]; zz[ip]/=a[jj][ip];
    }
 
    /* Secondary loop begins here */
    while(++iter<itmax) {
      /* See if all new constrained coefficients are feasible; if not, compute alpha */
      double alpha=2.0;
      for(int ip=0; ip<nsetp; ip++) {
        int ni=index[ip];
        if(zz[ip]<=0.) {
          double t=-x[ni]/(zz[ip]-x[ni]);
          if(alpha>t) {alpha=t; jj=ip-1;}
        }
      }
 
      /* If all new constrained coefficients are feasible then still alpha==2.
         If so, then exit from the secondary loop to main loop */
      if(alpha==2.0) break;
 
      /* Use alpha (0.<alpha<1.) to interpolate between old X and new ZZ */
      for(int ip=0; ip<nsetp; ip++) {
        int ni=index[ip]; x[ni]+=alpha*(zz[ip]-x[ni]);
      }
 
      /* Modify A and B and the INDEX arrays to move coefficient i from set P to set Z. */
      int pfeas=1;
      k=index[jj+1];
      do {
        x[k]=0.;
        if(jj!=(nsetp-1)) {
          jj++;
          for(int ni=jj+1; ni<nsetp; ni++) {
            int ii=index[ni]; index[ni-1]=ii;
            double ss, cc;
            _lss_g1(a[ii][ni-1], a[ii][ni], &cc, &ss, &a[ii][ni-1]);
            a[ii][ni]=0.0;
            for(int nj=0; nj<n; nj++) if(nj!=ii) {
              /* Apply procedure G2 (CC,SS,A(J-1,L),A(J,L)) */
              double temp=a[nj][ni-1];
              a[nj][ni-1]=cc*temp+ss*a[nj][ni];
              a[nj][ni]=-ss*temp+cc*a[nj][ni];
            }
            /* Apply procedure G2 (CC,SS,B(J-1),B(J)) */
            double temp=b[ni-1]; b[ni-1]=cc*temp+ss*b[ni]; b[ni]=-ss*temp+cc*b[ni];
          }
        }
        npp1=nsetp-1; nsetp--; iz1--; index[iz1]=k;
 
        /* See if the remaining coefficients in set P are feasible; they should be
           because of the way alpha was determined. If any are infeasible 
           it is due to round-off error. Any that are non-positive 
           will be set to zero and moved from set P to set Z. */
        for(jj=0, pfeas=1; jj<nsetp; jj++) {
          k=index[jj]; if(x[k]<=0.) {pfeas=0; break;}
        }
      } while(pfeas==0);
 
      /* Copy B[] into zz[], then solve again and loop back */
      for(int mi=0; mi<m; mi++) zz[mi]=b[mi];
      for(int mi=0; mi<nsetp; mi++) {
        int ip=nsetp-(mi+1);
        if(mi!=0) for(int ii=0; ii<=ip; ii++) zz[ii]-=a[jj][ii]*zz[ip+1];
        jj=index[ip]; zz[ip]/=a[jj][ip];
      }
    } /* end of secondary loop */
 
    if(iter>=itmax) break;
    for(int ip=0; ip<nsetp; ip++) {k=index[ip]; x[k]=zz[ip];}
  } /* end of main loop */
 
  /* Compute the norm of the final residual vector */
  if(rnorm != NULL) {
    double sm=0.0;
    if(npp1<m) for(int mi=npp1; mi<m; mi++) sm+=(b[mi]*b[mi]);
    else for(int ni=0; ni<n; ni++) w[ni]=0.;
    *rnorm=sm; //sqrt(sm);
  }
 
  /* Free working space, if it was allocated here */
  w=NULL; zz=NULL; index=NULL;
  if(wl!=NULL) free(wl); 
  if(zzl!=NULL) free(zzl); 
  if(indexl!=NULL) free(indexl);
  if(iter>=itmax) return(1);
 
  return(0);
} /* nnls */

Referenced by fitExpDecayNNLS(), and img_k1_using_ki().

◆ nnlsWght()

int nnlsWght	(	int	N,
		int	M,
		double **	A,
		double *	b,
		double *	weight )

extern

Algorithm for weighting the problem that is given to nnls-algorithm.

Square roots of weights are used because in nnls the difference w*A-w*b is squared.

Returns: Algorithm returns zero if successful, 1 if arguments are inappropriate.

See also: nnlsWghtSquared, nnls, qrLSQ, llsqWght

Parameters

N	NNLS dimension N (nr of parameters).
M	NNLS dimension M (nr of samples).
A	NNLS matrix A.
b	NNLS vector B.
weight	Weights for each sample (array of length M).

Definition at line 254 of file nnls.c.

  {
  int n, m;
  double *w;
 
  /* Check the arguments */
  if(N<1 || M<1 || A==NULL || b==NULL || weight==NULL) return(1);
 
  /* Allocate memory */
  w=(double*)malloc(M*sizeof(double)); if(w==NULL) return(2);
 
  /* Check that weights are not zero and get the square roots of them to w[] */
  for(m=0; m<M; m++) {
    if(weight[m]<=1.0e-20) w[m]=0.0;
    else w[m]=sqrt(weight[m]);
  }
 
  /* Multiply rows of matrix A and elements of vector b with weights*/
  for(m=0; m<M; m++) {
    for(n=0; n<N; n++) {
      A[n][m]*=w[m];
    }
    b[m]*=w[m];
  }
 
  free(w);
  return(0);
}

◆ nnlsWghtSquared()

int nnlsWghtSquared	(	int	N,
		int	M,
		double **	A,
		double *	b,
		double *	sweight )

extern

Algorithm for weighting the problem that is given to nnls-algorithm.

Square roots of weights are used because in nnls the difference w*A-w*b is squared. Here user must give squared weights; this makes calculation faster, when this function needs to be called many times.

Returns: Algorithm returns zero if successful, 1 if arguments are inappropriate.

See also: nnlsWghtSquared, qrLSQ, nnls

Parameters

N	NNLS dimension N (nr of parameters).
M	NNLS dimension M (nr of samples).
A	NNLS matrix A.
b	NNLS vector B.
sweight	Squared weights for each sample (array of length M).

Definition at line 303 of file nnls.c.

  {
  int n, m;
 
  /* Check the arguments */
  if(N<1 || M<1 || A==NULL || b==NULL || sweight==NULL) return(1);
 
  /* Multiply rows of matrix A and elements of vector b with weights*/
  for(m=0; m<M; m++) {
    for(n=0; n<N; n++) {
      A[n][m]*=sweight[m];
    }
    b[m]*=sweight[m];
  }
 
  return(0);
}

◆ normal_pvalue_1()

double normal_pvalue_1 ( double x )

extern

Calculates the one-sided p-value for x in relation to the standard normal distribution (that is, the probability that a random variable distributed as N(0, 1) is greater than x).

Returns: Returns 1 minus the value of the standard normal CDF evaluated at x.

Parameters

x	double-precision value x

Definition at line 60 of file normaldistr.c.

  {
  return 1.0-ndtr(x);
}

◆ normal_pvalue_2()

double normal_pvalue_2 ( double x )

extern

Calculates the two-sided p-value for x in relation to the standard normal distribution.

Returns: Returns 2 times (1 minus the value of the standard normal CDF evaluated at |x|).

Parameters

x	double-precision value x

Definition at line 43 of file normaldistr.c.

  {
  double p = (x<0.0)? ndtr(x) : ndtr(-x);
  return 2.0*p;
}

◆ parFreeNr()

int parFreeNr	(	const int	n,
		double *	pLower,
		double *	pUpper )

extern

Calculate the number of free parameters.

Model parameters can be fixed by setting lower and upper limit to equal values. This function simply checks the limits for each parameter.

Returns: Returns the number of free parameters.

See also: aicSS, dftWSampleNr

Parameters

n	Nr of parameters
pLower	Lower limits (array of length n)
pUpper	Upper limits (array of length n)

Definition at line 50 of file aic.c.

  {
  if(n<1 || pLower==NULL || pUpper==NULL) return(0);
  int nf=0;
  for(int i=0; i<n; i++) {
    double range=pUpper[i]-pLower[i];
    if(range>1.0E-10) nf++;
  }
  return(nf);
}

◆ patlak_data()

int patlak_data	(	int	data_nr,
		double *	i,
		double *	ii,
		double *	c,
		double *	x,
		double *	y )

extern

Calculates Gjedde-Patlak plot x,y values from the measured input and ROI concentration TACs.

Plot will not include data where: 1) any of the values is not available (NaN), 2) integral is negative at this or later point, 3) divider is too close to zero, 4) plot x value is negative.

See also: logan_data, img_patlak, llsqperp, mtga_best_perp

Returns: Returns the number of acceptable Gjedde-Patlak plot data pairs, or <0 in case of an error. Note that zero or one return values prevent the line fitting, but are here not considered as errors.

Parameters

data_nr	Nr of samples.
i	Array of input concentrations.
ii	Array of integrals (from zero to sample time) of input concentrations; if reference region input, then remember to consider the frame length.
c	Array of ROI concentrations.
x	Pointer to preallocated memory (at least size dnr) where MTGA plot x values will be written.
y	Pointer to preallocated memory (at least size dnr) where MTGA plot y values will be written.

Definition at line 22 of file mtga.c.

  {
  int fi, plot_nr=0;
  double divider_limit=1.0E-12;
 
  if(data_nr<0 || i==NULL || ii==NULL || c==NULL || x==NULL || y==NULL)
    return -1;
  for(fi=0; fi<data_nr; fi++) {
    // check that all measured data is available
    if(isnan(i[fi]) || isnan(ii[fi]) || isnan(c[fi])) continue;
    if(!(i[fi]>-1.0E+20 && i[fi]<+1.0E+20)) continue; 
    if(!(ii[fi]>-1.0E+20 && ii[fi]<+1.0E+20)) continue; 
    if(!(c[fi]>-1.0E+20 && c[fi]<+1.0E+20)) continue; 
    // check that integral has been >=0 all the time
    if(ii[fi]<0.0) {plot_nr=0; continue;}
    // check that dividers are not too close to zero
    if(fabs(i[fi])<divider_limit) continue;
    // calculate plot x axis value
    x[plot_nr]=ii[fi]/i[fi];
    if(!(x[plot_nr]>-1.0E+20 && x[plot_nr]<+1.0E+20)) continue;
    if(x[plot_nr]<0.0) continue;
    // calculate plot y axis value
    y[plot_nr]=c[fi]/i[fi];
    if(!(y[plot_nr]>-1.0E+20 && y[plot_nr]<+1.0E+20)) continue;
    // so this plot data point is fine
    plot_nr++;
  }
  return(plot_nr);
}

Referenced by img_patlak().

◆ pearson()

int pearson	(	double *	x,
		double *	y,
		int	nr,
		double *	k,
		double *	kSD,
		double *	b,
		double *	bSD,
		double *	r,
		double *	ySD )

extern

Calculate slope and intercept of a line and Pearson's correlation coefficient.

See also: regr_line, best_pearson, highest_slope, pearson2, pearson3, pearson4, mean, imgsegmPearson, nlopt1D

Returns: If successful, function returns value 0.

Parameters

x	data x values
y	data y values
nr	number of data sample values
k	slope
kSD	S.D. of slope
b	y axis intercept
bSD	S.D. of y axis intercept
r	Pearson's correlation coefficient, r
ySD	Residual variance of y values

Definition at line 14 of file pearson.c.

  {
  int i;
  double e, f, g, meanx, meany, kk, bb, ke, be, rr, sumsdcy=0.0;
  double sumx=0.0, sumy=0.0, sumsx=0.0, sumsdx=0.0, sumsdy=0.0, sumdxdy=0.0;
  double sumxy=0.0, sumsy=0.0;
 
 
  if(0) {
    fprintf(stdout, "pearson(x[], y[], %d, *k, *kSD, *b, *bSD, *r, *ySD)\n", nr);
    fflush(stdout);
  }
  /* Check that there is some data */
  if(x==NULL || y==NULL || nr<2) return(1);
 
  /* If only 2 datapoints */
  if(nr==2) {
    f=x[1]-x[0]; if(fabs(f)<1.0E-50) return(1);
    *k=(y[1]-y[0])/f; *b=y[0]-(*k)*x[0];
    *kSD=*bSD=*ySD=0.; *r=1.;
    return(0);
  }
 
  /* Calculate (x,y) sums and means */
  for(i=0; i<nr; i++) {
    sumx+=x[i]; sumy+=y[i];
    sumsx+=x[i]*x[i]; sumsy+=y[i]*y[i];
    sumxy+=x[i]*y[i];
  }
  meanx=sumx/(double)nr;
  meany=sumy/(double)nr;
  /* and then based on means */
  for(i=0; i<nr; i++) {
    f=x[i]-meanx; sumsdx+=f*f;
    g=y[i]-meany; sumsdy+=g*g;
    sumdxdy+=f*g;
  }
  if(sumsdx<1.0e-50 || sumsdy<1.0e-50) return(3);
  /* Regression coefficient */
  kk=sumdxdy/sumsdx; *k=kk;
  /* Intercept with y axis */
  bb=(sumsdx*sumy - sumx*sumdxdy)/((double)nr*sumsdx); *b=bb;
  /* Errors */
  for(i=0; i<nr; i++) {
    f=kk*x[i]+bb-y[i];
    sumsdcy+=f*f;
  }
  /* Deviation of y values */
  if(sumsdcy<=1.0e-12) e=0.0; else e=sqrt(sumsdcy/(double)(nr-2)); *ySD=e;
  /* SD of slope and intercept */
  ke=e/sqrt(sumsdx); be=e/sqrt((double)nr-sumx*sumx/sumsx);
  *kSD=ke; *bSD=be;
  be=sqrt(sumsdcy/(double)(nr-2))/sqrt((double)nr-(sumx*sumx)/sumsx);
  /* Pearson's correlation coefficient */
  rr=(sumxy-((sumx*sumy)/(double)nr)) /
     sqrt((sumsx-sumx*sumx/(double)nr)*(sumsy-sumy*sumy/(double)nr));
  /* Correct for small sample size */
  if(nr>4) rr*=1.0+(1.0-rr*rr)/(double)(2*(nr-4));
  *r=rr;
  if(0) {
    fprintf(stdout, "k=%14.7e +- %14.7e\n", kk, ke);
    fprintf(stdout, "b=%14.7e +- %14.7e\n", bb, be);
    fprintf(stdout, "r=%14.7e ySD=%14.7e\n", rr, e);
    fflush(stdout);
  }
 
  return(0);
}

Referenced by best_logan_regr(), best_pearson(), dft_end_line(), extrapolate_monoexp(), pearson2(), pearson3(), and pearson4().

◆ pearson2()

int pearson2	(	double *	x,
		double *	y,
		char *	is,
		int	nr,
		double *	k,
		double *	kSD,
		double *	b,
		double *	bSD,
		double *	r,
		double *	ySD )

extern

Calculate slope and intercept of a line and Pearson's correlation coefficient.

Array char is[] specifies whether single (x,y) points are used in the fit.

See also: regr_line, best_pearson, pearson, highest_slope

Returns: If successful, function returns value 0.

Parameters

x	data x values
y	data y values
is	Switch values: 0=do not use this point
nr	number of data sample values
k	slope
kSD	S.D. of slope
b	y axis intercept
bSD	S.D. of y axis intercept
r	Pearson's correlation coefficient, r
ySD	Residual variance of y values

Definition at line 109 of file pearson.c.

  {
  int i, j;
  double *nx, *ny;
 
  /* Allocate memory for new data pointers  */
  nx=(double*)calloc(nr, sizeof(double)); if(nx==NULL) return 1;
  ny=(double*)calloc(nr, sizeof(double)); if(ny==NULL) {free((char*)nx); return 1;}
 
  /* Copy data to pointers */
  for(i=0, j=0; i<nr; i++) if(is[i]) {nx[j]=x[i]; ny[j]=y[i]; j++;}
 
  /* Use pearson() */
  i=pearson(nx, ny, j, k, kSD, b, bSD, r, ySD); free((char*)nx); free((char*)ny);
  return (i);
}

◆ pearson3()

int pearson3	(	double *	x,
		double *	y,
		int	nr,
		double *	k,
		double *	kSD,
		double *	b,
		double *	bSD,
		double *	r,
		double *	ySD )

extern

Calculate slope and intercept of a line and Pearson's correlation coefficient.

Data points may contain NaN's.

See also: regr_line, pearson, best_pearson, highest_slope

Returns: If successful, function returns value 0.

Parameters

x	data x values
y	data y values
nr	number of data sample values
k	slope
kSD	S.D. of slope
b	y axis intercept
bSD	S.D. of y axis intercept
r	Pearson's correlation coefficient, r
ySD	Residual variance of y values

Definition at line 154 of file pearson.c.

  {
  int i, j;
  double *nx, *ny;
 
  /* Allocate memory for new data pointers  */
  nx=(double*)calloc(nr, sizeof(double)); if(nx==NULL) return 1;
  ny=(double*)calloc(nr, sizeof(double)); if(ny==NULL) {free((char*)nx); return 1;}
 
  /* Copy data to pointers  */
  for(i=0, j=0; i<nr; i++)
    if(!isnan(x[i]) && !isnan(y[i])) {nx[j]=x[i]; ny[j]=y[i]; j++;}
 
  /* Use pearson()  */
  i=pearson(nx, ny, j, k, kSD, b, bSD, r, ySD); free((char*)nx); free((char*)ny);
  return (i);
}

◆ pearson4()

int pearson4	(	double *	x,
		double *	y,
		int	nr,
		double	start,
		double	end,
		double *	k,
		double *	kSD,
		double *	b,
		double *	bSD,
		double *	r,
		double *	ySD )

extern

Calculate slope and intercept of a line and Pearson's correlation coefficient.

Data points may contain NaN's. Fit start and end times are specified.

See also: regr_line, best_pearson, highest_slope

Returns: If successful, function returns value 0.

Parameters

x	data x values
y	data y values
nr	number of data sample values
start	fit start time
end	fit end time
k	slope
kSD	S.D. of slope
b	y axis intercept
bSD	S.D. of y axis intercept
r	Pearson's correlation coefficient, r
ySD	Residual variance of y values

Definition at line 198 of file pearson.c.

  {
  int i, j;
  double *nx, *ny;
 
  if(0) {
    fprintf(stdout, "pearson4(x[], y[], %d, %g, %g, *k, *kSD, *b, *bSD, *r, *ySD)\n", nr,start,end);
    fflush(stdout);
  }
  /* Allocate memory for new data pointers */
  if((nx=(double*)calloc(nr, sizeof(double)))==NULL) return -3;
  if((ny=(double*)calloc(nr, sizeof(double)))==NULL) {free((char*)nx); return -3;}
 
  /* Copy data to pointers */
  for(i=0, j=0; i<nr; i++)
    if(x[i]>=start && x[i]<=end && !isnan(x[i]) && !isnan(y[i])) {
      nx[j]=x[i]; ny[j]=y[i]; j++;}
 
  /* Use pearson() */
  i=pearson(nx, ny, j, k, kSD, b, bSD, r, ySD);
  free((char*)nx); free((char*)ny);
  return i;
}

◆ petintegral()

int petintegral	(	double *	x1,
		double *	x2,
		double *	y,
		int	nr,
		double *	ie,
		double *	iie )

extern

Integrate PET TAC data to frame mid times.

Any of output arrays may be set to NULL if that is not needed. Frames must be in ascending time order. Gaps and small overlap are allowed. If x1[0]>0 and x1[0]<=x2[0]-x1[0], then an imaginary line is drawn from (0,0) to (x[0],y[0]).

Returns: Returns 0 if ok.

See also: fpetintegral, interpolate4pet, petintegrate

Parameters

x1	frame start times
x2	frame end times
y	avg value during frame
nr	number of frames
ie	integrals at frame mid time
iie	2nd integrals at frame mid time

Definition at line 771 of file integr.c.

  {
  int i;
  double x, last_x, last_x2, last_y, last_integral, box_integral, half_integral;
  double gap_integral, integral, integral2, frame_len, xdist, s;
 
  /* Check for data */
  if(nr<1 || nr<1) return(1);
  /* Check that programmer understood that output must've been allocated */
  if(ie==NULL && iie==NULL) return(2);
 
  /* Initiate values to zero */
  last_x=last_x2=last_y=last_integral=0.0;
  box_integral=integral=integral2=frame_len=0.0;
 
  for(i=0; i<nr; i++) {
    frame_len=x2[i]-x1[i]; if(frame_len<0.0) return(5);
    x=0.5*(x1[i]+x2[i]); xdist=x-last_x; 
    if(last_x>0.0 && xdist<=0.0) return(6);
    if(x<0) {
      if(ie!=NULL) ie[i]=integral;
      if(iie!=NULL) iie[i]=integral2;
      continue;
    }
    s=(y[i]-last_y)/xdist; /* slope */
    /*If there is a big gap in the beginning it is eliminated */
    if(i==0)if(x1[0]>x2[0]-x1[0]){last_x2=last_x=x1[0];}
    /*Integral of a possible gap between frames*/
    gap_integral=(x1[i]-last_x2)*(last_y+s*((last_x2+x1[i])/2.0-last_x)); 
    /*Integral from the beginning of the frame to the middle of the frame */
    half_integral=(x-x1[i])*(last_y+s*((x1[i]+x)/2.0-last_x));
    integral=box_integral+gap_integral+half_integral; 
    /* half_integral is not added to box because it is more accurate to 
       increment integrals of full frames */
    box_integral+=gap_integral+frame_len*y[i];
    integral2+=xdist*(integral+last_integral)*0.5;
    if(ie!=NULL) ie[i]=integral;
    if(iie!=NULL) iie[i]=integral2;
    last_x=x; last_x2=x2[i];
    last_y=y[i]; last_integral=integral;
  }
 
  return(0);
}

Referenced by dftInterpolate(), dftInterpolateForIMG(), dftInterpolateInto(), dftReadinput(), img_k1_using_ki(), img_logan(), and img_patlak().

◆ petintegrate()

int petintegrate	(	double *	x1,
		double *	x2,
		double *	y,
		int	nr,
		double *	newyi,
		double *	newyii )

extern

Calculates integrals of PET data at frame end times.

Data does not have to be continuous, but it must be increasing in time. For faster performance in repetitive calls, allocate memory for integral[] even if it is not needed. If x1[0] is >0 AND x1[0] is <=(x2[0]-x1[0]), then the beginning is interpolated from (0, 0) to (x1[0], y1[0]*x1[0]/x) where x is midtime of the first frame.

Returns: Returns 0 if ok.

See also: integrate, fpetintegrate, petintegral, interpolate

Parameters

x1	Array of frame start times
x2	Array of frame end times
y	Array of y values (avg during each frame)
nr	Nr of frames
newyi	Output: integral values at frame end times, or NULL
newyii	Output: 2nd integral values at frame end times, or NULL

Definition at line 334 of file integr.c.

  {
  int i, allocated=0;
  double *ti, x, a;
 
 
  /* Check that data is increasing in time and is not (much) overlapping */
  if(nr<1 || x1[0]<0) return 1;
  for(i=0; i<nr; i++) if(x2[i]<x1[i]) return 2;
  for(i=1; i<nr; i++) if(x1[i]<=x1[i-1]) return 3;
 
  /* Allocate memory for temp data, if necessary */
  if(newyi==NULL) {
    allocated=1;
    ti=(double*)malloc(nr*sizeof(double)); if(ti==NULL) return 4;
  } else
    ti=newyi;
 
  /* Calculate the integral at the end of first frame */
  ti[0]=(x2[0]-x1[0])*y[0];
  /* If frame does not start at 0 time, add the area in the beginning */
  /* But only if the gap in the beginning is less than the lenght of the 
     first frame */
  if(x1[0]>0) {
    if(x1[0]<=x2[0]-x1[0]) {
       x=(x1[0]+x2[0])/2.0; 
       a=(x1[0]*(y[0]/x)*x1[0])/2.0; 
       ti[0]+=a;
    }
  }
 
  /* Calculate integrals at the ends of following frames */
  for(i=1; i<nr; i++) {
    /* Add the area of this frame to the previous integral */
    a=(x2[i]-x1[i])*y[i]; ti[i]=ti[i-1]+a;
    /* Check whether frames are contiguous */
    if(x1[i]==x2[i-1]) continue;
    /* When not, calculate the area of an imaginary frame */
    x=(x1[i]+x2[i-1])/2.0;
    a=(x1[i]-x2[i-1])*
      (y[i]-(y[i]-y[i-1])*(x2[i]+x1[i]-2.0*x)/(x2[i]+x1[i]-x2[i-1]-x1[i-1]));
    ti[i]+=a;
  }
 
  /* Copy integrals to output if required */
  if(allocated) for(i=0; i<nr; i++) newyi[i]=ti[i];
 
  /* Calculate 2nd integrals if required */
  if(newyii!=NULL) {
    newyii[0]=x2[0]*ti[0]/2.0;
    for(i=1; i<nr; i++)
      newyii[i]=newyii[i-1]+(x2[i]-x2[i-1])*(ti[i-1]+ti[i])/2.0;
  }
  
  /* Free memory */
  if(allocated) free((char*)ti);
 
  return 0;
}

Referenced by dftReadReference().

◆ petintegrate2fe()

int petintegrate2fe	(	double *	x1,
		double *	x2,
		double *	y,
		int	nr,
		double *	e,
		double *	ie,
		double *	iie )

extern

Integrate PET TAC data to frame end times.

Any of output arrays may be set to NULL if that is not needed. Frames must be in ascending time order. Gaps and small overlap are allowed. If x1[0]>0 and x1[0]<=x2[0]-x1[0], then an imaginary line is drawn from (0,0) to (x[0],y[0]).

Returns: Returns 0 if ok.

See also: fpetintegrate2fe

Parameters

x1	frame start times
x2	frame end times
y	avg value during frame
nr	number of frames
e	values at frame end time
ie	integrals at frame end time
iie	2nd integrals at frame end time

Definition at line 905 of file integr.c.

  {
  int i;
  double x, last_x, last_x2, last_y, last_integral;
  double value, integral, integral2, frame_len, xdist, s;
 
  /* Check for data */
  if(nr<1 || nr<1) return(1);
  /* Check that programmer understood that output must've been allocated */
  if(e==NULL && ie==NULL && iie==NULL) return(2);
 
  /* Initiate values to zero */
  last_x=last_x2=last_y=last_integral=value=integral=integral2=frame_len=s=0.0;
 
  for(i=0; i<nr; i++) {
    frame_len=x2[i]-x1[i]; if(frame_len<0.0) return(5);
    x=0.5*(x1[i]+x2[i]); xdist=x-last_x; if(last_x>0.0 && xdist<=0.0) return(6);
    if(x<0) {
      if(e!=NULL) e[i]=value;
      if(ie!=NULL) ie[i]=integral;
      if(iie!=NULL) iie[i]=integral2;
      continue;
    }
    s=(y[i]-last_y)/xdist; /* slope between x[i-1] and x[i] */
    /* If there is a big gap in the beginning, it is eliminated */
    if(i==0 && x1[0]>x2[0]-x1[0]) {last_x2=last_x=x1[0];}
    integral+=(x1[i]-last_x2)*(last_y+s*((last_x2+x1[i])/2.0-last_x)); /*gap*/
    integral+=frame_len*y[i];
    integral2+=(x2[i]-last_x2)*(integral+last_integral)*0.5;
    if(e!=NULL && i>0) {
      value=last_y+s*(last_x2-last_x); /* value at previous frame end */
      e[i-1]=value;
    }
    if(ie!=NULL) ie[i]=integral;
    if(iie!=NULL) iie[i]=integral2;
    last_x=x; last_x2=x2[i]; last_y=y[i]; last_integral=integral;
  }
  if(e!=NULL) {
    value=last_y+s*(last_x2-last_x); /* Value for the last frame */
    e[i-1]=value;
  }
 
  return(0);
}

◆ powell()

int powell	(	double *	p,
		double *	delta,
		int	parNr,
		double	ftol,
		int *	iterNr,
		double *	fret,
		double(*	_fun )(int, double , void ),
		void *	fundata,
		int	verbose )

extern

Powell function minimization routine.

Returns: Returns 0, if successful, 1 if required tolerance was not reached, 2 if initial guess does not give finite function value, 3 if final function value is NaN or infinite, and >3 in case of another error.

See also: simplex, tgo, bobyqa, nlopt1D

Parameters

p	Initial guess and final set of parameters
delta	Initial changes for parameters, ==0 if fixed
parNr	Nr of parameters
ftol	Fractional tolerance (for WSS); 0<ftol<1
iterNr	Max nr of iterations, and nr of required iters
fret	Function return value (WSS) at minimum
_fun	Function to minimize (must return the WSS)
fundata	Pointer to data which is passed on to the function; NULL if not needed
verbose	Verbose level; if zero, then nothing is printed into stdout or stderr

Definition at line 43 of file powell.c.

  {
  int pbIterNr;
  int i, j, ibig, iterMax, fixed[MAX_PARAMETERS];
  double xi[MAX_PARAMETERS][MAX_PARAMETERS]; /* Matrix for directions */
  double pt[MAX_PARAMETERS], ptt[MAX_PARAMETERS], xit[MAX_PARAMETERS];
  double del, fp, fptt, t;
  double origp[MAX_PARAMETERS];
  int ftol_reached=0;
 
 
  if(verbose>0) printf("in powell(,,%d,%g,%d,,)\n", parNr, ftol, *iterNr);
  if(verbose>1) {
    printf("Initial parameter guesses and deltas:\n");
    for(i=0; i<parNr; i++) printf("  %g  %g\n", p[i], delta[i]);
  }
  *fret=nan("");
  if(p==NULL) return(11);
  if(delta==NULL) return(12);
  if(parNr<1) return(21);
  if(ftol<=0.0) return(22);
  if(ftol>=1.0) return(23);
  if((*iterNr)<1) return(24);
 
  /* SetUp */
  _powellFunc=_fun;
  _powellFuncData=fundata;
  iterMax=*iterNr; /* save the max nr of iterations */
  _powell_ncom=parNr;
  /* Function value at initial point */
  _powell_func_calls=1;
  *fret=(*_powellFunc)(parNr, p, _powellFuncData);
  if(verbose>10) printf("initial point fret=%g\n", *fret);
  if(!isfinite(*fret)) {
    if(verbose>0) printf("in powell(): objf failed at initial point.\n");
    *fret=nan(""); return(2);
  }
  /* Save the initial point (pt[] will be changed later) */
  for(j=0; j<parNr; j++) origp[j]=pt[j]=p[j];
  /* Check which parameters are fixed */
  for(i=0; i<parNr; i++) if(fabs(delta[i])<1.0e-20) fixed[i]=1; else fixed[i]=0;
 
  /* Initiate matrix for directions */
  for(i=0; i<parNr; i++)
    for(j=0; j<parNr; j++)
      if(i==j) xi[i][j]=delta[i]; else xi[i][j]=0.0;
 
  /* Iterate */
  for(*iterNr=1; ; (*iterNr)++) {
    if(verbose>2) printf("  iteration %d\n", *iterNr);
    fp=*fret; ibig=0; del=0.0; /* largest function decrease */
 
    /* In each iteration, loop over all directions in the set */
    for(i=0; i<parNr; i++) {
      if(fixed[i]) continue; /* do nothing with fixed parameters */
      for(j=0; j<parNr; j++) if(fixed[j]) xit[j]=0.0; else xit[j]=xi[j][i];
      fptt=*fret;
      /* minimize along direction xit */
      pbIterNr=POWELL_LINMIN_MAXIT;
      _powell_linmin(p, xit, parNr, fret, &pbIterNr);
      if(verbose>3) printf("iterNr in _powell_linmin() with p%d: %d\n",
                           i, pbIterNr);
      if(fabs(fptt-(*fret))>del) {del=fabs(fptt-(*fret)); ibig=i;}
    }
    if(verbose>20) printf("fret=%g  fp=%g\n", *fret, fp);
 
    /* Check if done */
#if(0)
    if(2.0*fabs(fp-(*fret)) <= ftol*(fabs(fp)+fabs(*fret))) break;
#else
    if(2.0*fabs(fp-(*fret)) <= ftol*(fabs(fp)+fabs(*fret))) {
      if(ftol_reached>0 || (*iterNr)>=iterMax) break; else ftol_reached++;
    } else ftol_reached=0;
#endif
    if((*iterNr)>=iterMax) {
      if(verbose>0) printf("max iterations nr exceeded in powell().\n");
      break;
    }
    /* Construct the extrapolated point and the average direction moved */
    for(j=0; j<parNr; j++) {
      ptt[j]=2.0*p[j]-pt[j]; xit[j]=p[j]-pt[j];
      pt[j]=p[j]; /* save the old starting point */
    }
    fptt=(*_powellFunc)(parNr, ptt, _powellFuncData); _powell_func_calls++;
    if(fptt<fp) {
      t=2.0*(fp-2.0*(*fret)+fptt)*_powell_sqr(fp-(*fret)-del)-del*_powell_sqr(fp-fptt);
      if(t<0.0) {
        pbIterNr=POWELL_LINMIN_MAXIT;
        _powell_linmin(p, xit, parNr, fret, &pbIterNr);
        if(verbose>3) printf("iterNr in _powell_linmin(): %d\n", pbIterNr);
        for(j=0; j<parNr; j++) {
          xi[j][ibig]=xi[j][parNr-1]; xi[j][parNr-1]=xit[j];}
      }
    }
  } /* next iteration */
  if(verbose>1) {
    printf("iterNr := %d\n", *iterNr);
    printf("nr of function calls := %d\n", _powell_func_calls);
  }
 
  if(isnan(*fret) || !isfinite(*fret)) {
    if(verbose>10) printf("powell() fails and returns the initial point.\n");
    if(verbose>11) {
      if(isnan(*fret)) printf("  fret := NaN\n");
      if(isfinite(*fret)) printf("  fret := overflow/underflow\n");
    }
    // if failed, then return initial guess
    for(j=0; j<parNr; j++) p[j]=origp[j];
    // and call function again so that any data saved there is correct
    *fret=(*_powellFunc)(parNr, p, _powellFuncData);
    return(3);
  }
  // and call function again so that any data saved there is correct
  *fret=(*_powellFunc)(parNr, p, _powellFuncData);
  if((*iterNr)>=iterMax) return(1);
  if(verbose>0) printf("out of powell() in good order.\n");
  return(0);
}

Referenced by bootstrap(), and tgo().

◆ qr()

int qr	(	double **	A,
		int	m,
		int	n,
		double *	B,
		double *	X,
		double *	rnorm,
		double *	tau,
		double *	res,
		double **	wws,
		double *	ws )

extern

Algorithm QR.

Solves a matrix form least square problem min||A x - b|| => A x =~ b (A is m*n matrix, m>=n) using the QR decomposition for overdetermined systems. Based on GNU Scientific Library, edited by Kaisa Liukko.

Instead of pointers for working space, NULL can be given to let this function to allocate and free the required memory.

Returns: Function returns 0 if successful and 1 in case of invalid problem dimensions or memory allocation error.

See also: qr_decomp, qr_solve, qrLH

Parameters

A	On entry, a[m][n] contains the m by n matrix A. On exit, a[][] contains the QR factorization.
m	Dimensions of matrix A are a[m][n].
n	Dimensions of matrix A are a[m][n].
B	B[] is an m-size vector containing the right-hand side vector b.
X	On exit, x[] will contain the solution vector x (size of n).
rnorm	On exit, rnorm (pointer to double) contains the squared Euclidean norm of the residual vector (R^2); enter NULL if not needed.
tau	On exit, tau[] will contain the householder coefficients (size of n); enter NULL, if not needed.
res	An m-size array of working space, res[]. On output contains residual b - Ax. Enter NULL to let qr() to handle it.
wws	m*n array of working space. Enter NULL to let qr() to handle it.
ws	2m-array of working space. Enter NULL to let qr() to handle it.

Definition at line 346 of file qr.c.

  {
  int i;
  double *qrRes, *qrTau, **qrWws, *qrWs, *chain;
 
  /* Check the parameters and data */
  if(m<=0 || n<=0 || A==NULL || B==NULL || X==NULL) return(1);
  if(m<n) return(1);
 
  /* Allocate memory for working space, if required */
  if(tau!=NULL) qrTau=tau; else qrTau=(double*)calloc(n, sizeof(double));
  if(res!=NULL) qrRes=res; else qrRes=(double*)calloc(m, sizeof(double));
  if(wws!=NULL) {
    qrWws=wws; chain=(double*)NULL;
  } else {
    qrWws=(double**)malloc(m * sizeof(double*));
    chain=(double*)malloc(m*n * sizeof(double));
    for(i=0; i<m; i++) qrWws[i]=chain + i*n;
  }
  if(ws!=NULL) qrWs=ws; else qrWs=(double*)calloc(2*m, sizeof(double));
  if(qrTau==NULL || qrRes==NULL || qrWws==NULL || qrWs==NULL) return(1);
 
  /* Form the householder decomposition and solve the least square problem */
  if(qr_decomp(A, m, n, qrTau, qrWws, qrWs)) return(2);
  if(qr_solve(A, m, n, qrTau, B, X, qrRes, rnorm, qrWws, qrWs)) return(3);
 
  /* Free working space, if it was allocated here */
  if(tau==NULL) free(qrTau);
  if(res==NULL) free(qrRes);
  if(wws==NULL) {free(qrWws); free(chain);}
  if(ws==NULL) free(qrWs);
  for(i=0; i<n; i++) if(isnan(X[i])) return(4);
  return(0);
} /* qr */

◆ qr_decomp()

int qr_decomp	(	double **	a,
		int	M,
		int	N,
		double *	tau,
		double **	cchain,
		double *	chain )

extern

Factorise a general M x N matrix A into A = Q R , where Q is orthogonal (M x M) and R is upper triangular (M x N).

Q is stored as a packed set of Householder vectors in the strict lower triangular part of the input matrix A and a set of coefficients in vector tau.

R is stored in the diagonal and upper triangle of the input matrix.

The full matrix for Q can be obtained as the product Q = Q_1 Q_2 .. Q_k and it's transform as the product Q^T = Q_k .. Q_2 Q_1 , where k = min(M,N) and Q_i = (I - tau_i * h_i * h_i^T) and where h_i is a Householder vector h_i = [1, A(i+1,i), A(i+2,i), ... , A(M,i)]. This storage scheme is the same as in LAPACK.

NOTICE! The calling program must take care that pointer tau is of size N or M, whichever is smaller.

Returns: Function returns 0 if ok.

See also: qr_solve

Parameters

a	contains coefficient matrix A (m*n) as input and factorisation QR as output.
M	nr of rows in matrix A.
N	nr of columns in matrix A.
tau	Vector for householder coefficients, of length N or M, whichever is smaller.
cchain	m*n matrix of working space.
chain	m size array of working space.

Definition at line 427 of file qr.c.

  {
  //printf("qr_decomp()\n");
  int i, m, n, MNmin;
  double *subvector, **submatrix;
 
  /* Local variables */
  if(M<N) MNmin=M; else MNmin=N;
  if(MNmin<1 || a==NULL || tau==NULL || cchain==NULL || chain==NULL) return(1);
 
  subvector=chain;
  submatrix=cchain;
 
  for(i=0; i<MNmin; i++) {
    //printf("i=%d (MNmin=%d)\n", i, MNmin);
    /* Compute the Householder transformation to reduce the j-th column of the matrix A to 
       a multiple of the j-th unit vector. Householder vector h_i is saved in the lower triangular 
       part of the column and Householder coefficient tau_i in the vector tau. */
    for(m=i; m<M; m++) subvector[m-i]=a[m][i];
    tau[i] = householder_transform(subvector, M-i);
    for(m=i; m<M; m++) a[m][i]=subvector[m-i];
 
    /* Apply the transformation to the remaining columns to get upper triangular part of matrix R  */
    if(i+1 < N) {
      for(m=i; m<M; m++)
        for(n=i+1; n<N; n++)
          submatrix[m-i][n-i-1]=a[m][n];
      if(householder_hm(tau[i], subvector, submatrix, M-i, N-i)) return(2);
      for(m=i; m<M; m++)
        for(n=i+1; n<N; n++)
          a[m][n]=submatrix[m-i][n-i-1];
    }
  }
 
  return(0);
}

Referenced by qr().

◆ qr_solve()

int qr_solve	(	double **	QR,
		int	M,
		int	N,
		double *	tau,
		double *	b,
		double *	x,
		double *	residual,
		double *	resNorm,
		double **	cchain,
		double *	chain )

extern

Find the least squares solution to the overdetermined system

A x = b

for m >= n using the QR factorisation A = Q R. qr_decomp() must be used prior to this function in order to form the QR factorisation of A. Solution is formed in the following order: QR x = b => R x = Q^T b => x = R^-1 (Q^T b)

NOTICE! The calling program must take care that pointers b, x and residual are of the right size.

Returns: Function returns 0 if ok.

Precondition: qr_decomp

Parameters

QR	m*n matrix containing householder vectors of A.
M	nr of rows in matrix A.
N	nr of columns in matrix A.
tau	vector containing householder coefficients tau; length is M or N, whichever is smaller.
b	Contains m-size vector b of A x = b.
x	solution vector x of length n.
residual	residual vector of length m.
resNorm	norm^2 of the residual vector; enter NULL if not needed.
cchain	m*n matrix of the working space.
chain	2m length array of the working space.

Definition at line 492 of file qr.c.

  {
  //printf("qr_solve()\n");
  if(QR==NULL || tau==NULL || b==NULL || x==NULL || residual==NULL) return(1);
  if(cchain==NULL || chain==NULL) return(1);
  if(M<1 || N<1) return(2);
 
  int MNmin; if(M<N) MNmin=M; else MNmin=N;
 
  int m, n;
  double **Rmatrix=cchain;
  double *h=chain;
  double *w=chain+M;
 
  /* Get matrix R from the upper triangular part of QR
     First the rows N - M-1 are eliminated from R matrix*/
  for(m=0; m<N; m++) for(n=0; n<N; n++) Rmatrix[m][n]=QR[m][n];
  for(m=0; m<M; m++) residual[m]=b[m];
 
  /* Compute b = Q^T b */
  /* Form the product Q^T residual from householder vectors saved in the lower triangle of 
     QR matrix and householder coefficients saved in vector tau. */
  for(int i=0; i<MNmin; i++) {
    for(m=i; m<M; m++) h[m-i]=QR[m][i]; 
    for(m=i; m<M; m++) w[m-i]=residual[m];
    if(householder_hv(tau[i], M-i, h, w)) return(2);
    for(m=i; m<M; m++) residual[m]=w[m-i];
  }
 
  /* Solve R x = b by computing x = R^-1 b */
  for(n=0; n<N; n++) x[n]=residual[n];
  /* back-substitution */
  x[N-1]=x[N-1]/Rmatrix[N-1][N-1];
  for(int i=N-2; i>=0; i--) {
    for(int j=i+1; j<N; j++) x[i]-=Rmatrix[i][j]*x[j];
    x[i]/=Rmatrix[i][i];
  }
 
  /* Compute residual = b - A x = Q (Q^T b - R x) */
  for(n=0; n<N; n++) residual[n]=0.0;
  /* Compute residual= Q*residual */
  /* Form the product Q*residual from householder vectors saved in the lower triangle
     of QR matrix and householder coefficients saved in vector tau. */
  for(int i=MNmin-1; i>=0; i--) {
    for(int m=i; m<M; m++) h[m-i]=QR[m][i]; 
    for(int m=i; m<M; m++) w[m-i]=residual[m];
    if(householder_hv(tau[i], M-i, h, w)) return(2);
    for(int m=i; m<M; m++) residual[m]=w[m-i];
  }
 
  /* Compute norm^2 of the residual vector, if needed */
  if(resNorm!=NULL)
    for(m=0, *resNorm=0.0; m<M; m++) *resNorm +=residual[m]*residual[m];
 
  return(0);
}

Referenced by qr().

◆ qr_weight()

int qr_weight	(	int	N,
		int	M,
		double **	A,
		double *	b,
		double *	weight,
		double *	ws )

extern

Algorithm for weighting the problem that is given to QR algorithm.

Square roots of weights are used because in QR the difference w*A-w*b is squared.

Returns: Algorithm returns zero if successful, otherwise <>0.

Parameters

N	Dimensions of matrix A are a[m][n].
M	Dimensions of matrix A are a[m][n]; size of vector B is m.
A	Matrix a[m][n] for QR, contents will be weighted here.
b	B[] is an m-size vector for QR, contents will be weighted here.
weight	Pointer to array of size m, which contains sample weights, used here to weight matrix A and vector b.
ws	m-sized vector for working space; enter NULL to allocate locally.

Definition at line 576 of file qr.c.

  {
  int n, m;
  double *w;
 
  /* Check the arguments */
  if(N<1 || M<1 || A==NULL || b==NULL || weight==NULL) return(1);
 
  /* Allocate memory, if necessary */
  if(ws==NULL) {
    w=(double*)malloc(M*sizeof(double)); if(w==NULL) return(2);
  } else {
    w=ws;
  }
 
  /* Check that weights are not zero and get the square roots of them to w[]. */
  for(m=0; m<M; m++) {
    if(weight[m]<=1.0e-100) w[m]=1.0e-50;
    else w[m]=sqrt(weight[m]);
  }
 
  /* Multiply rows of matrix A and elements of vector b with weights. */
  for(m=0; m<M; m++) {
    for(n=0; n<N; n++) A[m][n]*=w[m];
    b[m]*=w[m];
  }
 
  if(ws==NULL) free(w);
  return(0);
}

◆ qrLH()

int qrLH	(	const unsigned int	m,
		const unsigned int	n,
		double *	a,
		double *	b,
		double *	x,
		double *	r2 )

extern

Solve over-determined least-squares problem A x ~ b using successive Householder rotations.

This routine is based on the text and Fortran code in C.L. Lawson and R.J. Hanson, Solving Least Squares Problems, Prentice-Hall, Englewood Cliffs, New Jersey, 1974, and Fortran code by R.L. Parker and P.B. Stark.

Returns: Returns 0 when successful, 1 if system is singular, and 2 in case of other errors, including that system is under-determined.

Parameters

m	Number of samples in matrix A and the length of vector b.
n	Number of parameters in matrix A and the length of vector x. The n must be smaller or equal to m.
a	Pointer to matrix A; matrix must be given as an n*m array, containing n consecutive m-length vectors. Contents of A are modified in this routine.
b	Pointer to vector b of length n. Contents of b are modified in this routine.
x	Pointer to the result vector x of length n.
r2	Pointer to a double value, in where the sum of squared residuals is written.

Definition at line 633 of file qr.c.

  {
  /* Check the input */
  if(a==NULL || b==NULL || x==NULL || r2==NULL) return(2);
  if(n<1 || m<n) {*r2=nan(""); return(2);}
 
  /* Initiate output to zeroes, in case of exit because of singularity */
  for(unsigned int ni=0; ni<n; ni++) x[ni]=0.0;
  *r2=0.0;
 
  /* Rotates matrix A into upper triangular form */
  for(unsigned int ni=0; ni<n; ni++) {
    /* Find constants for rotation and diagonal entry */
    double sq=0.0;
    for(unsigned int mi=ni; mi<m; mi++) sq+=a[mi + ni*m]*a[mi + ni*m];
    if(sq==0.0) return(1);
    double qv1=-copysign(sqrt(sq), a[ni + ni*m]);
    double u1=a[ni + ni*m] - qv1;
    a[ni + ni*m]=qv1;
    unsigned int ni1=ni+1;
    /*  Rotate the remaining columns of sub-matrix. */
    for(unsigned int nj=ni1; nj<n; nj++) {
      double dot=u1*a[ni + nj*m];
      for(unsigned int mi=ni1; mi<m; mi++)
        dot+=a[mi + nj*m] * a[mi + ni*m];
      double c=dot/fabs(qv1*u1);
      for(unsigned int mi=ni1; mi<m; mi++)
        a[mi + nj*m]-=c*a[mi + ni*m];
      a[ni + nj*m]-=c*u1;
    }
    /* Rotate vector B */
    double dot=u1*b[ni];
    for(unsigned int mi=ni1; mi<m; mi++)
      dot+=b[mi]*a[mi + ni*m];
    double c=dot/fabs(qv1*u1);
    b[ni]-=c*u1;
    for(unsigned int mi=ni1; mi<m; mi++)
      b[mi]-=c*a[mi + ni*m];
  } // end of rotation loop
 
  /* Solve triangular system by back-substitution. */
  for(unsigned int ni=0; ni<n; ni++) {
    int k=n-ni-1;
    double s=b[k];
    for(unsigned int nj=k+1; nj<n; nj++) 
      s-=a[k + nj*m] * x[nj];
    if(a[k + k*m]==0.0) return(1);
    x[k]=s/a[k + k*m];
  }
 
  /* Calculate the sum of squared residuals. */
  *r2=0.0;
  for(unsigned int mi=n; mi<m; mi++)
    *r2 += b[mi]*b[mi];
 
  return(0);
}

Referenced by bvls().

◆ qrLSQ()

int qrLSQ	(	double **	mat,
		double *	rhs,
		double *	sol,
		const unsigned int	rows,
		const unsigned int	cols,
		double *	r2 )

extern

QR least-squares solving routine.

Solves a matrix form least square problem min||A x - b|| => A x =~ b (A is m*n matrix, m>=n) using the QR decomposition for overdetermined systems

Author: : Michael Mazack License: Public Domain. Redistribution and modification without restriction is granted. If you find this code helpful, please let the author know (https://mazack.org). Small editions by Vesa Oikonen when added to tpcclib.

See also: nnls, qr

Todo: Check that modification in one subroutine is ok, and add possibility to provide working space for the main and sub-functions.

Returns: Returns 0 if ok.

Parameters

mat	Pointer to the row-major matrix (2D array), A[rows][cols]; not modified.
rhs	Vector b[rows]; modified to contain the computed (fitted) b[], that is, matrix-vector product A*x.
sol	Solution vector x[cols]; solution x corresponds to the solution of both the modified and original systems A and B.
rows	Number of rows (samples) in matrix A and length of vector B.
cols	Number of cols (parameters) in matrix A and length of vector X.
r2	Pointer to value where R^2, the difference between original and computed right hand side (b); enter NULL if not needed.

Definition at line 54 of file qr.c.

  {
  if(rows<1 || cols<1) return(1);
  if(mat==NULL || rhs==NULL || sol==NULL) return(2);
 
  unsigned int i, j, max_loc;
  unsigned int *p=NULL;
  double *buf=NULL, *ptr, *v=NULL, *orig_b=NULL, **A=NULL;
 
  /* Allocate memory for index vector and Householder transform vector */
  /* and original data matrix and vector. */
  p=malloc(sizeof(unsigned int)*cols);
  A=malloc(sizeof(double*)*rows);
  buf=malloc(sizeof(double)*(rows*cols+rows+rows));
  if(p==NULL || A==NULL || buf==NULL) {
    free(p); free(A); free(buf); 
    return(3);
  }
  ptr=buf; 
  for(i=0; i<rows; i++) {A[i]=ptr; ptr+=cols;}
  v=ptr; ptr+=rows; orig_b=ptr;
  /* copy the original data */
  for(i=0; i<rows; i++) {
    orig_b[i]=rhs[i];
    for(j=0; j<cols; j++) A[i][j]=mat[i][j];
  }
 
  /* Initial permutation vector. */
  for(i=0; i<cols; i++) p[i]=i;
  
  /* Apply rotators to make R and Q'*b */
  for(i=0; i<cols; i++) {
    if(qr_get_next_col(A, rows, cols, i, p, &max_loc)==0)
      qr_swap_cols(p, i, max_loc);
    qr_householder(A, rows, cols, i, p[i], v);
    qr_apply_householder(A, rhs, rows, cols, v, i, p);
  }
 
  /* Back solve Rx = Q'*b */
  qr_back_solve(A, rhs, rows, cols, sol, p);
 
  /* Compute fitted b[] (matrix-vector product A*x) using non-modified A */
  for(i=0; i<rows; i++) {
    rhs[i]=0.0;
    for(j=0; j<cols; j++) rhs[i]+=mat[i][j]*sol[j];
  }
 
  /* Compute R^2, if requested */
  if(r2!=NULL) {
    double ss=0, d;
    for(i=0; i<rows; i++) {
      d=orig_b[i]-rhs[i];
      ss+=d*d;
    }
    *r2=ss;
  }
 
  /* Collect garbage. */
  free(p); free(A); free(buf);
  return(0);
}

◆ quadratic()

int quadratic	(	double	a,
		double	b,
		double	c,
		double *	m1,
		double *	m2 )

extern

Finds the real roots of a*x^2 + b*x + c = 0

Returns: Returns the nr of roots, and the roots in m1 and m2.

Parameters

a	Input A
b	Input B
c	Input C
m1	Output: Root 1
m2	Output: Root 2

Definition at line 490 of file llsqwt.c.

  {
  double discriminant, r, r1, r2, sgnb, temp;
 
  if(a==0) {if(b==0) return(0); else {*m1=*m2=-c/b; return(1);}}
  discriminant=b*b - 4*a*c;
  if(discriminant>0) {
    if(b==0) {r=fabs(0.5*sqrt(discriminant)/a); *m1=-r; *m2=r;}
    else {
      sgnb=(b>0 ? 1:-1); temp=-0.5*(b + sgnb*sqrt(discriminant));
      r1=temp/a; r2=c/temp; if(r1<r2) {*m1=r1; *m2=r2;} else {*m1=r2; *m2=r1;}
    }
    return(2);
  } else if(discriminant==0) {
    *m1=-0.5*b/a; *m2=-0.5*b/a;
    return(2);
  } else {
    return(0);
  }
}

Referenced by llsqperp().

◆ rand_range()

int rand_range	(	int	nr,
		double *	d,
		double	low,
		double	up,
		int	type )

extern

Fills the double array with random numbers between specified limits. Set seed for random number generator before calling this routine, for example with srand(time(NULL));

Returns: Returns 0 when successful, otherwise <> 0.

Parameters

nr	Nr of values in double array
d	Pointer to allocated double array
low	Lower limit for random values
up	Upper limit for random values
type	Distribution: 0=even, 1=square-root transformation

Definition at line 159 of file gaussdev.c.

  {
  int i;
  double dif, v, stl, stu;
 
  if(nr<1) return 0;
  if(d==NULL || type<0 || type>1) return 1;
 
  dif=up-low; if(dif<0.0) return 2;
  if(dif==0.0) {
    for(i=0; i<nr; i++) d[i]=low;
    return 0;
  }
 
  if(type==0) {
    for(i=0; i<nr; i++) d[i] = drand()*dif + low;
  } else if(type==1) {
    stl=copysign(sqrt(fabs(low)),low); if(!isnormal(stl)) stl=0.0;
    stu=copysign(sqrt(fabs(up)), up); if(!isnormal(stu)) stu=0.0;
    dif=stu-stl;
    for(i=0; i<nr; i++) {v=drand()*dif+stl; d[i]=copysign(v*v, v);}
  }
 
  return 0;
}

◆ random_shuffle()

void random_shuffle	(	int *	array,
		int	n )

extern

Random shuffle: arrange the n elements of array in random order. Only effective if N is much smaller than RAND_MAX.

Definition at line 13 of file shuffle.c.

{
  if(n<=1 || array==NULL) return;
  int i, j, tmp;
  for(i=0; i<n-1; i++) {
    j=i+rand()/(RAND_MAX/(n-i)+1);
    tmp=array[j]; array[j]=array[i]; array[i]=tmp;
  }
}

Referenced by randperm().

◆ randperm()

void randperm	(	int *	array,
		int	n,
		int	a )

extern

Random permutation: given (allocated) array of length n is filled with random permutation of numbers in the range [a:n+a-1]; that is, each number once in random order.

Definition at line 29 of file shuffle.c.

{
  if(n<1 || array==NULL) return;
  int i;
  for(i=0; i<n; i++) array[i]=i+a;
  random_shuffle(array, n);
}

◆ regr_line()

int regr_line	(	double *	x,
		double *	y,
		int	n,
		double *	m,
		double *	c )

extern

Calculates regression line slope (m) and y axis intercept.

Data (x and y data) may contain NaN's.

See also: highest_slope, pearson, imgsegmPearson

Returns: Returns 0 if ok.

Parameters

x	An array of x axis values.
y	An array of y axis values.
n	The number of values in x and y arrays.
m	Pointer where calculated slope is written.
c	Pointer where calculated y axis intercept is written.

Definition at line 387 of file pearson.c.

  {
  double xsum=0.0, ysum=0.0, x2sum=0.0, xysum=0.0, delta;
  int i, nn=0;
 
  /* Check the data */
  if(x==NULL || y==NULL) return(1);
  if(n<2) return(2);
 
  /* Compute */
  for(i=0, nn=0; i<n; i++) {
    if(isnan(x[i]) || isnan(y[i])) continue;
    xsum+=x[i]; ysum+=y[i]; x2sum+=x[i]*x[i]; xysum+=x[i]*y[i]; nn++;
  }
  if(nn<2) return(2);
  delta=(double)nn*x2sum - xsum*xsum; if(delta==0.0) return(3);
  *m=((double)nn*xysum - xsum*ysum)/delta;
  *c=(x2sum*ysum - xsum*xysum)/delta;
  return(0);
}

Referenced by highest_slope(), and highest_slope_after().

◆ residuals()

int residuals	(	double *	d1,
		double *	d2,
		int	Nr,
		int *	Rnr,
		int *	Nminus,
		int *	Nplus )

extern

Residuals function calculates the nr of runs (a sequence of consecutive positive or negative residuals) and nr of negative and positive residuals for two data arrays.

Returns: Returns 0, if ok.

Parameters

d1	double array with data points
d2	double array with data points
Nr	number of data points in both arrays
Rnr	nr of runs
Nminus	nr of negative residuals
Nplus	nr of positive residuals

Definition at line 56 of file runs_test.c.

  {
  if(d1==NULL || d2==NULL || Nr<1 || Rnr==NULL || Nminus==NULL || Nplus==NULL) return(1);
 
  int i, *sign;
  double *res;
 
  /* Allocate memory for residuals */
  res=(double*)malloc((Nr)*sizeof(double));
  sign=(int*)malloc((Nr)*sizeof(int));
  if(res==NULL || sign==NULL) return(2);
 
  /* get residuals into res, nr of negative residuals in Nminus */
  /* nr of positive residuals into Nplus */
  /* Sign of each residual is saved into sign */
  /* and if sign is different from the last residual, increase runs nr */
  *Nminus=0; *Nplus=0; *Rnr=1;
  for(i=0; i<Nr; i++) {
    res[i]=d1[i]-d2[i];
    if(res[i]<0.0) {
      *Nminus+=1; sign[i]=-1;
    } else {
      *Nplus+=1; sign[i]=1;
    }
    if(i>0) if(sign[i]!=sign[i-1]) *Rnr+=1;
  }
  free(res); free(sign);
  return(0);
}

Referenced by runs_test().

◆ runs_test()

int runs_test	(	double *	data1,
		double *	data2,
		int	N,
		double	alpha,
		double *	p )

extern

Runs_test function tests if residuals of two data arrays are independent.

Returns: Returns 0, if residuals are independent, -1, if residuals are dependent and >0 in case of an error.

Parameters

data1	double array with data points
data2	double array with data points
N	number of data points in both arrays
alpha	significance level percentage (set to negative value to use default 5%)
p	calculated probability p; enter NULL if not needed

Definition at line 12 of file runs_test.c.

  {
  int R=1, Nneg=0, Npos=0, NN;
  double expect, var, Z, pvalue=0.0, a, b;
  if(alpha<=0.0) alpha=5.0;
 
  residuals(data1, data2, N, &R, &Nneg, &Npos);
  //printf("* R=%d  Nneg=%d  Npos=%d\n", R, Nneg, Npos); 
 
  /* Expectation value for R. See Cobelli p. 262*/
  NN=2*Nneg*Npos;
  if(NN<1) {if(p!=NULL) *p=pvalue; return -1;}
  expect=(double)NN/(double)N + 1.0;
 
  /* Variance for R. See Cobelli Eq 8.6.4 p. 262*/
  a=(double)NN*(double)(NN-N); b=(double)(N-1)*(double)N*(double)N;
  var=a/b;
 
  /* R->Z that tends to _standardized_ normal distribution */
  Z=((double)R-expect)/sqrt(var); // printf("  Z=%g\n", Z);
  /* Get propability of getting value Z from normal distribution*/
  pvalue=ndtr(Z); if(p!=NULL) *p=pvalue;
 
  if (pvalue<0.01*alpha) return -1;
  else return 0;
}

◆ simC1()

int simC1	(	double *	t,
		double *	ca,
		int	nr,
		double	k1,
		double	k2,
		double *	ct )

extern

Simulates tissue TAC using 1 tissue compartment model plasma TAC, at plasma TAC times.

Memory for ct must be allocated in the calling program.

The units of rate constants must be related to the time unit; 1/min and min, or 1/sec and sec.

Returns: Function returns 0 when successful, else a value >= 1.

See also: simC3s, simC3p, simC3vs, simC3vp, simC2l, simC2vl, simC3vpKLoss, simRTCM, simSRTM, simTRTM, simHuangmet, simTPCMOD0009c, simMBF, simC3DIvs, simC4DIvp, simC4DIvs, simDispersion, simOxygen

Parameters

t	Array of time values
ca	Array of arterial activities
nr	Number of values in TACs
k1	Rate constant of the model
k2	Rate constant of the model
ct	Pointer for TAC array to be simulated; must be allocated

Definition at line 1317 of file simulate.c.

  {
  int i;
  double dt2;
  double cai, ca_last, t_last;
  double ct1, ct1_last;
  double ct1i, ct1i_last;
 
 
  /* Check for data */
  if(nr<2) return 1;
  if(ct==NULL) return 2;
 
  /* Check actual parameter number */
  if(k1<0.0) return 3;
 
  /* Calculate curves */
  t_last=0.0; if(t[0]<t_last) t_last=t[0]; 
  cai=ca_last=0.0;
  ct1_last=ct1i_last=0.0;
  ct1=ct1i=0.0;
  for(i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last);
    /* calculate values */
    if(dt2<0.0) {
      return 5;
    } else if(dt2>0.0) {
      /* arterial integral */
      cai+=(ca[i]+ca_last)*dt2;
      /* tissue compartment and its integral */
      ct1 = (k1*cai - k2*(ct1i_last+dt2*ct1_last)) / (1.0 + dt2*k2);
      ct1i = ct1i_last + dt2*(ct1_last+ct1);
    }
    /* copy values to argument arrays; set very small values to zero */
    ct[i]=ct1; if(fabs(ct[i])<1.0e-12) ct[i]=0.0;
    /* prepare to the next loop */
    t_last=t[i]; ca_last=ca[i];
    ct1_last=ct1; ct1i_last=ct1i;
  }
 
  return 0;
}

Referenced by bf_srtm(), bfIrr2TCM(), bfRadiowater(), and simDispersion().

◆ simC2l()

int simC2l	(	double *	t,
		double *	ca,
		int	nr,
		double	k1,
		double	k2,
		double	k3,
		double	kLoss,
		double *	ct,
		double *	cta,
		double *	ctb )

extern

Simulates tissue TAC using 2 tissue compartment model (in series) and plasma TAC, at plasma TAC times. In contrary to the common model, kLoss represents a direct loss rate from the 2nd tissue compartment to venous plasma.

Memory for ct must be allocated in the calling program. To retrieve the separate tissue compartment TACs, pointer to allocated memory for cta and ctb can be given; if compartmental TACs are not required, NULL pointer can be given instead.

The units of rate constants must be related to the time unit; 1/min and min, or 1/sec and sec.

Returns: Function returns 0 when successful, else a value >= 1.

See also: simC3s, simC3p, simC3vs, simC3vp, simC2vl, simC3vpKLoss, simRTCM, simSRTM, simTRTM, simHuangmet, simTPCMOD0009c, simMBF, simC1, simC3DIvs, simC4DIvp, simC4DIvs, simDispersion, simOxygen

Parameters

t	Array of time values
ca	Array of arterial activities
nr	Number of values in TACs
k1	Rate constant of the model
k2	Rate constant of the model
k3	Rate constant of the model
kLoss	Rate constant of the model
ct	Pointer for TAC array to be simulated; must be allocated
cta	Pointer for 1st compartment TAC to be simulated, or NULL
ctb	Pointer for 2nd compartment TAC to be simulated, or NULL

Definition at line 500 of file simulate.c.

  {
  int i;
  double b, c, dt2;
  double cai, ca_last, t_last;
  double ct1, ct1_last, ct2, ct2_last;
  double ct1i, ct1i_last, ct2i, ct2i_last;
 
 
  /* Check for data */
  if(nr<2) return 1;
  if(ct==NULL) return 2;
 
  /* Check actual parameter number */
  if(k1<0.0) return 3;
 
  /* Calculate curves */
  t_last=0.0; if(t[0]<t_last) t_last=t[0];
  cai=ca_last=0.0;
  ct1_last=ct2_last=ct1i_last=ct2i_last=ct1=ct2=ct1i=ct2i=0.0;
  for(i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last);
    /* calculate values */
    if(dt2<0.0) {
      return 5;
    } else if(dt2>0.0) {
      /* arterial integral */
      cai+=(ca[i]+ca_last)*dt2;
      /* partial results */
      b=ct1i_last+dt2*ct1_last;
      c=ct2i_last+dt2*ct2_last;
      /* 1st tissue compartment and its integral */
      ct1 = (k1*cai - (k2+k3)*b) / (1.0 + (k2+k3)*dt2 );
      ct1i = ct1i_last + dt2*(ct1_last+ct1);
      /* 2nd tissue compartment and its integral */
      ct2 = (k3*ct1i - kLoss*c) / (1.0 + kLoss*dt2);
      ct2i = ct2i_last + dt2*(ct2_last+ct2);
    }
    /* copy values to argument arrays; set very small values to zero */
    ct[i]=ct1+ct2; if(fabs(ct[i])<1.0e-12) ct[i]=0.0;
    if(cta!=NULL) {cta[i]=ct1; if(fabs(cta[i])<1.0e-12) cta[i]=0.0;}
    if(ctb!=NULL) {ctb[i]=ct2; if(fabs(ctb[i])<1.0e-12) ctb[i]=0.0;}
    /* prepare to the next loop */
    t_last=t[i]; ca_last=ca[i];
    ct1_last=ct1; ct1i_last=ct1i;
    ct2_last=ct2; ct2i_last=ct2i;
  }
 
  return 0;
}

◆ simC2vl()

int simC2vl	(	double *	t,
		double *	ca,
		double *	cb,
		int	nr,
		double	k1,
		double	k2,
		double	k3,
		double	kL,
		double	f,
		double	vb,
		double	fa,
		double *	cpet,
		double *	cta,
		double *	ctb,
		double *	ctab,
		double *	ctvb )

extern

Simulates tissue TAC using 2 tissue compartment model and plasma TAC, at plasma TAC times, considering also arterial and venous vasculature. The efflux from 2nd tissue compartment (at rate kL) goes directly to blood.

Memory for cpet must be allocated in the calling program. To retrieve the separate tissue compartment TACs, pointer to allocated memory for cta, ctb, ctab and/or ctvb can be given; if compartmental TACs are not required, NULL pointer can be given instead.

The units of rate constants must be related to the time unit; 1/min and min, or 1/sec and sec.

If blood flow is set to 0, function assumes that f>>k1, and Cvb=Cab.,

Returns: Function returns 0 when successful, else a value >= 1.

See also: simC3s, simC3p, simC3vs, simC3vp, simC2l, simC3vpKLoss, simRTCM, simSRTM, simTRTM, simHuangmet, simTPCMOD0009c, simMBF, simC1, simC3DIvs, simC4DIvp, simC4DIvs, simDispersion, simOxygen

Parameters

t	Array of time values
ca	Array of arterial plasma activities
cb	Array of arterial blood activities
nr	Number of values in TACs
k1	Rate constant of the model
k2	Rate constant of the model
k3	Rate constant of the model
kL	Rate constant of the model
f	Blood flow; if 0, function assumes that f>>k1, and Cvb=Cab.
vb	Vascular volume fraction
fa	Arterial fraction of vascular volume
cpet	Pointer for TAC array to be simulated; must be allocated
cta	Pointer for 1st compartment TAC to be simulated, or NULL
ctb	Pointer for 2nd compartment TAC to be simulated, or NULL
ctab	Pointer for arterial TAC in tissue, or NULL
ctvb	Pointer for venous TAC in tissue, or NULL

Definition at line 592 of file simulate.c.

  {
  int i;
  double dt2, b, c, va, vv;
  double cai, ca_last, t_last, dct, cvb;
  double ct1, ct1_last, ct2, ct2_last;
  double ct1i, ct1i_last, ct2i, ct2i_last;
 
 
  /* Check for data */
  if(nr<2) return 1;
  if(cpet==NULL) return 2;
 
  /* Check parameters */
  if(k1<0.0) return 3;
  if(vb<0.0 || vb>=1.0) return 4;
  if(fa<=0.0 || fa>1.0) return 5;
  va=fa*vb; vv=(1.0-fa)*vb;
 
  /* Calculate curves */
  t_last=0.0; if(t[0]<t_last) t_last=t[0];
  cai=ca_last=0.0;
  ct1_last=ct2_last=ct1i_last=ct2i_last=ct1=ct2=ct1i=ct2i=0.0;
  for(i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last);
    /* calculate values */
    if(dt2<0.0) {
      return 5;
    } else if(dt2>0.0) {
      /* arterial integral */
      cai+=(ca[i]+ca_last)*dt2;
      /* Calculate partial results */
      b=ct1i_last+dt2*ct1_last;
      c=ct2i_last+dt2*ct2_last;
      /* 1st tissue compartment and its integral */
      ct1 = (k1*cai - (k2+k3)*b) / (1.0 + (k2+k3)*dt2 );
      ct1i = ct1i_last + dt2*(ct1_last+ct1);
      /* 2nd tissue compartment and its integral */
      ct2 = (k3*ct1i - kL*c) / (1.0 + kL*dt2);
      ct2i = ct2i_last + dt2*(ct2_last+ct2);
    }
    /* Venous curve */
    if(f>0.) {dct = k1*ca[i] - k2*ct1 - kL*ct2; cvb = cb[i] - dct/f;}
    else cvb=cb[i];
    /* copy values to argument arrays; set very small values to zero */
    cpet[i]= va*cb[i] + vv*cvb + (1.0-vb)*(ct1+ct2);
    if(fabs(cpet[i])<1.0e-12) cpet[i]=0.0;
    if(cta!=NULL) {cta[i]=(1.0-vb)*ct1; if(fabs(cta[i])<1.0e-12) cta[i]=0.0;}
    if(ctb!=NULL) {ctb[i]=(1.0-vb)*ct2; if(fabs(ctb[i])<1.0e-12) ctb[i]=0.0;}
    if(ctab!=NULL) {ctab[i]=va*cb[i]; if(fabs(ctab[i])<1.0e-12) ctab[i]=0.0;}
    if(ctvb!=NULL) {ctvb[i]=vv*cvb; if(fabs(ctvb[i])<1.0e-12) ctvb[i]=0.0;}
    /* prepare to the next loop */
    t_last=t[i]; ca_last=ca[i];
    ct1_last=ct1; ct1i_last=ct1i;
    ct2_last=ct2; ct2i_last=ct2i;
  }
 
  return 0;
}

◆ simC3DIvs()

int simC3DIvs	(	double *	t,
		double *	ca1,
		double *	ca2,
		double *	cb,
		int	nr,
		double	k1,
		double	k2,
		double	k3,
		double	k4,
		double	k5,
		double	k6,
		double	k1b,
		double	k2b,
		double	f,
		double	vb,
		double	fa,
		double *	scpet,
		double *	sct1,
		double *	sct2,
		double *	sct3,
		double *	sct1b,
		double *	sctab,
		double *	sctvb )

extern

Simulates tissue TAC using dual-input tissue compartment model (1-3 compartments in series for tracer1, and 1 compartment for tracer2) at plasma TAC times, considering also contribution of arterial and venous vasculature, but no exchange between compartments for tracer1 and tracer2. The units of rate constants must be related to the time unit; 1/min and min, or 1/sec and sec. If blood flow is set to 0, function assumes that f>>k1, and Cvb=Cab.

Returns: Function returns 0 when successful, else a value >= 1.

See also: simC3s, simC3p, simC3vs, simC3vp, simC2l, simC2vl, simC3vpKLoss, simRTCM, simSRTM, simTRTM, simHuangmet, simTPCMOD0009c, simMBF, simC1, simC4DIvp, simC4DIvs, simDispersion, simOxygen

Parameters

t	Array of time values
ca1	Array of arterial plasma activities of tracer1
ca2	Array of arterial plasma activities of tracer2
cb	Array of arterial blood activities
nr	Number of values in TACs
k1	Rate constant of the model for tracer1 (from plasma to C1)
k2	Rate constant of the model for tracer1 (from C1 to plasma)
k3	Rate constant of the model for tracer1 (from C1 to C2)
k4	Rate constant of the model for tracer1 (from C2 to C1)
k5	Rate constant of the model for tracer1 (from C2 to C3)
k6	Rate constant of the model for tracer1 (from C3 to C2)
k1b	Rate constant of the model for tracer2 (from plasma to C4)
k2b	Rate constant of the model for tracer2 (from C4 to plasma)
f	Blood flow; if 0, function assumes that f>>k1, and Cvb=Cab.
vb	Vascular volume fraction
fa	Arterial fraction of vascular volume
scpet	Pointer for TAC array to be simulated; must be allocated
sct1	Pointer for 1st tracer1 compartment TAC, or NULL if not needed
sct2	Pointer for 2nd tracer1 compartment TAC, or NULL if not needed
sct3	Pointer for 3rd tracer1 compartment TAC, or NULL if not needed
sct1b	Pointer for 1st tracer2 compartment TAC, or NULL if not needed
sctab	Pointer for arterial TAC in tissue, or NULL if not needed
sctvb	Pointer for venous TAC in tissue, or NULL if not needed

Definition at line 1387 of file simulate.c.

  {
  int i;
  double b, c, d, e, w, z, dt2, va, vv;
  double ca1i, ca1_last, ca2i, ca2_last, t_last, dct, cvb;
  double ct1, ct1_last, ct2, ct2_last, ct3, ct3_last;
  double ct1i, ct1i_last, ct2i, ct2i_last, ct3i, ct3i_last;
  double ct1b, ct1b_last, ct1bi, ct1bi_last;
 
 
  /* Check for data */
  if(nr<2) return 1;
  if(scpet==NULL) return 2;
 
  /* Check parameters */
  if(k1<0.0) return 3;
  if(vb<0.0 || vb>=1.0) return 4;
  if(fa<=0.0 || fa>1.0) return 5;
  va=fa*vb; vv=(1.0-fa)*vb;
 
  /* Calculate curves */
  t_last=0.0; if(t[0]<t_last) t_last=t[0];
  ca1i=ca1_last=ca2i=ca2_last=0.0;
  ct1_last=ct2_last=ct3_last=ct1i_last=ct2i_last=ct3i_last=0.0;
  ct1b_last=ct1bi_last=0.0;
  ct1=ct2=ct3=ct1b=ct1i=ct2i=ct3i=ct1bi=0.0;
  for(i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last);
    /* calculate values */
    if(dt2<0.0) {
      return 5;
    } else if(dt2>0.0) {
      /* arterial integrals */
      ca1i+=(ca1[i]+ca1_last)*dt2;
      ca2i+=(ca2[i]+ca2_last)*dt2;
      /* partial results */
      b=ct1i_last+dt2*ct1_last;
      c=ct2i_last+dt2*ct2_last;
      d=ct3i_last+dt2*ct3_last;
      e=ct1bi_last+dt2*ct1b_last;
      w=k4 + k5 - (k5*k6*dt2)/(1.0+k6*dt2);
      z=1.0+w*dt2;
      /* 1st tissue compartment and its integral */
      ct1 = (
          + k1*z*ca1i + (k3*k4*dt2 - (k2+k3)*z)*b
          + k4*c + k4*k6*dt2*d/(1.0+k6*dt2)
        ) / ( z*(1.0 + dt2*(k2+k3)) - k3*k4*dt2*dt2 );
      ct1i = ct1i_last + dt2*(ct1_last+ct1);
      ct1b = (k1b*ca2i - k2b*e) / (1.0 + dt2*k2b);
      ct1bi = ct1bi_last + dt2*(ct1b_last+ct1b);
      /* 2nd tissue compartment and its integral */
      ct2 = (k3*ct1i - w*c + k6*d/(1.0+k6*dt2)) / z;
      ct2i = ct2i_last + dt2*(ct2_last+ct2);
      /* 3rd tissue compartment and its integral */
      ct3 = (k5*ct2i - k6*d) / (1.0 + k6*dt2);
      ct3i = ct3i_last + dt2*(ct3_last+ct3);
    }
    /* Venous curve */
    if(f>0.) {
      dct = k1*ca1[i] - k2*ct1 + k1b*ca2[i] - k2b*ct1b;
      cvb = cb[i] - dct/f;
    } else cvb=cb[i];
    /* copy values to argument arrays; set very small values to zero */
    scpet[i]= va*cb[i] + vv*cvb + (1.0-vb)*(ct1+ct2+ct3+ct1b);
    if(fabs(scpet[i])<1.0e-12) scpet[i]=0.0;
    if(sct1!=NULL) {sct1[i]=(1.0-vb)*ct1; if(fabs(sct1[i])<1.0e-12) sct1[i]=0.0;}
    if(sct2!=NULL) {sct2[i]=(1.0-vb)*ct2; if(fabs(sct2[i])<1.0e-12) sct2[i]=0.0;}
    if(sct3!=NULL) {sct3[i]=(1.0-vb)*ct3; if(fabs(sct3[i])<1.0e-12) sct3[i]=0.0;}
    if(sct1b!=NULL) {
      sct1b[i]=(1.0-vb)*ct1b; if(fabs(sct1b[i])<1.0e-12) sct1b[i]=0.0;}
    if(sctab!=NULL) {sctab[i]=va*cb[i]; if(fabs(sctab[i])<1.0e-12) sctab[i]=0.0;}
    if(sctvb!=NULL) {sctvb[i]=vv*cvb; if(fabs(sctvb[i])<1.0e-12) sctvb[i]=0.0;}
    /* prepare to the next loop */
    t_last=t[i]; ca1_last=ca1[i]; ca2_last=ca2[i];
    ct1_last=ct1; ct1i_last=ct1i;
    ct2_last=ct2; ct2i_last=ct2i;
    ct3_last=ct3; ct3i_last=ct3i;
    ct1b_last=ct1b; ct1bi_last=ct1bi;
  }
 
  return 0;
}

◆ simC3p()

int simC3p	(	double *	t,
		double *	ca,
		int	nr,
		double	k1,
		double	k2,
		double	k3,
		double	k4,
		double	k5,
		double	k6,
		double *	ct,
		double *	cta,
		double *	ctb,
		double *	ctc )

extern

Simulates tissue TAC using 1-3 tissue compartment model (2nd and 3rd compartments in parallel) and plasma TAC, at plasma TAC times.

Memory for ct must be allocated in the calling program. To retrieve the separate tissue compartment TACs, pointer to allocated memory for cta, ctb and/or ctc can be given; if compartmental TACs are not required, NULL pointer can be given instead.

The units of rate constants must be related to the time unit; 1/min and min, or 1/sec and sec.

Returns: Function returns 0 when successful, else a value >= 1.

See also: simC3s, simC3vs, simC3vp, simC2l, simC2vl, simC3vpKLoss, simRTCM, simSRTM, simTRTM, simHuangmet, simTPCMOD0009c, simMBF, simC1, simC3DIvs, simC4DIvp, simC4DIvs, simDispersion, simOxygen

Parameters

t	Array of time values
ca	Array of arterial activities
nr	Number of values in TACs
k1	Rate constant of the model
k2	Rate constant of the model
k3	Rate constant of the model
k4	Rate constant of the model
k5	Rate constant of the model
k6	Rate constant of the model
ct	Pointer for TAC array to be simulated; must be allocated
cta	Pointer for 1st compartment TAC to be simulated, or NULL
ctb	Pointer for 2nd compartment TAC to be simulated, or NULL
ctc	Pointer for 3rd compartment TAC to be simulated, or NULL

Definition at line 136 of file simulate.c.

  {
  int i;
  double dt2, r, s, u, v, w;
  double cai, ca_last, t_last;
  double ct1, ct1_last, ct2, ct2_last, ct3, ct3_last;
  double ct1i, ct1i_last, ct2i, ct2i_last, ct3i, ct3i_last;
 
 
  /* Check for data */
  if(nr<2) return 1;
  if(ct==NULL) return 2;
 
  /* Check parameters */
  if(k1<0.0) return 3;
 
  /* Calculate curves */
  t_last=0.0; if(t[0]<t_last) t_last=t[0];
  cai=ca_last=0.0;
  ct1_last=ct2_last=ct3_last=ct1i_last=ct2i_last=ct3i_last=0.0;
  ct1=ct2=ct3=ct1i=ct2i=ct3i=0.0;
  for(i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last);
    /* calculate values */
    if(dt2<0.0) {
      return 5;
    } else if(dt2>0.0) {
      /* arterial integral */
      cai+=(ca[i]+ca_last)*dt2;
      /* Calculate partial results */
      r=1.0+k4*dt2;
      s=1.0+k6*dt2;
      u=ct1i_last+dt2*ct1_last;
      v=ct2i_last+dt2*ct2_last;
      w=ct3i_last+dt2*ct3_last;
      /* 1st tissue compartment and its integral */
      ct1 = ( k1*cai - (k2 + (k3/r) + (k5/s))*u + (k4/r)*v + (k6/s)*w )
            / ( 1.0 + dt2*(k2 + (k3/r) + (k5/s)) );
      ct1i = ct1i_last + dt2*(ct1_last+ct1);
      /* 2nd tissue compartment and its integral */
      ct2 = (k3*ct1i - k4*v) / r;
      ct2i = ct2i_last + dt2*(ct2_last+ct2);
      /* 3rd tissue compartment and its integral */
      ct3 = (k5*ct1i - k6*w) / s;
      ct3i = ct3i_last + dt2*(ct3_last+ct3);
    }
    /* copy values to argument arrays; set very small values to zero */
    ct[i]=ct1+ct2+ct3; if(fabs(ct[i])<1.0e-12) ct[i]=0.0;
    if(cta!=NULL) {cta[i]=ct1; if(fabs(cta[i])<1.0e-12) cta[i]=0.0;}
    if(ctb!=NULL) {ctb[i]=ct2; if(fabs(ctb[i])<1.0e-12) ctb[i]=0.0;}
    if(ctc!=NULL) {ctc[i]=ct3; if(fabs(ctc[i])<1.0e-12) ctc[i]=0.0;}
    /* prepare to the next loop */
    t_last=t[i]; ca_last=ca[i];
    ct1_last=ct1; ct1i_last=ct1i;
    ct2_last=ct2; ct2i_last=ct2i;
    ct3_last=ct3; ct3i_last=ct3i;
  }
 
  return 0;
}

◆ simC3s()

int simC3s	(	double *	t,
		double *	ca,
		int	nr,
		double	k1,
		double	k2,
		double	k3,
		double	k4,
		double	k5,
		double	k6,
		double *	ct,
		double *	cta,
		double *	ctb,
		double *	ctc )

extern

Simulates tissue TAC using 1-3 tissue compartment model (in series) and plasma TAC, at plasma TAC times.

Memory for ct must be allocated in the calling program. To retrieve the separate tissue compartment TACs, pointer to allocated memory for cta, ctb and/or ctc can be given; if compartmental TACs are not required, NULL pointer can be given instead.

The units of rate constants must be related to the time unit; 1/min and min, or 1/sec and sec.

Returns: Function returns 0 when successful, else a value >= 1.

See also: simC3p, simC3vs, simC3vp, simC2l, simC2vl, simC3vpKLoss, simRTCM, simSRTM, simTRTM, simHuangmet, simTPCMOD0009c, simMBF, simC1, simC3DIvs, simC4DIvp, simC4DIvs, simDispersion, simOxygen

Parameters

t	Array of time values
ca	Array of arterial activities
nr	Number of values in TACs
k1	Rate constant of the model
k2	Rate constant of the model
k3	Rate constant of the model
k4	Rate constant of the model
k5	Rate constant of the model
k6	Rate constant of the model
ct	Pointer for TAC array to be simulated; must be allocated
cta	Pointer for 1st compartment TAC to be simulated, or NULL
ctb	Pointer for 2nd compartment TAC to be simulated, or NULL
ctc	Pointer for 3rd compartment TAC to be simulated, or NULL

Definition at line 27 of file simulate.c.

  {
  double b, c, d, w, z, dt2;
  double cai, ca_last, t_last;
  double ct1, ct1_last, ct2, ct2_last, ct3, ct3_last;
  double ct1i, ct1i_last, ct2i, ct2i_last, ct3i, ct3i_last;
 
 
  /* Check for data */
  if(nr<2) return 1;
  if(ct==NULL) return 2;
 
  /* Check actual parameter number */
  if(k1<0.0) return 3;
  if(k3<=0.0) {k3=0.0; if(k2<=0.0) {k2=0.0;}}
  else if(k5<=0.0) {k5=0.0; if(k4<=0.0) {k4=0.0;}}
  else if(k6<=0.0) {k6=0.0;}
 
  /* Calculate curves */
  t_last=0.0; if(t[0]<t_last) t_last=t[0]; 
  cai=ca_last=0.0;
  ct1_last=ct2_last=ct3_last=ct1i_last=ct2i_last=ct3i_last=0.0;
  ct1=ct2=ct3=ct1i=ct2i=ct3i=0.0;
  for(int i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last);
    /* calculate values */
    if(dt2<0.0) {
      return 5;
    } else if(dt2>0.0) {
      /* arterial integral */
      cai+=(ca[i]+ca_last)*dt2;
      /* partial results */
      b=ct1i_last+dt2*ct1_last;
      c=ct2i_last+dt2*ct2_last;
      d=ct3i_last+dt2*ct3_last;
      w=k4 + k5 - (k5*k6*dt2)/(1.0+k6*dt2);
      z=1.0+w*dt2;
      /* 1st tissue compartment and its integral */
      ct1 = (
          + k1*z*cai + (k3*k4*dt2 - (k2+k3)*z)*b
          + k4*c + k4*k6*dt2*d/(1.0+k6*dt2)
        ) / ( z*(1.0 + dt2*(k2+k3)) - k3*k4*dt2*dt2 );
      ct1i = ct1i_last + dt2*(ct1_last+ct1);
      /* 2nd tissue compartment and its integral */
      ct2 = (k3*ct1i - w*c + k6*d/(1.0+k6*dt2)) / z;
      ct2i = ct2i_last + dt2*(ct2_last+ct2);
      /* 3rd tissue compartment and its integral */
      ct3 = (k5*ct2i - k6*d) / (1.0 + k6*dt2);
      ct3i = ct3i_last + dt2*(ct3_last+ct3);
    }
    /* copy values to argument arrays; set very small values to zero */
    ct[i]=ct1+ct2+ct3; if(fabs(ct[i])<1.0e-12) ct[i]=0.0;
    if(cta!=NULL) {cta[i]=ct1; if(fabs(cta[i])<1.0e-12) cta[i]=0.0;}
    if(ctb!=NULL) {ctb[i]=ct2; if(fabs(ctb[i])<1.0e-12) ctb[i]=0.0;}
    if(ctc!=NULL) {ctc[i]=ct3; if(fabs(ctc[i])<1.0e-12) ctc[i]=0.0;}
    /* prepare to the next loop */
    t_last=t[i]; ca_last=ca[i];
    ct1_last=ct1; ct1i_last=ct1i;
    ct2_last=ct2; ct2i_last=ct2i;
    ct3_last=ct3; ct3i_last=ct3i;
  }
 
  return 0;
}

◆ simC3vp()

int simC3vp	(	double *	t,
		double *	ca,
		double *	cb,
		int	nr,
		double	k1,
		double	k2,
		double	k3,
		double	k4,
		double	k5,
		double	k6,
		double	f,
		double	vb,
		double	fa,
		double *	cpet,
		double *	cta,
		double *	ctb,
		double *	ctc,
		double *	ctab,
		double *	ctvb )

extern

Simulates tissue TAC using 1-3 tissue compartment model (2nd and 3rd compartments in parallel) and plasma TAC, at plasma TAC times, considering also arterial and venous vasculature.

Memory for cpet must be allocated in the calling program. To retrieve the separate tissue compartment TACs, pointer to allocated memory for cta, ctb, ctc, ctab and/or ctvb can be given; if compartmental TACs are not required, NULL pointer can be given instead.

The units of rate constants must be related to the time unit; 1/min and min, or 1/sec and sec.

If blood flow is set to 0, function assumes that f>>k1, and Cvb=Cab.,

Returns: Function returns 0 when successful, else a value >= 1.

See also: simC3s, simC3p, simC3vs, simC2l, simC2vl, simC3vpKLoss, simRTCM, simSRTM, simTRTM, simHuangmet, simTPCMOD0009c, simMBF, simC1, simC3DIvs, simC4DIvp, simC4DIvs, simDispersion, simOxygen

Parameters

t	Array of time values
ca	Array of arterial plasma activities
cb	Array of arterial blood activities
nr	Number of values in TACs
k1	Rate constant of the model
k2	Rate constant of the model
k3	Rate constant of the model
k4	Rate constant of the model
k5	Rate constant of the model
k6	Rate constant of the model
f	Blood flow; if 0, function assumes that f>>k1, and Cvb=Cab.
vb	Vascular volume fraction
fa	Arterial fraction of vascular volume
cpet	Pointer for TAC array to be simulated; must be allocated
cta	Pointer for 1st compartment TAC to be simulated, or NULL
ctb	Pointer for 2nd compartment TAC to be simulated, or NULL
ctc	Pointer for 3rd compartment TAC to be simulated, or NULL
ctab	Pointer for arterial TAC in tissue, or NULL
ctvb	Pointer for venous TAC in tissue, or NULL

Definition at line 373 of file simulate.c.

  {
  int i;
  double dt2, r, s, u, v, w, va, vv;
  double cai, ca_last, t_last, dct, cvb;
  double ct1, ct1_last, ct2, ct2_last, ct3, ct3_last;
  double ct1i, ct1i_last, ct2i, ct2i_last, ct3i, ct3i_last;
 
 
  /* Check for data */
  if(nr<2) return 1;
  if(cpet==NULL) return 2;
 
  /* Check parameters */
  if(k1<0.0) return 3;
  if(vb<0.0 || vb>=1.0) return 4;
  if(fa<=0.0 || fa>1.0) return 5;
  va=fa*vb; vv=(1.0-fa)*vb;
 
  /* Calculate curves */
  t_last=0.0; if(t[0]<t_last) t_last=t[0];
  cai=ca_last=0.0;
  ct1_last=ct2_last=ct3_last=ct1i_last=ct2i_last=ct3i_last=0.0;
  ct1=ct2=ct3=ct1i=ct2i=ct3i=0.0;
  for(i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last);
    /* calculate values */
    if(dt2<0.0) {
      return 5;
    } else if(dt2>0.0) {
      /* arterial integral */
      cai+=(ca[i]+ca_last)*dt2;
      /* Calculate partial results */
      r=1.0+k4*dt2;
      s=1.0+k6*dt2;
      u=ct1i_last+dt2*ct1_last;
      v=ct2i_last+dt2*ct2_last;
      w=ct3i_last+dt2*ct3_last;
      /* 1st tissue compartment and its integral */
      ct1 = ( k1*cai - (k2 + (k3/r) + (k5/s))*u + (k4/r)*v + (k6/s)*w )
            / ( 1.0 + dt2*(k2 + (k3/r) + (k5/s)) );
      ct1i = ct1i_last + dt2*(ct1_last+ct1);
      /* 2nd tissue compartment and its integral */
      ct2 = (k3*ct1i - k4*v) / r;
      ct2i = ct2i_last + dt2*(ct2_last+ct2);
      /* 3rd tissue compartment and its integral */
      ct3 = (k5*ct1i - k6*w) / s;
      ct3i = ct3i_last + dt2*(ct3_last+ct3);
    }
    /* Venous curve */
    if(f>0.) {dct = k1*ca[i] - k2*ct1; cvb = cb[i] - dct/f;} else cvb=cb[i];
    /* copy values to argument arrays; set very small values to zero */
    cpet[i]= va*cb[i] + vv*cvb + (1.0-vb)*(ct1+ct2+ct3);
    if(fabs(cpet[i])<1.0e-12) cpet[i]=0.0;
    if(cta!=NULL) {cta[i]=(1.0-vb)*ct1; if(fabs(cta[i])<1.0e-12) cta[i]=0.0;}
    if(ctb!=NULL) {ctb[i]=(1.0-vb)*ct2; if(fabs(ctb[i])<1.0e-12) ctb[i]=0.0;}
    if(ctc!=NULL) {ctc[i]=(1.0-vb)*ct3; if(fabs(ctc[i])<1.0e-12) ctc[i]=0.0;}
    if(ctab!=NULL) {ctab[i]=va*cb[i]; if(fabs(ctab[i])<1.0e-12) ctab[i]=0.0;}
    if(ctvb!=NULL) {ctvb[i]=vv*cvb; if(fabs(ctvb[i])<1.0e-12) ctvb[i]=0.0;}
    /* prepare to the next loop */
    t_last=t[i]; ca_last=ca[i];
    ct1_last=ct1; ct1i_last=ct1i;
    ct2_last=ct2; ct2i_last=ct2i;
    ct3_last=ct3; ct3i_last=ct3i;
  }
 
  return 0;
}

◆ simC3vpKLoss()

int simC3vpKLoss	(	double *	t,
		double *	ca,
		double *	cb,
		int	nr,
		double	k1,
		double	k2,
		double	k3,
		double	k4,
		double	k5,
		double	k6,
		double	kLoss,
		double	f,
		double	vb,
		double	fa,
		double *	cpet,
		double *	cta,
		double *	ctb,
		double *	ctc,
		double *	ctab,
		double *	ctvb )

extern

Simulates tissue TAC using 3 tissue compartmental model with two parallel compartments, and plasma TAC, at plasma TAC sample times, considering also arterial and venous vasculature. The efflux from 3rd tissue compartment (C) goes directly to blood at rate kLoss.

Memory for cpet must be allocated in the calling program. To retrieve the separate tissue compartment TACs, pointer to allocated memory for cta, ctb, ctab and/or ctvb can be given; if compartmental TACs are not required, NULL pointer can be given instead.

The units of rate constants must be related to the time unit; 1/min and min, or 1/sec and sec.

If blood flow is set to 0, function assumes that f>>k1, and Cvb=Cab.,

Returns: Function returns 0 when successful, else a value >= 1.

See also: simC3s, simC3p, simC3vs, simC3vp, simC2l, simC2vl, simRTCM, simSRTM, simTRTM, simHuangmet, simTPCMOD0009c, simMBF, simC1, simC3DIvs, simC4DIvp, simC4DIvs, simDispersion, simOxygen

Parameters

t	Array of sample times
ca	Array of arterial plasma activities
cb	Array of arterial blood activities
nr	Number of sample values in TACs
k1	Rate constant of the model
k2	Rate constant of the model
k3	Rate constant of the model
k4	Rate constant of the model
k5	Rate constant of the model
k6	Rate constant of the model
kLoss	Rate constant of the model
f	Blood flow; if 0, function assumes that f>>k1, and Cvb=Cab.
vb	Vascular volume fraction
fa	Arterial fraction of vascular volume
cpet	Pointer for TAC array to be simulated; must be allocated
cta	Pointer for 1st tissue compartment TAC to be simulated, or NULL
ctb	Pointer for 2nd compartment TAC to be simulated, or NULL
ctc	Pointer for 3rd compartment TAC to be simulated, or NULL
ctab	Pointer for arterial TAC in tissue, or NULL
ctvb	Pointer for venous TAC in tissue, or NULL

Definition at line 707 of file simulate.c.

  {
  int i;
  double dt2, b, c, d, w, z, u, va, vv;
  double cai, ca_last, t_last, dct, cvb;
  double ct1, ct1_last, ct2, ct2_last, ct3, ct3_last;
  double ct1i, ct1i_last, ct2i, ct2i_last, ct3i, ct3i_last;
 
 
  /* Check for data */
  if(nr<2) return 1;
  if(cpet==NULL) return 2;
 
  /* Check parameters */
  if(k1<0.0) return 3;
  if(vb<0.0 || vb>=1.0) return 4;
  if(fa<=0.0 || fa>1.0) return 5;
  va=fa*vb; vv=(1.0-fa)*vb;
 
  /* Calculate curves */
  t_last=0.0; if(t[0]<t_last) t_last=t[0];
  cai=ca_last=0.0;
  ct1_last=ct2_last=ct3_last=ct1i_last=ct2i_last=ct3i_last=0.0;
  ct1=ct2=ct3=ct1i=ct2i=ct3i=0.0;
  for(i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last);
    /* calculate values */
    if(dt2<0.0) {
      return 5;
    } else if(dt2>0.0) {
      /* arterial integral */
      cai+=(ca[i]+ca_last)*dt2;
      /* Calculate partial results */
      w = 1.0 + k4*dt2;
      z = 1.0 + dt2*(k6 + kLoss); 
      u = k2 + k3 + k5 - k3*k4*dt2/w - k5*k6*dt2/z;
      b = ct1i_last+dt2*ct1_last;
      c = ct2i_last+dt2*ct2_last;
      d = ct3i_last+dt2*ct3_last;
      /* 1st tissue compartment and its integral */
      ct1 = ( k1*cai - u*b + k4*c/w + k6*d/z ) / ( 1.0 + dt2*u);
      ct1i = ct1i_last + dt2*(ct1_last+ct1);
      /* 2nd tissue compartment and its integral */
      ct2 = (k3*ct1i - k4*c) / w;
      ct2i = ct2i_last + dt2*(ct2_last+ct2);
      /* 3rd tissue compartment and its integral */
      ct3 = (k5*ct1i - (k6 + kLoss)*d) / z;
      ct3i = ct3i_last + dt2*(ct3_last+ct3);
    }
    /* Venous curve */
    if(f>0.) {dct = k1*ca[i] - k2*ct1 - kLoss*ct3; cvb = cb[i] - dct/f;}
    else cvb=cb[i];
    /* copy values to argument arrays; set very small values to zero */
    cpet[i]= va*cb[i] + vv*cvb + (1.0-vb)*(ct1+ct2+ct3);
    if(fabs(cpet[i])<1.0e-12) cpet[i]=0.0;
    if(cta!=NULL) {cta[i]=(1.0-vb)*ct1; if(fabs(cta[i])<1.0e-12) cta[i]=0.0;}
    if(ctb!=NULL) {ctb[i]=(1.0-vb)*ct2; if(fabs(ctb[i])<1.0e-12) ctb[i]=0.0;}
    if(ctc!=NULL) {ctc[i]=(1.0-vb)*ct3; if(fabs(ctc[i])<1.0e-12) ctc[i]=0.0;}
    if(ctab!=NULL) {ctab[i]=va*cb[i]; if(fabs(ctab[i])<1.0e-12) ctab[i]=0.0;}
    if(ctvb!=NULL) {ctvb[i]=vv*cvb; if(fabs(ctvb[i])<1.0e-12) ctvb[i]=0.0;}
    /* prepare to the next loop */
    t_last=t[i]; ca_last=ca[i];
    ct1_last=ct1; ct1i_last=ct1i;
    ct2_last=ct2; ct2i_last=ct2i;
    ct3_last=ct3; ct3i_last=ct3i;
  }
  
  return 0;
}

◆ simC3vs()

int simC3vs	(	double *	t,
		double *	ca,
		double *	cb,
		int	nr,
		double	k1,
		double	k2,
		double	k3,
		double	k4,
		double	k5,
		double	k6,
		double	f,
		double	vb,
		double	fa,
		double *	cpet,
		double *	cta,
		double *	ctb,
		double *	ctc,
		double *	ctab,
		double *	ctvb )

extern

Simulates tissue TAC using 1-3 tissue compartment model (in series) and plasma TAC, at plasma TAC times, considering also arterial and venous vasculature.

Memory for cpet must be allocated in the calling program. To retrieve the separate tissue compartment TACs, pointer to allocated memory for cta, ctb, ctc, ctab and/or ctvb can be given; if compartmental TACs are not required, NULL pointer can be given instead.

The units of rate constants must be related to the time unit; 1/min and min, or 1/sec and sec.

If blood flow is set to 0, function assumes that f>>k1, and Cvb=Cab.,

Returns: Function returns 0 when successful, else a value >= 1.

See also: simC3s, simC3p, simC3vp, simC2l, simC2vl, simC3vpKLoss, simRTCM, simSRTM, simTRTM, simHuangmet, simTPCMOD0009c, simMBF, simC1, simC3DIvs, simC4DIvp, simC4DIvs, simDispersion, simOxygen

Parameters

t	Array of time values
ca	Array of arterial plasma activities
cb	Array of arterial blood activities
nr	Number of values in TACs
k1	Rate constant of the model
k2	Rate constant of the model
k3	Rate constant of the model
k4	Rate constant of the model
k5	Rate constant of the model
k6	Rate constant of the model
f	Blood flow; if 0, function assumes that f>>k1, and Cvb=Cab.
vb	Vascular volume fraction
fa	Arterial fraction of vascular volume
cpet	Pointer for TAC array to be simulated; must be allocated
cta	Pointer for 1st compartment TAC to be simulated, or NULL
ctb	Pointer for 2nd compartment TAC to be simulated, or NULL
ctc	Pointer for 3rd compartment TAC to be simulated, or NULL
ctab	Pointer for arterial TAC in tissue, or NULL
ctvb	Pointer for venous TAC in tissue, or NULL

Definition at line 243 of file simulate.c.

  {
  int i;
  double b, c, d, w, z, dt2, va, vv;
  double cai, ca_last, t_last, dct, cvb;
  double ct1, ct1_last, ct2, ct2_last, ct3, ct3_last;
  double ct1i, ct1i_last, ct2i, ct2i_last, ct3i, ct3i_last;
 
 
  /* Check for data */
  if(nr<2) return 1;
  if(cpet==NULL) return 2;
 
  /* Check parameters */
  if(k1<0.0) return 3;
  if(vb<0.0 || vb>=1.0) return 4;
  if(fa<=0.0 || fa>1.0) return 5;
  va=fa*vb; vv=(1.0-fa)*vb;
 
  /* Calculate curves */
  t_last=0.0; if(t[0]<t_last) t_last=t[0];
  cai=ca_last=0.0;
  ct1_last=ct2_last=ct3_last=ct1i_last=ct2i_last=ct3i_last=0.0;
  ct1=ct2=ct3=ct1i=ct2i=ct3i=0.0;
  for(i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last);
    /* calculate values */
    if(dt2<0.0) {
      return 5;
    } else if(dt2>0.0) {
      /* arterial integral */
      cai+=(ca[i]+ca_last)*dt2;
      /* partial results */
      b=ct1i_last+dt2*ct1_last;
      c=ct2i_last+dt2*ct2_last;
      d=ct3i_last+dt2*ct3_last;
      w=k4 + k5 - (k5*k6*dt2)/(1.0+k6*dt2);
      z=1.0+w*dt2;
      /* 1st tissue compartment and its integral */
      ct1 = (
          + k1*z*cai + (k3*k4*dt2 - (k2+k3)*z)*b
          + k4*c + k4*k6*dt2*d/(1.0+k6*dt2)
        ) / ( z*(1.0 + dt2*(k2+k3)) - k3*k4*dt2*dt2 );
      ct1i = ct1i_last + dt2*(ct1_last+ct1);
      /* 2nd tissue compartment and its integral */
      ct2 = (k3*ct1i - w*c + k6*d/(1.0+k6*dt2)) / z;
      ct2i = ct2i_last + dt2*(ct2_last+ct2);
      /* 3rd tissue compartment and its integral */
      ct3 = (k5*ct2i - k6*d) / (1.0 + k6*dt2);
      ct3i = ct3i_last + dt2*(ct3_last+ct3);
    }
    /* Venous curve */
    if(f>0.) {dct = k1*ca[i] - k2*ct1; cvb = cb[i] - dct/f;} else cvb=cb[i];
    /* copy values to argument arrays; set very small values to zero */
    cpet[i]= va*cb[i] + vv*cvb + (1.0-vb)*(ct1+ct2+ct3);
    if(fabs(cpet[i])<1.0e-12) cpet[i]=0.0;
    if(cta!=NULL) {cta[i]=(1.0-vb)*ct1; if(fabs(cta[i])<1.0e-12) cta[i]=0.0;}
    if(ctb!=NULL) {ctb[i]=(1.0-vb)*ct2; if(fabs(ctb[i])<1.0e-12) ctb[i]=0.0;}
    if(ctc!=NULL) {ctc[i]=(1.0-vb)*ct3; if(fabs(ctc[i])<1.0e-12) ctc[i]=0.0;}
    if(ctab!=NULL) {ctab[i]=va*cb[i]; if(fabs(ctab[i])<1.0e-12) ctab[i]=0.0;}
    if(ctvb!=NULL) {ctvb[i]=vv*cvb; if(fabs(ctvb[i])<1.0e-12) ctvb[i]=0.0;}
    /* prepare to the next loop */
    t_last=t[i]; ca_last=ca[i];
    ct1_last=ct1; ct1i_last=ct1i;
    ct2_last=ct2; ct2i_last=ct2i;
    ct3_last=ct3; ct3i_last=ct3i;
  }
 
  return 0;
}

◆ simC4DIvp()

int simC4DIvp	(	double *	t,
		double *	ca1,
		double *	ca2,
		double *	cb,
		int	nr,
		double	k1,
		double	k2,
		double	k3,
		double	k4,
		double	k5,
		double	k6,
		double	k7,
		double	km,
		double	k1b,
		double	k2b,
		double	f,
		double	vb,
		double	fa,
		double *	scpet,
		double *	sct1,
		double *	sct2,
		double *	sct3,
		double *	sct1b,
		double *	sctab,
		double *	sctvb,
		int	verbose )

extern

Simulates tissue TAC using dual-input tissue compartment model (compartments 2 and 3 in parallel for tracer1, and 1 compartment for tracer2) at plasma TAC sample times, considering also contribution of arterial and venous vasculature, and transfer of tracer1 to tracer2. The units of rate constants must be related to the time unit; 1/min and min, or 1/sec and sec. If blood flow is set to 0, function assumes that f>>k1, and Cvb=Cab. Reference: TPCMOD0001 Appendix C. Tested with program p2t_di -parallel.

Returns: Function returns 0 when successful, else a value >= 1.

See also: simC3s, simC3p, simC3vs, simC3vp, simC2l, simC2vl, simC3vpKLoss, simRTCM, simSRTM, simTRTM, simHuangmet, simTPCMOD0009c, simMBF, simC1, simC3DIvs, simC4DIvs, simDispersion, simOxygen

Parameters

t	Array of time values
ca1	Array of arterial plasma activities of tracer1 (parent tracer)
ca2	Array of arterial plasma activities of tracer2 (metabolite)
cb	Array of (total) arterial blood activities
nr	Number of values in TACs
k1	Rate constant of the model for tracer1 (from plasma to C1)
k2	Rate constant of the model for tracer1 (from C1 to plasma)
k3	Rate constant of the model for tracer1 (from C1 to C2)
k4	Rate constant of the model for tracer1 (from C2 to C1)
k5	Rate constant of the model for tracer1 (from C1 to C3)
k6	Rate constant of the model for tracer1 (from C3 to C1)
k7	Rate constant of the model for tracer1 (from C3 to plasma)
km	Rate constant of the model (from tracer1 in C1 to tracer2 in C4)
k1b	Rate constant of the model for tracer2 (from plasma to C4)
k2b	Rate constant of the model for tracer2 (from C4 to plasma)
f	Blood flow; if 0, function assumes that f>>k1, and Cvb=Cab
vb	Vascular volume fraction (0<=Vb<1)
fa	Arterial fraction of vascular volume (0<=fa<=1)
scpet	Pointer for TAC array to be simulated; must be allocated
sct1	Pointer for 1st tracer1 compartment TAC, or NULL if not needed
sct2	Pointer for 2nd tracer1 compartment TAC, or NULL if not needed
sct3	Pointer for 3rd tracer1 compartment TAC, or NULL if not needed
sct1b	Pointer for 1st tracer2 compartment TAC, or NULL if not needed
sctab	Pointer for arterial TAC in tissue, or NULL if not needed
sctvb	Pointer for venous TAC in tissue, or NULL if not needed
verbose	Verbose level; if zero, then nothing is printed into stdout or stderr

Definition at line 1533 of file simulate.c.

  {
  int i;
  double b, c, d, e, pt, qt, dt2, va, vv;
  double ca1i, ca1_last, ca2i, ca2_last, t_last, dct, cvb;
  double ct1, ct1_last, ct2, ct2_last, ct3, ct3_last;
  double ct1i, ct1i_last, ct2i, ct2i_last, ct3i, ct3i_last;
  double ct1b, ct1b_last, ct1bi, ct1bi_last;
 
 
  if(verbose>0) {
    printf("simC4DIvp()\n");
    if(verbose>1) {
      printf("  k1 := %g\n", k1);
      printf("  k2 := %g\n", k2);
      printf("  k3 := %g\n", k3);
      printf("  k4 := %g\n", k4);
      printf("  k5 := %g\n", k5);
      printf("  k6 := %g\n", k6);
      printf("  k7 := %g\n", k7);
      printf("  km := %g\n", km);
      printf("  k1b := %g\n", k1b);
      printf("  k2b := %g\n", k2b);
      printf("  vb := %g\n", vb);
      printf("  fa := %g\n", fa);
      printf("  f := %g\n", f);
    }
  }
 
  /* Check for data */
  if(nr<2) return 1;
  if(scpet==NULL) return 2;
 
  /* Check parameters */
  if(k1<0.0 || k1b<0.0) return 3;
  if(vb<0.0 || vb>=1.0) return 4;
  if(fa<0.0 || fa>1.0) return 5;
  va=fa*vb; vv=(1.0-fa)*vb;
 
  /* Calculate curves */
  t_last=0.0; if(t[0]<t_last) t_last=t[0];
  ca1i=ca1_last=ca2i=ca2_last=0.0;
  ct1_last=ct2_last=ct3_last=ct1i_last=ct2i_last=ct3i_last=ct1b_last=
  ct1bi_last=0.0;
  ct1=ct2=ct3=ct1b=ct1i=ct2i=ct3i=ct1bi=0.0;
  for(i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last);
    /* calculate values */
    if(dt2<0.0) {
      return 5;
    } else if(dt2>0.0) {
      /* arterial integrals */
      ca1i+=(ca1[i]+ca1_last)*dt2;
      ca2i+=(ca2[i]+ca2_last)*dt2;
      /* partial results */
      b=ct1i_last+dt2*ct1_last;
      c=ct2i_last+dt2*ct2_last;
      d=ct3i_last+dt2*ct3_last;
      e=ct1bi_last+dt2*ct1b_last;
      pt=k6+k7;
      qt=k2+k3+k5+km-(k3*k4*dt2)/(1.0+k4*dt2)-(k5*k6*dt2)/(1.0+pt*dt2);
      /* 1st tissue compartment and its integral */
      ct1 = (k1/(1.0+qt*dt2))*ca1i
    - (qt/(1.0+qt*dt2))*b
          + (k4/((1.0+qt*dt2)*(1.0+k4*dt2)))*c
          + (k6/((1.0+qt*dt2)*(1.0+pt*dt2)))*d;
      ct1i = ct1i_last + dt2*(ct1_last+ct1);
      /* 2nd tissue compartment and its integral */
      ct2 = (k3/(1.0+k4*dt2))*ct1i
          - (k4/(1.0+k4*dt2))*c;
      ct2i = ct2i_last + dt2*(ct2_last+ct2);
      /* 3rd tissue compartment and its integral */
      ct3 = (k5/(1.0+pt*dt2))*ct1i
          - (pt/(1.0+pt*dt2))*d;
      ct3i = ct3i_last + dt2*(ct3_last+ct3);
      /* 4th tissue compartment (the 1st for tracer 2) and its integral */
      ct1b = (k1b/(1.0+k2b*dt2))*ca2i
           - (k2b/(1.0+k2b*dt2))*e
           + (km/(1.0+k2b*dt2))*ct1i;
      ct1bi = ct1bi_last + dt2*(ct1b_last+ct1b);
    }
    /* Venous curve */
    if(f>0.) {
      dct = k1*ca1[i] - k2*ct1 - k7*ct3 + k1b*ca2[i] - k2b*ct1b;
      cvb = cb[i] - dct/f;
    } else cvb=cb[i];
    /* copy values to argument arrays; set very small values to zero */
    scpet[i]= va*cb[i] + vv*cvb + (1.0-vb)*(ct1+ct2+ct3+ct1b);
    if(fabs(scpet[i])<1.0e-12) scpet[i]=0.0;
    if(sct1!=NULL) {
      sct1[i]=(1.0-vb)*ct1; if(fabs(sct1[i])<1.0e-12) sct1[i]=0.0;}
    if(sct2!=NULL) {
      sct2[i]=(1.0-vb)*ct2; if(fabs(sct2[i])<1.0e-12) sct2[i]=0.0;}
    if(sct3!=NULL) {
      sct3[i]=(1.0-vb)*ct3; if(fabs(sct3[i])<1.0e-12) sct3[i]=0.0;}
    if(sct1b!=NULL) {
      sct1b[i]=(1.0-vb)*ct1b; if(fabs(sct1b[i])<1.0e-12) sct1b[i]=0.0;}
    if(sctab!=NULL) {
      sctab[i]=va*cb[i]; if(fabs(sctab[i])<1.0e-12) sctab[i]=0.0;}
    if(sctvb!=NULL) {
      sctvb[i]=vv*cvb; if(fabs(sctvb[i])<1.0e-12) sctvb[i]=0.0;}
    /* prepare to the next loop */
    t_last=t[i]; ca1_last=ca1[i]; ca2_last=ca2[i];
    ct1_last=ct1; ct1i_last=ct1i;
    ct2_last=ct2; ct2i_last=ct2i;
    ct3_last=ct3; ct3i_last=ct3i;
    ct1b_last=ct1b; ct1bi_last=ct1bi;
  }
  
  if(verbose>2) {
    printf("AUC 0-%g:\n", t_last);
    printf(" ca1i := %g\n", ca1i);
    printf(" ca2i := %g\n", ca2i);
    printf(" ct1i := %g\n", ct1i_last);
    printf(" ct2i := %g\n", ct2i_last);
    printf(" ct3i := %g\n", ct3i_last);
    printf(" ct1bi := %g\n", ct1bi_last);
  }
 
  return 0;
}

◆ simC4DIvs()

int simC4DIvs	(	double *	t,
		double *	ca1,
		double *	ca2,
		double *	cb,
		int	nr,
		double	k1,
		double	k2,
		double	k3,
		double	k4,
		double	k5,
		double	k6,
		double	k7,
		double	km,
		double	k1b,
		double	k2b,
		double	f,
		double	vb,
		double	fa,
		double *	scpet,
		double *	sct1,
		double *	sct2,
		double *	sct3,
		double *	sct1b,
		double *	sctab,
		double *	sctvb,
		int	verbose )

extern

Simulates tissue TAC using dual-input tissue compartment model (1-3 compartments in series for tracer1, and 1 compartment for tracer2) at plasma TAC times, considering also contribution of arterial and venous vasculature, and transfer of tracer1 to tracer2. The units of rate constants must be related to the time unit; 1/min and min, or 1/sec and sec. If blood flow is set to 0, function assumes that f>>k1, and Cvb=Cab. Reference: TPCMOD0001 Appendix B. Tested with program p2t_di -series.

Returns: Function returns 0 when successful, else a value >= 1.

See also: simC3s, simC3p, simC3vs, simC3vp, simC2l, simC2vl, simC3vpKLoss, simRTCM, simSRTM, simTRTM, simHuangmet, simTPCMOD0009c, simMBF, simC1, simC3DIvs, simC4DIvp, simDispersion, simOxygen

Parameters

t	Array of time values
ca1	Array of arterial plasma activities of tracer1 (parent tracer)
ca2	Array of arterial plasma activities of tracer2 (metabolite)
cb	Array of (total) arterial blood activities
nr	Number of values in TACs
k1	Rate constant of the model for tracer1 (from plasma to C1)
k2	Rate constant of the model for tracer1 (from C1 to plasma)
k3	Rate constant of the model for tracer1 (from C1 to C2)
k4	Rate constant of the model for tracer1 (from C2 to C1)
k5	Rate constant of the model for tracer1 (from C2 to C3)
k6	Rate constant of the model for tracer1 (from C3 to C2)
k7	Rate constant of the model for tracer1 (from C3 to plasma)
km	Rate constant of the model (from tracer1 in C1 to tracer2 in C4)
k1b	Rate constant of the model for tracer2 (from plasma to C4)
k2b	Rate constant of the model for tracer2 (from C4 to plasma)
f	Blood flow; if 0, function assumes that f>>k1, and Cvb=Cab.
vb	Vascular volume fraction
fa	Arterial fraction of vascular volume
scpet	Pointer for TAC array to be simulated; must be allocated
sct1	Pointer for 1st tracer1 compartment TAC, or NULL if not needed
sct2	Pointer for 2nd tracer1 compartment TAC, or NULL if not needed
sct3	Pointer for 3rd tracer1 compartment TAC, or NULL if not needed
sct1b	Pointer for 1st tracer2 compartment TAC, or NULL if not needed
sctab	Pointer for arterial TAC in tissue, or NULL if not needed
sctvb	Pointer for venous TAC in tissue, or NULL if not needed
verbose	Verbose level; if zero, then nothing is printed into stdout or stderr

Definition at line 1724 of file simulate.c.

  {
  int i;
  double b, c, d, e, pt, qt, rt, dt2, va, vv;
  double ca1i, ca1_last, ca2i, ca2_last, t_last, dct, cvb;
  double ct1, ct1_last, ct2, ct2_last, ct3, ct3_last;
  double ct1i, ct1i_last, ct2i, ct2i_last, ct3i, ct3i_last;
  double ct1b, ct1b_last, ct1bi, ct1bi_last;
 
 
  if(verbose>0) {
    printf("simC4DIvs()\n");
    if(verbose>1) {
      printf("  k1 := %g\n", k1);
      printf("  k2 := %g\n", k2);
      printf("  k3 := %g\n", k3);
      printf("  k4 := %g\n", k4);
      printf("  k5 := %g\n", k5);
      printf("  k6 := %g\n", k6);
      printf("  k7 := %g\n", k7);
      printf("  km := %g\n", km);
      printf("  k1b := %g\n", k1b);
      printf("  k2b := %g\n", k2b);
      printf("  vb := %g\n", vb);
      printf("  fa := %g\n", fa);
      printf("  f := %g\n", f);
    }
  }
 
  /* Check for data */
  if(nr<2) return 1;
  if(scpet==NULL) return 2;
 
  /* Check parameters */
  if(k1<0.0 || k1b<0.0) return 3;
  if(vb<0.0 || vb>=1.0) return 4;
  if(fa<0.0 || fa>1.0) return 5;
  va=fa*vb; vv=(1.0-fa)*vb;
 
  /* Calculate curves */
  t_last=0.0; if(t[0]<t_last) t_last=t[0];
  ca1i=ca1_last=ca2i=ca2_last=0.0;
  ct1_last=ct2_last=ct3_last=ct1i_last=ct2i_last=ct3i_last=ct1b_last=
  ct1bi_last=0.0;
  ct1=ct2=ct3=ct1b=ct1i=ct2i=ct3i=ct1bi=0.0;
  for(i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last);
    /* calculate values */
    if(dt2<0.0) {
      return 5;
    } else if(dt2>0.0) {
      /* arterial integrals */
      ca1i+=(ca1[i]+ca1_last)*dt2;
      ca2i+=(ca2[i]+ca2_last)*dt2;
      //printf("ca1[%d]=%g int=%g\n", i, ca1[i], ca1i);
      //printf("ca2[%d]=%g int=%g\n", i, ca2[i], ca2i);
      /* partial results */
      b=ct1i_last+dt2*ct1_last;
      c=ct2i_last+dt2*ct2_last;
      d=ct3i_last+dt2*ct3_last;
      e=ct1bi_last+dt2*ct1b_last;
      pt=k6+k7;
      qt=k4+k5-(k5*k6*dt2)/(1.0+pt*dt2);
      rt=k2+k3+km-(k3*k4*dt2)/(1.0+qt*dt2);
      /* 1st tissue compartment and its integral */
      ct1 = (k1/(1.0+rt*dt2))*ca1i
    - (rt/(1.0+rt*dt2))*b
          + (k4/((1.0+qt*dt2)*(1.0+rt*dt2)))*c
          + ((k4*k6*dt2)/((1.0+pt*dt2)*(1.0+qt*dt2)*(1.0+rt*dt2)))*d;
      ct1i = ct1i_last + dt2*(ct1_last+ct1);
      /* 2nd tissue compartment and its integral */
      ct2 = (k3/(1.0+qt*dt2))*ct1i
          - (qt/(1.0+qt*dt2))*c
    + (k6/((1.0+pt*dt2)*(1.0+qt*dt2)))*d;
      ct2i = ct2i_last + dt2*(ct2_last+ct2);
      /* 3rd tissue compartment and its integral */
      ct3 = (k5/(1.0+pt*dt2))*ct2i
          - (pt/(1.0+pt*dt2))*d;
      ct3i = ct3i_last + dt2*(ct3_last+ct3);
      /* 4th tissue compartment (the 1st for tracer 2) and its integral */
      ct1b = (k1b/(1.0+k2b*dt2))*ca2i
           - (k2b/(1.0+k2b*dt2))*e
           + (km/(1.0+k2b*dt2))*ct1i;
      ct1bi = ct1bi_last + dt2*(ct1b_last+ct1b);
    }
    /* Venous curve */
    if(f>0.) {
      dct = k1*ca1[i] - k2*ct1 - k7*ct3 + k1b*ca2[i] - k2b*ct1b;
      cvb = cb[i] - dct/f;
    } else cvb=cb[i];
    /* copy values to argument arrays; set very small values to zero */
    scpet[i]= va*cb[i] + vv*cvb + (1.0-vb)*(ct1+ct2+ct3+ct1b);
    if(fabs(scpet[i])<1.0e-12) scpet[i]=0.0;
    if(sct1!=NULL) {
      sct1[i]=(1.0-vb)*ct1; if(fabs(sct1[i])<1.0e-12) sct1[i]=0.0;}
    if(sct2!=NULL) {
      sct2[i]=(1.0-vb)*ct2; if(fabs(sct2[i])<1.0e-12) sct2[i]=0.0;}
    if(sct3!=NULL) {
      sct3[i]=(1.0-vb)*ct3; if(fabs(sct3[i])<1.0e-12) sct3[i]=0.0;}
    if(sct1b!=NULL) {
      sct1b[i]=(1.0-vb)*ct1b; if(fabs(sct1b[i])<1.0e-12) sct1b[i]=0.0;}
    if(sctab!=NULL) {
      sctab[i]=va*cb[i]; if(fabs(sctab[i])<1.0e-12) sctab[i]=0.0;}
    if(sctvb!=NULL) {
      sctvb[i]=vv*cvb; if(fabs(sctvb[i])<1.0e-12) sctvb[i]=0.0;}
    /* prepare to the next loop */
    t_last=t[i]; ca1_last=ca1[i]; ca2_last=ca2[i];
    ct1_last=ct1; ct1i_last=ct1i;
    ct2_last=ct2; ct2i_last=ct2i;
    ct3_last=ct3; ct3i_last=ct3i;
    ct1b_last=ct1b; ct1bi_last=ct1bi;
  }
  
  if(verbose>2) {
    printf("AUC 0-%g:\n", t_last);
    printf(" ca1i := %g\n", ca1i);
    printf(" ca2i := %g\n", ca2i);
    printf(" ct1i := %g\n", ct1i_last);
    printf(" ct2i := %g\n", ct2i_last);
    printf(" ct3i := %g\n", ct3i_last);
    printf(" ct1bi := %g\n", ct1bi_last);
  }
 
  return 0;
}

◆ simDispersion()

int simDispersion	(	double *	x,
		double *	y,
		int	n,
		double	tau1,
		double	tau2,
		double *	tmp )

extern

Simulate the effect of dispersion on a time-activity curve.

Returns: Returns 0 when successful, otherwise <>0.

See also: simC3s, simC3p, simC3vs, simC3vp, simC2l, simC2vl, simC3vpKLoss, simRTCM, simSRTM, simTRTM, simHuangmet, simTPCMOD0009c, simMBF, simC1, simC3DIvs, simC4DIvp, simC4DIvs, simOxygen

Parameters

x	Array of sample times.
y	Array of sample values, which will be replaced here by dispersion added values.
n	Nr of samples.
tau1	First dispersion time constant (zero if no dispersion); in same time unit as sample times.
tau2	2nd dispersion time constant (zero if no dispersion); in same time unit as sample times.
tmp	Array for temporary data, for at least n samples; enter NULL to let function to allocate and free the temporary space.

Definition at line 1911 of file simulate.c.

  {
  /* Check input */
  if(x==NULL || y==NULL || n<2) return 1;
  if(tau1<0.0 || tau2<0.0) return 2;
 
  /* Allocate memory if not allocated by user */
  double *buf;
  if(tmp!=NULL) buf=tmp; else buf=(double*)malloc(n*sizeof(double));
  if(buf==NULL) return 3;
 
  /* First dispersion */
  if(tau1>0.0) {
    double k=1.0/tau1;
    int ret=simC1(x, y, n, k, k, buf);
    if(ret!=0) {
      if(tmp==NULL) free(buf);
      return 100+ret;
    }
    for(int i=0; i<n; i++) y[i]=buf[i];
  }
 
  /* Second dispersion */
  if(tau2>0.0) {
    double k=1.0/tau2;
    int ret=simC1(x, y, n, k, k, buf);
    if(ret!=0) {
      if(tmp==NULL) free(buf);
      return 200+ret;
    }
    for(int i=0; i<n; i++) y[i]=buf[i];
  }
 
  if(tmp==NULL) free(buf);
  return 0;
}

Referenced by fitEvaltac().

◆ simHuangmet()

int simHuangmet	(	double *	t,
		double *	ctot,
		int	nr,
		double	k01,
		double	k12,
		double	k21,
		double	k03,
		double	k34,
		double	k43,
		double *	c0,
		double *	c1,
		double *	c3 )

extern

Simulation of TACs of parent tracer, and 1-2 of its metabolites in plasma using Huang's compartmental model.

The units of model parameters must be related to the sample time unit; 1/min and min, or 1/sec and sec.

Pointers to memory for output TACs must be specified, or NULL if TAC is not needed.

Returns: Returns 0, if ok.

See also: simC3s, simC3p, simC3vs, simC3vp, simC2l, simC2vl, simC3vpKLoss, simRTCM, simSRTM, simTRTM, simTPCMOD0009c, simMBF, simC1, simC3DIvs, simC4DIvp, simC4DIvs, simDispersion, simOxygen

Parameters

t	Input: Sample times (preferably with short intervals)
ctot	Input: Measured total plasma TAC
nr	Input: Nr of samples
k01	Input: Model parameters
k12	Input: Model parameters
k21	Input: Model parameters
k03	Input: Model parameters
k34	Input: Model parameters
k43	Input: Model parameters
c0	Output: unchanged (parent) tracer TAC
c1	Output: TAC of the 1st metabolite
c3	Output: TAC of the 2nd metabolite

Definition at line 1054 of file simulate.c.

  {
  int i;
  double dt2, t_last, ictot, ctot_last;
  double c0_, c1_, c2_, c3_, c4_;
  double ic0_, ic1_, ic2_, ic3_, ic4_;
  double c0_last, c1_last, c2_last, c3_last, c4_last;
  double ic0_last, ic1_last, ic2_last, ic3_last, ic4_last;
  double a, b, am1, am2, am3, am4;
 
 
  /* Check input */
  if(t==NULL || ctot==NULL || nr<2) return(1);
  if(k01<0 || k12<0 || k21<0 || k03<0 || k34<0 || k43<0) return(2);
  if(t[0]<0.0) return(3);
 
  /* Compute the TACs */
  t_last=0.0; if(t[0]<t_last) t_last=t[0];
  ictot=ctot_last=0.0;
  c0_=c0_last=ic0_=ic0_last=0.0;
  c1_=c1_last=ic1_=ic1_last=0.0;
  c2_=c2_last=ic2_=ic2_last=0.0;
  c3_=c3_last=ic3_=ic3_last=0.0;
  c4_=c4_last=ic4_=ic4_last=0.0;
  for(i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last); if(dt2<0.0) return(5);
    if(dt2>0.0) {
      /* Compute temp constants */
      a=k01+k12-(k12*k21*dt2/(1.0+dt2*k21));
      b=k03+k34-(k34*k43*dt2/(1.0+dt2*k43));
      am1=ic1_last+dt2*c1_last;
      am2=ic2_last+dt2*c2_last;
      am3=ic3_last+dt2*c3_last;
      am4=ic4_last+dt2*c4_last;
    
      /* Compute the "input" i.e. ctot integral */
      ictot+=(ctot[i]+ctot_last)*dt2;
      /* Compute C1(t) and its integral */
      c1_= ( k01*(1.0-k03*dt2/(1.0+dt2*b))*ictot
            -(a-k01*k03*dt2/(1.0+dt2*b))*am1
            +(k21/(1.0+dt2*k21))*am2
            -(k01/(1.0+dt2*b))*am3
            -(k01*k43*dt2/((1.0+dt2*b)*(1.0+dt2*k43)))*am4
           ) / ( 1.0+dt2*(a-k01*k03*dt2/(1.0+dt2*b)) );
      ic1_= ic1_last + dt2*(c1_+c1_last);
      /* Compute C2(t) and its integral */
      c2_= (k12*ic1_-k21*am2)/(1.0+dt2*k21);
      ic2_= ic2_last + dt2*(c2_+c2_last);
 
      /* Compute C3(t) and its integral */
      c3_= ( k03*(1.0-k01*dt2/(1.0+dt2*a))*ictot
            -(b-k01*k03*dt2/(1.0+dt2*a))*am3
            +(k43/(1.0+dt2*k43))*am4
            -(k03/(1.0+dt2*a))*am1
            -(k03*k21*dt2/((1.0+dt2*a)*(1.0+dt2*k21)))*am2
           ) / ( 1.0+dt2*(b-k01*k03*dt2/(1.0+dt2*a)) );
      ic3_= ic3_last + dt2*(c3_+c3_last);
      /* Compute C4(t) and its integral */
      c4_= (k34*ic3_-k43*am4)/(1.0+dt2*k43);
      ic4_= ic4_last + dt2*(c4_+c4_last);
 
      /* Compute the C0(t) */
      c0_=ctot[i]-c1_-c3_; /*if(c0_<0.0) return(-1);*/
    }
    /* Set output data */
    if(c0) c0[i]=c0_; 
    if(c1) c1[i]=c1_; 
    if(c3) c3[i]=c3_;
    /* Prepare for the next sample */
    c0_last=c0_; c1_last=c1_; c2_last=c2_; c3_last=c3_; c4_last=c4_;
    ic0_last=ic0_; ic1_last=ic1_; ic2_last=ic2_; ic3_last=ic3_; ic4_last=ic4_;
    ctot_last=ctot[i]; t_last=t[i];
  } /* next sample */
 
  return(0);
}

◆ simMBF()

int simMBF	(	double *	t,
		double *	ci,
		int	nr,
		double	k1,
		double	k2,
		double	Vfit,
		double *	ct )

extern

Simulate myocardial tissue TAC using Iida's compartment model. Memory for ct must be allocated in the calling program. The units of rate constants must be related to the time unit; 1/min and min, or 1/sec and sec.

Returns: 0 when successful, else a value >= 1.

See also: simC3s, simC3p, simC3vs, simC3vp, simC2l, simC2vl, simC3vpKLoss, simRTCM, simSRTM, simTRTM, simHuangmet, simTPCMOD0009c, simC1, simC3DIvs, simC4DIvp, simC4DIvs, simDispersion, simOxygen

Parameters

t	Array of time values
ci	Input activities
nr	Number of values in TACs
k1	Apparent k1
k2	Apparent k2
Vfit	Vfit
ct	Pointer for TAC array to be simulated; must be allocated

Definition at line 1253 of file simulate.c.

  {
  int i;
  double dt2;
  double cii, ci_last, t_last;
  double ct_last, cti, cti_last;
 
 
  /* Check for data */
  if(nr<2) return(1);
  if(ct==NULL) return(2);
 
  /* Calculate curves */
  t_last=0.0; cii=ci_last=0.0;
  cti=ct_last=cti_last=0.0;
  for(i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last);
    /* calculate values */
    if(dt2<0.0) {
      return(5);
    } else if(dt2>0.0) {
      /* input integral */
      cii+=(ci[i]+ci_last)*dt2;
      /* Tissue compartment and its integral */
      ct[i] = (Vfit*ci[i] + k1*cii - k2*(cti_last+dt2*ct_last)) / (1.0 + dt2*k2);
      cti = cti_last + dt2*(ct_last+ct[i]);
    }
    /* set very small values to zero */
    if(fabs(ct[i])<1.0e-12) ct[i]=0.0;
    /* prepare to the next loop */
    t_last=t[i]; ci_last=ci[i];
    ct_last=ct[i]; cti_last=cti;
  }
  return(0);
}

◆ simOxygen()

int simOxygen	(	double *	t,
		double *	ca1,
		double *	ca2,
		double *	ca1i,
		double *	ca2i,
		const int	n,
		const double	k1a,
		const double	k2a,
		const double	km,
		const double	k1b,
		const double	k2b,
		const double	vb,
		const double	fa,
		double *	scpet,
		double *	sct1,
		double *	sct2,
		double *	sctab,
		double *	sctvb1,
		double *	sctvb2,
		double *	scvb1,
		double *	scvb2,
		const int	verbose )

extern

Simulate tissue and venous blood TACs using dual-input compartment model for [O-15]O2 (one tissue compartment for [O-15]O2, and another tissue compartment for its metabolite [O-15]H2O).

The units of rate constants must be related to the time unit of the data; 1/min and min, or 1/sec and sec.

Returns: Function returns 0 when successful, else a value >= 1.

Author: Vesa Oikonen

See also: simC3s, simC3p, simC3vs, simC3vp, simC2l, simC2vl, simC3vpKLoss, simRTCM, simSRTM, simTRTM, simHuangmet, simTPCMOD0009c, simMBF, simC1, simC3DIvs, simC4DIvp, simC4DIvs, simDispersion

Parameters

t	Array of sample times
ca1	Array of arterial blood activities of tracer1 ([O-15]O2)
ca2	Array of arterial blood activities of tracer2 ([O-15]H2O)
ca1i	Array of AUC 0-t of arterial tracer1 activities; NULL if not available
ca2i	Array of AUC 0-t of arterial tracer2 activities; NULL if not available
n	Nr of samples (array lengths)
k1a	Rate constant of the model for tracer1 (from blood to C1)
k2a	Rate constant of the model for tracer1 (from C1 to blood)
km	Rate constant of the model (from tracer1 in C1 to tracer2 in C2)
k1b	Rate constant of the model for tracer2 (from blood to C2)
k2b	Rate constant of the model for tracer2 (from C2 to blood)
vb	Vascular volume fraction [0-1)
fa	Arterial fraction of vascular volume [0-1]
scpet	Pointer for TTAC array to be simulated; allocate in the calling program or set to NULL if not needed
sct1	Simulated TAC of tracer1 in tissue; allocate in the calling program or set to NULL if not needed
sct2	Simulated TAC of tracer2 in tissue; allocate in the calling program or set to NULL if not needed
sctab	Total arterial contribution to PET TTAC; allocate in the calling program or set to NULL if not needed
sctvb1	Venous tracer1 contribution to PET TAC; allocate in the calling program or set to NULL if not needed
sctvb2	Venous tarcer1 contribution to PET TAC; allocate in the calling program or set to NULL if not needed
scvb1	Venous BTAC of tracer1; allocate in the calling program or set to NULL if not needed
scvb2	Venous BTAC of tracer2; allocate in the calling program or set to NULL if not needed
verbose	Verbose level; if zero, then nothing is printed into stdout or stderr

Definition at line 1978 of file simulate.c.

  {
  if(verbose>0) {
    printf("simOxygen()\n");
    if(verbose>1) {
      printf("  k1a := %g\n", k1a);
      printf("  k2a := %g\n", k2a);
      printf("  km := %g\n", km);
      printf("  k1b := %g\n", k1b);
      printf("  k2b := %g\n", k2b);
      printf("  vb := %g\n", vb);
      printf("  fa := %g\n", fa);
      printf("  n := %d\n", n);
    }
  }
 
  /* Check for data */
  if(n<2) return 1;
  if(t==NULL) return 2;
  if(ca1==NULL || ca2==NULL) return 3;
 
  /* Check parameters */
  if(k1a<0.0 || k1b<0.0 || k2a<0.0 || k2b<0.0) return(4);
  if(vb<0.0 || vb>=1.0) return(5);
  if(fa<0.0 || fa>1.0) return(6);
  double va=fa*vb;       // arterial volume fraction in tissue
  double vv=(1.0-fa)*vb; // venous volume fraction in tissue
 
  /* Set initial condition */
  double t_last=0.0; // previous sample time
  if(t[0]<t_last) t_last=t[0];
  /* Concentrations, integrals, and previous values are zero */
  double cba1i=0.0, cba1_last=0.0;
  double cba2i=0.0, cba2_last=0.0;
  double ct1=0.0, ct1_last=0.0, ct1i=0.0, ct1i_last=0.0;
  double ct2=0.0, ct2_last=0.0, ct2i=0.0, ct2i_last=0.0;
  double cvb1=0.0, cvb2=0.0;
 
  /* Calculate curves */
  double p, q;
  double dt2; // delta t / 2
  for(int i=0; i<n; i++) {
    dt2=0.5*(t[i]-t_last);
    if(dt2>0.0) {
      /* arterial integrals */
      if(ca1i!=NULL) cba1i=ca1i[i]; else cba1i+=(ca1[i]+cba1_last)*dt2;
      if(ca2i!=NULL) cba2i=ca2i[i]; else cba2i+=(ca2[i]+cba2_last)*dt2;
      /* partial results */
      p=ct1i_last+dt2*ct1_last;
      q=ct2i_last+dt2*ct2_last;
      /* 1st tissue compartment and its integral */
      ct1 = (k1a*cba1i - (k2a+km)*p) / (1.0 + dt2*(k2a+km));
      ct1i = ct1i_last + dt2*(ct1_last+ct1);
      /* 2nd tissue compartment and its integral */
      ct2 = (km*ct1i + k1b*cba2i - k2b*q) / (1.0 + dt2*k2b);
      ct2i = ct2i_last + dt2*(ct2_last+ct2);
    }
    /* Venous BTACs */
    if(k1a>0.0 && k2a>0.0) cvb1=ct1/(k1a/k2a);
    else if(k2a>0.0) cvb1=0.0; else cvb1=ca1[i];
    if(k1b>0.0 && k2b>0.0) cvb2=ct2/(k1b/k2b);
    else if(k2b>0.0) cvb2=0.0; else cvb2=ca2[i];
    /* copy values to argument arrays; set very small values to zero */
    if(scpet!=NULL) {
      scpet[i]= va*(ca1[i]+ca2[i]) + vv*(cvb1+cvb2) + (1.0-vb)*(ct1+ct2);
      if(fabs(scpet[i])<1.0e-12) scpet[i]=0.0;
    }
    if(sct1!=NULL) {
      sct1[i]=(1.0-vb)*ct1; 
      if(fabs(sct1[i])<1.0e-12) sct1[i]=0.0;
    }
    if(sct2!=NULL) {
      sct2[i]=(1.0-vb)*ct2; 
      if(fabs(sct2[i])<1.0e-12) sct2[i]=0.0;
    }
    if(sctab!=NULL) {
      sctab[i]=va*(ca1[i]+ca2[i]); 
      if(fabs(sctab[i])<1.0e-12) sctab[i]=0.0;
    }
    if(sctvb1!=NULL) {
      sctvb1[i]=vv*cvb1; 
      if(fabs(sctvb1[i])<1.0e-12) sctvb1[i]=0.0;
    }
    if(sctvb2!=NULL) {
      sctvb2[i]=vv*cvb2; 
      if(fabs(sctvb2[i])<1.0e-12) sctvb2[i]=0.0;
    }
    if(scvb1!=NULL) scvb1[i]=cvb1;
    if(scvb2!=NULL) scvb2[i]=cvb2;
    /* prepare for the next loop */
    t_last=t[i]; 
    cba1_last=ca1[i]; cba2_last=ca2[i];
    ct1_last=ct1; ct1i_last=ct1i;
    ct2_last=ct2; ct2i_last=ct2i;
  } // next sample
 
  if(verbose>2) {
    printf("AUC 0-%g:\n", t_last);
    printf(" cba1i := %g\n", cba1i);
    printf(" cba2i := %g\n", cba2i);
    printf(" ct1i := %g\n", ct1i_last);
    printf(" ct2i := %g\n", ct2i_last);
  }
 
  return 0;
}

◆ simplex()

double simplex	(	double(*	_fun )(double *),
		int	parNr,
		double *	par,
		double *	delta,
		double	maxerr,
		int	maxiter,
		int	verbose )

extern

Downhill simplex function minimization routine.

Note that if any constraints are required for the parameter values they must be set in the function.

Returns: Function returns the least calculated value of func.

See also: powell, tgo, bobyqa, nlopt1D

Parameters

_fun	Pointer to the function to be minimized. It must be defined in main program as: double func(double *p); where p is the parameter array.
parNr	The number of unknown parameters
par	This double array contains the minimized parameters. Initial values must be set.
delta	This double array contains the initial changes to parameters. To fix a parameter, set the corresponding delta to 0.
maxerr	Maximal error allowed (stopping rule #1)
maxiter	Maximal nr of iterations allowed (stopping rule #2)
verbose	Verbose level; if zero, then only warnings are printed into stderr

Definition at line 27 of file simplex.c.

  {
  int         i, j, Meas, it;
  double      Max, Min, Max2, Min2, LastChi;
  int         NextBest, New2, Best;
 
 
  if(verbose>0) printf("%s(func, %d, p[], delta[], %g, %d)\n", __func__, parNr, maxerr, maxiter);
  /* SetUp */
  _simplexFunc=_fun;
  _simplexParNr=parNr; it=0; NewPnt=_simplexParNr+1;
  for(i=0; i<_simplexParNr; i++) for(Meas=0; Meas<_simplexParNr+3; Meas++) _simplexP[Meas][i]=par[i];
  if(verbose>1) {
    for(int i=0; i<_simplexParNr; i++) printf("%12g   %12g\n", _simplexP[0][i], delta[i]);
    printf("ChiSqr of guesses: %f\n", (*_simplexFunc)(_simplexP[0]));
  }
  New2=NewPnt+1;
  for(Meas=0; Meas<=_simplexParNr; Meas++) {
    it++;
    _simplexR[Meas] = (*_simplexFunc)(_simplexP[Meas]);
    for (i=0; i<_simplexParNr; i++) {
      if(i==Meas) delta[i]= -delta[i];
      _simplexP[Meas+1][i] = _simplexP[Meas][i] + delta[i];
    }
  }
 
  /* Simplex minimization */
  LastChi = 1.0E30; NextBest=Best=0;
  do {
    for(j=0; j<100; j++) {
      /* Find the max and min response measured */
      Max=0.; Min=1.0E30;
      for (i=0; i<=_simplexParNr; i++) {
        if(_simplexR[i] > Max) {Max=_simplexR[i]; Worst=i;}
        if(_simplexR[i] < Min) {Min=_simplexR[i]; Best=i; }
      }
      /* Find 2nd best and 2nd worst, too */
      Max2=0.; Min2=1.0E30;
      for (i=0; i<=_simplexParNr; i++) {
        if((_simplexR[i] > Max2) && (_simplexR[i] < Max)) Max2=_simplexR[i];
        if((_simplexR[i] < Min2) && (_simplexR[i] > Min)) {
          Min2=_simplexR[i]; NextBest=i;}
      }
      /* Calculate centroid of all measurements */
      for(i=0; i<_simplexParNr; i++) {
        _simplexC[i]=0.;
        for(Meas=0; Meas<=_simplexParNr; Meas++)
          if(Meas!=Worst) _simplexC[i]+=_simplexP[Meas][i];
        _simplexC[i]/=(double)_simplexParNr;
      }
      /* Measure the response at the point reflected away from worst */
      for(i=0; i<_simplexParNr; i++)
        _simplexP[NewPnt][i] = 2.*_simplexC[i] - _simplexP[Worst][i];
      _simplexR[NewPnt]= (*_simplexFunc)(_simplexP[NewPnt]);
      it++;
      /* If this one is better than previous best, then expand in this
          direction */
      if(_simplexR[NewPnt] < _simplexR[Best]) {
        _simplexGenNew(New2,2.0); it++;
      } else {
        /* If this one is worse than previous worst, measure point halfway
           between worst and centroid */
        if(_simplexR[NewPnt] > _simplexR[Worst]) {
          _simplexGenNew(New2,-0.5); it++;
        } else {
          /* If newest response is worse than next best point
             but better than worst, measure response halfway
             between centroid and newest point */
          if((_simplexR[NextBest] < _simplexR[NewPnt]) &&
             (_simplexR[NewPnt] < _simplexR[Worst])) {
            _simplexGenNew(New2,0.5); it++;
          } else {
            /* If none of the above, keep the new point as best */
            for(i=0; i<_simplexParNr; i++)
              _simplexP[Worst][i] = _simplexP[NewPnt][i];
            _simplexR[Worst] = _simplexR[NewPnt];
          }
        }
      }
    }
    if(verbose>1) printf(" it=%i; ChiSqr=%f\n", it, _simplexR[Best]);
    if(verbose>2)
      for(i=0; i<_simplexParNr; i++) printf("     %12g\n", _simplexP[Best][i]);
    /* Check if fitting is not proceeding */
    if(_simplexR[Best] == LastChi) {
      for(i=0; i<_simplexParNr; i++) par[i]=_simplexP[Best][i];
      return _simplexR[Best];
    }
    LastChi = _simplexR[Best];
  } while ((_simplexR[Best]>maxerr) && (it<=maxiter));
 
  for(i=0; i<_simplexParNr; i++) par[i]=_simplexP[Best][i];
  return _simplexR[Best];
}

◆ simRTCM()

int simRTCM	(	double *	t,
		double *	cr,
		int	nr,
		double	R1,
		double	k2,
		double	k3,
		double	k4,
		double *	ct,
		double *	cta,
		double *	ctb )

extern

Simulates tissue TAC using reference tissue compartment model (original) and reference region TAC, at reference region TAC times.

Memory for ct must be allocated in the calling program. To retrieve the separate tissue compartment TACs, pointer to allocated memory for cf and/or cb can be given; if compartmental TACs are not required, NULL pointer can be given instead.

The units of rate constants must be related to the time unit; 1/min and min, or 1/sec and sec.

Returns: Function returns 0 when successful, else a value >= 1.

See also: simC3s, simC3p, simC3vs, simC3vp, simC2l, simC2vl, simC3vpKLoss, simSRTM, simTRTM, simHuangmet, simTPCMOD0009c, simMBF, simC1, simC3DIvs, simC4DIvp, simC4DIvs, simDispersion, simOxygen

Parameters

t	Array of time values
cr	Reference region activities
nr	Number of values in TACs
R1	Ratio K1/K1'
k2	Rate constant of the model
k3	Rate constant of the model
k4	Rate constant of the model
ct	Pointer for TAC array to be simulated; must be allocated
cta	Pointer for 1st compartment TAC to be simulated, or NULL
ctb	Pointer for 2nd compartment TAC to be simulated, or NULL

Definition at line 835 of file simulate.c.

  {
  int i;
  double f, b, w, dt2;
  double cri, cr_last, t_last;
  double cf, cf_last, cb, cb_last;
  double cfi, cfi_last, cbi, cbi_last;
 
 
  /* Check for data */
  if(nr<2) return 1;
  if(ct==NULL) return 2;
 
  /* Calculate curves */
  t_last=0.0; if(t[0]<t_last) t_last=t[0];
  cri=cr_last=0.0; cf_last=cb_last=cfi_last=cbi_last=cf=cb=cfi=cbi=0.0;
  for(i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last);
    /* calculate values */
    if(dt2<0.0) {
      return 5;
    } else if(dt2>0.0) {
      /* reference integral */
      cri+=(cr[i]+cr_last)*dt2;
      /* partial results */
      f=cfi_last+dt2*cf_last;
      b=cbi_last+dt2*cb_last;
      w=k2 + k3 + k2*k4*dt2;
      /* 1st tissue compartment and its integral */
      cf = ( (1.0 + k4*dt2)*(R1*cr[i] + k2*cri) + k4*b - w*f ) /
           ( 1.0 + dt2*(w+k4) );
      cfi = cfi_last + dt2*(cf_last+cf);
      /* 2nd tissue compartment and its integral */
      cb = (k3*cfi - k4*b) / (1.0 + k4*dt2);
      cbi = cbi_last + dt2*(cb_last+cb);
    }
    /* copy values to argument arrays; set very small values to zero */
    ct[i]=cf+cb; if(fabs(ct[i])<1.0e-12) ct[i]=0.0;
    if(cta!=NULL) {cta[i]=cf; if(fabs(cta[i])<1.0e-12) cta[i]=0.0;}
    if(ctb!=NULL) {ctb[i]=cb; if(fabs(ctb[i])<1.0e-12) ctb[i]=0.0;}
    /* prepare to the next loop */
    t_last=t[i]; cr_last=cr[i];
    cf_last=cf; cfi_last=cfi;
    cb_last=cb; cbi_last=cbi;
  }
 
  return 0;
}

◆ simSRTM()

int simSRTM	(	double *	t,
		double *	cr,
		int	nr,
		double	R1,
		double	k2,
		double	BP,
		double *	ct )

extern

Simulates tissue TAC using reference tissue compartment model (simplified) and reference region TAC, at reference region TAC times.

Memory for ct must be allocated in the calling program.

The units of rate constants must be related to the time unit; 1/min and min, or 1/sec and sec.

Returns: Function returns 0 when successful, else a value >= 1.

See also: simC3s, simC3p, simC3vs, simC3vp, simC2l, simC2vl, simC3vpKLoss, simRTCM, simTRTM, simHuangmet, simTPCMOD0009c, simMBF, simC1, simC3DIvs, simC4DIvp, simC4DIvs, simDispersion, simOxygen

Parameters

t	Array of time values
cr	Reference region activities
nr	Number of values in TACs
R1	Ratio K1/K1'
k2	Rate constant of the model
BP	Binding potential
ct	Pointer for TAC array to be simulated; must be allocated

Definition at line 919 of file simulate.c.

  {
  int i;
  double dt2;
  double cri, cr_last, t_last;
  double ct_last, cti, cti_last;
 
 
  /* Check for data */
  if(nr<2) return 1;
  if(ct==NULL) return 2;
 
  /* Calculate curves */
  t_last=0.0; if(t[0]<t_last) t_last=t[0];
  cri=cr_last=0.0; cti=ct_last=cti_last=0.0;
  for(i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last);
    /* calculate values */
    if(dt2<0.0) {
      return 5;
    } else if(dt2>0.0) {
      /* reference integral */
      cri+=(cr[i]+cr_last)*dt2;
      /* Tissue compartment and its integral */
      ct[i] = ( R1*cr[i] + k2*cri - (k2/(1.0+BP))*(cti_last+dt2*ct_last) ) /
              ( 1.0 + dt2*(k2/(1.0+BP)) );
      cti = cti_last + dt2*(ct_last+ct[i]);
    }
    /* set invalid or very small values to zero */
    if(!(fabs(ct[i])>=1.0e-12)) ct[i]=0.0;
    /* prepare to the next loop */
    t_last=t[i]; cr_last=cr[i];
    ct_last=ct[i]; cti_last=cti;
  }
 
  return 0;
}

◆ simTPCMOD0009c()

int simTPCMOD0009c	(	double *	t,
		double *	ctot,
		int	nr,
		double	km,
		double	k1m,
		double	k2m,
		double	k3m,
		double	k4m,
		double *	ca,
		double *	cm )

extern

Simulate parent tracer TAC using plasma metabolite model TPCMOD0009C, https://www.turkupetcentre.net/reports/tpcmod0009_app_c.pdf

Returns: Returns 0 if successful.

See also: simC3s, simC3p, simC3vs, simC3vp, simC2l, simC2vl, simC3vpKLoss, simRTCM, simSRTM, simTRTM, simHuangmet, simMBF, simC1, simC3DIvs, simC4DIvp, simC4DIvs, simDispersion, simOxygen

Parameters

t	Sample times
ctot	Total plasma TAC
nr	Sample number
km	km
k1m	k1m
k2m	k2m
k3m	k3m
k4m	k4m
ca	Pointer to array where parent tracer TAC will be written; NULL, if not needed.
cm	Pointer to array where metabolized tracer TAC will be written; NULL, if not needed.

Definition at line 1165 of file simulate.c.

  {
  int i;
  double t_last, dt2;
  double ctoti, ctot_last;
  double a, b;
  double ct1m, ct1mi, ct1m_last, ct1mi_last;
  double ct2m, ct2mi, ct2m_last, ct2mi_last;
  double cpm, cpmi, cpm_last, cpmi_last;
  
 
  /* Check for data */
  if(nr<2) return 1;
  if(t==NULL || ctot==NULL || ca==NULL) return 2;
 
  /* Calculate curves */
  t_last=0.0; if(t[0]<t_last) t_last=t[0]; 
  ctoti=ctot_last=0.0;
  ct1m_last=ct1mi_last=ct2m_last=ct2mi_last=cpm_last=cpmi_last=0.0;
  //ct1=ct2=ct3=ct1i=ct2i=ct3i=0.0;
  for(i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last);
    /* calculate values */
    if(dt2<0.0) {
      return 5;
    } else {
      /* arterial integral */
      ctoti+=(ctot[i]+ctot_last)*dt2;
      /* partial results */
      a=k4m/(1.0+k4m*dt2);
      b=(k1m-km)/(1.0+dt2*(k1m+k3m-k3m*a*dt2));
      /* 1st tissue compartment and its integral */
      ct1m = (km*ctoti - k2m*(1.0-dt2*b)*(ct1mi_last+dt2*ct1m_last)
             + b*(cpmi_last+dt2*cpm_last) + a*b*dt2*(ct2mi_last+dt2*ct2m_last)
       ) / (1.0 + dt2*k2m*(1.0-dt2*b));
      ct1mi = ct1mi_last + dt2*(ct1m_last+ct1m);
      /* Metabolite plasma compartment and its integral */
      cpm = (k2m*ct1mi + a*(ct2mi_last+dt2*ct2m_last)
             - (k1m+k3m-k3m*dt2*a)*(cpmi_last+dt2*cpm_last)
            ) / (1.0 + dt2*(k1m+k3m-k3m*dt2*a));
      cpmi = cpmi_last + dt2*(cpm_last+cpm);
      /* 2nd tissue compartment and its integral */
      ct2m = (k3m*cpmi - k4m*(ct2mi_last+dt2*ct2m_last)) / (1.0 + dt2*k4m);
      ct2mi = ct2mi_last + dt2*(ct2m_last+ct2m);
    }
    /* copy values to argument arrays; set very small values to zero */
    if(ca!=NULL) {ca[i]=ctot[i]-cpm; if(fabs(ca[i])<1.0e-12) ca[i]=0.0;}
    if(cm!=NULL) {cm[i]=cpm; if(fabs(cm[i])<1.0e-12) cm[i]=0.0;}
    /* prepare to the next loop */
    t_last=t[i]; ctot_last=ctot[i];
    ct1m_last=ct1m; ct1mi_last=ct1mi;
    ct2m_last=ct2m; ct2mi_last=ct2mi;
    cpm_last=cpm; cpmi_last=cpmi;
  } // next sample
  return 0;
}

◆ simTRTM()

int simTRTM	(	double *	t,
		double *	cr,
		int	nr,
		double	R1,
		double	k2,
		double	k3,
		double *	ct )

extern

Simulates tissue TAC using reference tissue compartment model (transport limited in ref region) and reference region TAC, at reference region TAC times.

Memory for ct must be allocated in the calling program.

The units of rate constants must be related to the time unit; 1/min and min, or 1/sec and sec.

Returns: Function returns 0 when successful, else a value >= 1.

See also: simC3s, simC3p, simC3vs, simC3vp, simC2l, simC2vl, simC3vpKLoss, simRTCM, simSRTM, simHuangmet, simTPCMOD0009c, simMBF, simC1, simC3DIvs, simC4DIvp, simC4DIvs, simDispersion, simOxygen

Parameters

t	Array of time values
cr	Reference region activities
nr	Number of values in TACs
R1	Ratio K1/K1'
k2	Rate constant of the model
k3	Rate constant of the model
ct	Pointer for TAC array to be simulated; must be allocated

Definition at line 986 of file simulate.c.

  {
  int i;
  double dt2;
  double cri, cr_last, t_last;
  double ct_last, cti, cti_last;
 
 
  /* Check for data */
  if(nr<2) return 1;
  if(ct==NULL) return 2;
 
  /* Calculate curves */
  t_last=0.0; if(t[0]<t_last) t_last=t[0];
  cri=cr_last=0.0; cti=ct_last=cti_last=0.0;
  for(i=0; i<nr; i++) {
    /* delta time / 2 */
    dt2=0.5*(t[i]-t_last);
    /* calculate values */
    if(dt2<0.0) {
      return 5;
    } else if(dt2>0.0) {
      /* reference integral */
      cri+=(cr[i]+cr_last)*dt2;
      /* Tissue compartment and its integral */
      ct[i] = ( R1*cr[i] + R1*k3*cri - (k2+k3)*(cti_last+dt2*ct_last) ) /
              ( 1.0 + dt2*(k2+k3) );
      cti = cti_last + dt2*(ct_last+ct[i]);
    }
    /* set very small values to zero */
    if(fabs(ct[i])<1.0e-12) ct[i]=0.0;
    /* prepare to the next loop */
    t_last=t[i]; cr_last=cr[i];
    ct_last=ct[i]; cti_last=cti;
  }
 
  return 0;
}

◆ tgo()

int tgo	(	double *	lowlim,
		double *	uplim,
		double(*	objf )(int, double , void ),
		void *	objfData,
		int	dim,
		int	neighNr,
		double *	fmin,
		double *	gmin,
		int	samNr,
		int	tgoNr,
		int	verbose )

extern

Topographical minimization algorithm, that searches the global minimum of a function using clusterization. Calls a local minimization algorithm. Based on an algorithm by Aimo Torn and Sami Viitanen.

Returns: Returns 0, if ok.

See also: tgoRandomParameters, powell, simplex, bobyqa, nlopt1D

Parameters

lowlim	Lower limits for the parameters.
uplim	Upper limits for the parameters.
objf	The object function.
objfData	Data to objective function; NULL if not needed.
dim	Dimension = nr of parameters.
neighNr	Nr of neighbours to investigate; enter large nr relative to samNr (below) if only few local minima are expected.
fmin	Function value at global minimum.
gmin	Global minimum = parameter estimates.
samNr	Nr of points to sample in one iteration; enter larger samNr if nr of iterations (below) is small.
tgoNr	Nr of TGO iterations; enter 0 to use the default; enter 1 to run TGO just once ie TGO instead of iTGO. Large iteration nr is needed if samNr (above) would otherwise require too much memory.
verbose	Verbose level; if zero, then nothing is printed into stdout or stderr.

Definition at line 39 of file tgo.c.

  {
  int i, j, k, l, IDmin, itNr, samplNr, topoNr, badNr, nevals=0, ret;
  double *delta, temp, min, *tempp, deltaf, tol;
  TGO_POINT *sampled_points;
  int fixed_n, fitted_n;
 
 
  if(verbose>0) {printf("in tgo()\n"); fflush(stdout);}
  if(TGO_LOCAL_OPT==1) {
    if(verbose>0) printf("local optimization routine: bobyqa\n");
  } else {
    if(verbose>0) printf("local optimization routine: powell\n");
  }
 
  /* Check input */
  if(lowlim==NULL || uplim==NULL || objf==NULL || dim<=0) return(1);
  if(fmin==NULL || gmin==NULL) return(1);
 
  /* Check if any of parameters is fixed */
  for(i=0, fixed_n=0; i<dim; i++) if(uplim[i]<=lowlim[i]) fixed_n++;
  fitted_n=dim-fixed_n;
  if(verbose>1) printf("%d parameter(s) are fixed.\n", fixed_n);
  if(fitted_n<1) return(1);
 
  /* Continue input checking */
  if(samNr<=0) samplNr=TGO_SAMPLNR; else samplNr=samNr;
  if(samplNr&1) samplNr++; // If number is odd, then add 1
  if(neighNr>samplNr-1) neighNr=samplNr-1; // Make sure "neighNr" isn't too big
  if(tgoNr<1) tgoNr=fitted_n; // Set TGO iteration number, if not set by user
  if(verbose>1) {
    printf("samplNr := %d\n", samplNr);
    printf("neighNr := %d\n", neighNr);
    printf("tgoNr := %d\n", tgoNr);
    if(verbose>2) {
      printf("iTGO limits: [%g,%g]", lowlim[0], uplim[0]);
      for(i=1; i<dim; i++) printf(" [%g,%g]", lowlim[i], uplim[i]);
      printf("\n");
    }
#ifdef OMP_NUM_THREADS
    printf("OMP_NUM_THREADS := %d\n", OMP_NUM_THREADS);
#endif
    fflush(stdout);
  }
 
  /* Allocate memory */
  sampled_points=(TGO_POINT*)calloc(samplNr, sizeof(TGO_POINT));
  if(sampled_points==NULL) return(2);
  for(i=0; i<samplNr; i++) {
    sampled_points[i].topomin=0;
    sampled_points[i].fvalue=0.0;
  }
  delta=(double*)malloc(dim*sizeof(double));
  tempp=(double*)malloc(samplNr*sizeof(double));
  if(delta==NULL || tempp==NULL) {free(sampled_points); return(2);}
 
  /* Set seed for random number generator */
  drandSeed(1);
 
  /*
   *  Iterative TGO, or non-iterative if tgoNr==1
   */
  for(l=0; l<tgoNr; l++) {
 
    if(verbose>2) {printf("TGO Loop # %d: \n", l+1); fflush(stdout);}
 
    /*
     *  Sample N points in the feasible region and compute the object function
     *  values for those points which do not already have it.
     */
    if(TGO_SQUARED_TRANSF==1)
      tgoRandomParametersST(sampled_points, dim, samplNr, lowlim, uplim);
    else
      tgoRandomParameters(sampled_points, dim, samplNr, lowlim, uplim);
    badNr=0;
    for(i=0; i<samplNr; i++) if(sampled_points[i].topomin==0) {
      sampled_points[i].fvalue=objf(dim, sampled_points[i].par, objfData);
      /* If function return value was not normal then we'll try 
         later (twice) with new guesses */
      if(!isfinite(sampled_points[i].fvalue)) {
        badNr++;
        if(verbose>5) {
          printf("this point did not give normal return value:\n");
          for(k=0; k<dim; k++) printf("  %10.2e", sampled_points[i].par[k]);
          printf("\n");
        }
      }
    }
    if(verbose>4 && badNr>0) printf("Nr of bad points: %d\n", badNr);
    /* New guesses for bad points */
    k=0; while(k<2 && badNr>0) {
      badNr=0; k++;
      for(i=0; i<samplNr; i++) 
        if(sampled_points[i].topomin==0 && !isfinite(sampled_points[i].fvalue)) {
          /* sample a new random point */
          if(TGO_SQUARED_TRANSF==1)
            tgoRandomParametersST(sampled_points+i, dim, 1, lowlim, uplim);
          else
            tgoRandomParameters(sampled_points+i, dim, 1, lowlim, uplim);
          /* compute the object function value for that */
          sampled_points[i].fvalue=objf(dim, sampled_points[i].par, objfData);
          if(!isfinite(sampled_points[i].fvalue)) badNr++;
        }
      if(verbose>4 && badNr>0) printf("Nr of bad points: %d\n", badNr);
    }
    /* Print sampled points */
    if(verbose>6) {
      printf("Sampled points:\n");
      for(j=0; j<samplNr; j++) {
        printf("%d", j+1);
        for(i=0; i<dim; i++) printf(" %e ", sampled_points[j].par[i]);
        printf("=>%e\n", sampled_points[j].fvalue);
      }
       fflush(stdout);
    }
    /* Object functions values must be good for at least NeigNr points */
    if(l==0 && (samplNr-badNr)<=neighNr) {
      if(verbose>0) {
        printf("Error in TGO: invalid function return value from all points.\n");
        fflush(stdout);
      }
      free(sampled_points); free(delta); free(tempp);
      return(3);
    }
 
    /*
     *  For each point i find out if it is a "topografic minimum" 
     *  = better than k neighbour points
     */
    /* Save the distances to point i in the vector tempp */
    /* Find the closest neighbour from {x1,..,xn}/{xi} k times, */
    /* extracting it after comparing */
    for(i=0, topoNr=0; i<samplNr; i++) {
      sampled_points[i].topomin=0;
      /* If function value is not ok, then point cannot be minimum */
      if(!isfinite(sampled_points[i].fvalue)) continue;
 
      /* Compute the (scaled) distances */
      for(j=0; j<samplNr; j++) {
        tempp[j]=1.0E+99;
        if(i!=j) {
          for(k=0, tempp[j]=0.0; k<dim; k++) {
            deltaf=uplim[k]-lowlim[k]; if(deltaf<=0.0) continue;
            temp=sampled_points[i].par[k]-sampled_points[j].par[k];
            if(deltaf>1.0E-20) temp/=deltaf;
            if(isfinite(temp)) tempp[j] += temp*temp;
          }
          /* Distance is computed as square root, but it does not affect
             the order of distances, and sqrt() is relatively slow */
          /*tempp=sqrt(tempp);*/
        }
      }
 
      /* Find the closest neighbours */
      /* At the same time, collect info for max fvalue of the neighbours
         and for the mean distance to every direction */
      for(k=0; k<dim; k++) sampled_points[i].delta[k]=0.0; // Init delta array 
      sampled_points[i].fvalrange=sampled_points[i].fvalue;
      for(j=0; j<neighNr; j++) {
        min=tempp[0]; IDmin=0;
        for(k=1; k<samplNr; k++) {if(tempp[k]<min) {min=tempp[k]; IDmin=k;}}
        tempp[IDmin]=1e+99; // so that this will not be used again
        /* If point i is worse than any of the closest neighbours, then
           point i is not a topographic minimum; then stop this loop and go to
           the next point i+1 */    
        if(isfinite(sampled_points[IDmin].fvalue) &&
          sampled_points[IDmin].fvalue<sampled_points[i].fvalue) break;
 
        /* Sum the distances to every direction for delta calculation */
        for(k=0; k<dim; k++)
          sampled_points[i].delta[k]+=
            fabs(sampled_points[i].par[k]-sampled_points[IDmin].par[k]); 
        if(isfinite(sampled_points[IDmin].fvalue) &&
           sampled_points[IDmin].fvalue>sampled_points[i].fvalrange)
          sampled_points[i].fvalrange=sampled_points[IDmin].fvalue;
      } // next neighbour point
 
      /* If this was NOT a topographic minimum, then continue with the next i */
      if(j!=neighNr) continue;
      /* otherwise mark this as topografic minimum (TM) */
      sampled_points[i].topomin=1; topoNr++;
 
      /* Compute the mean distance of neighbours from the TM in each
         dimension; local optimization delta will be based on that */
      for(k=0; k<dim; k++) sampled_points[i].delta[k]/=(double)neighNr;
      /* Compute the max range in fvalues */
      sampled_points[i].fvalrange-=sampled_points[i].fvalue;
 
    } /* next sample */
    if(verbose>2) {printf("  %d topographical minima\n", topoNr); fflush(stdout);}
 
    /* Check that if no topographical minimum was found, then set the smallest */
    /* minimum as 'topographical' minimum */
    if(topoNr==0) {
      min=sampled_points[0].fvalue; IDmin=0;
      for(k=1; k<samplNr; k++)
        if(!isfinite(min) || sampled_points[k].fvalue<min) {
          min=sampled_points[k].fvalue; IDmin=k;}
      sampled_points[IDmin].topomin=1;
      for(k=0; k<dim; k++)
        sampled_points[IDmin].delta[k]=0.1*(uplim[k]-lowlim[k]);
      sampled_points[i].fvalrange+=100.0*fabs(sampled_points[i].fvalue);
      if(verbose>2) {
        printf("  ; therefore minimum was set to point %d at %e\n", 
          IDmin, sampled_points[IDmin].fvalue);
         fflush(stdout);
      }
      topoNr=1;
    }
    if(verbose>3) { // Print the best TM 
      for(i=0, min=1e+99, IDmin=0; i<samplNr; i++)
        if(sampled_points[i].topomin==1) {
          if(isfinite(sampled_points[i].fvalue) && sampled_points[i].fvalue<min)
          {
            min=sampled_points[i].fvalue; IDmin=i;
          }
        }
      printf("  best topographical min:"); fflush(stdout);
      for(k=0; k<dim; k++) printf(" %e", sampled_points[IDmin].par[k]);
      printf(" => %e\n", sampled_points[IDmin].fvalue); fflush(stdout);
    }
 
    if(TGO_LOCAL_INSIDE==1) {
      /* Local optimization for each TM */
      if(verbose>2) printf("local optimization for each TM\n");
      for(i=0; i<samplNr; i++) if(sampled_points[i].topomin==1) {
        //tol=sampled_points[IDmin].fvalue*1.0E-02;
        //for(k=0; k<dim; k++) delta[k]=sampled_points[i].delta[k];
        for(k=0; k<dim; k++) delta[k]=0.1*sampled_points[i].delta[k];
        if(verbose>3) printf("point %d: original fvalue=%.2e\n",
                             i+1, sampled_points[i].fvalue);
        if(TGO_LOCAL_OPT==1) {
          tol=1.0E-08; //tol=1.0E-09;
          ret=bobyqa(dim, 0, sampled_points[i].par, lowlim, uplim, delta, 0.0, 1.0E-03, 
                     1.0E-10, tol, tol, 2000, &nevals, 
                     &sampled_points[i].fvalue, objf, objfData, NULL, verbose-3);
          if(ret<0 && verbose>0) {
            printf("bobyqa error %d\n", ret); fflush(stdout);}
          if(ret<0 && ret!=BOBYQA_ROUNDOFF_LIMITED) {
            free(sampled_points); free(delta); free(tempp);
            return(5);
          }
          if(verbose>3) {
            printf("  local opt => %.2e (nr of evals=%d)\n",
                   sampled_points[i].fvalue, nevals);
            fflush(stdout);
          }
        } else {
          itNr=40; //itNr=100;
          tol=1.0E-03; //tol=2.0E-03; //tol=1.0E-09;
          POWELL_LINMIN_MAXIT=30; // 100;
          ret=powell(sampled_points[i].par, delta, dim, tol, &itNr,
                     &sampled_points[i].fvalue, objf, objfData, verbose-3);
          if(ret>1 && verbose>0) {printf("powell error %d\n", ret); fflush(stdout);}
          if(ret>3) {
            free(sampled_points); free(delta); free(tempp);
            return(5);
          }
          if(verbose>3) {
            printf("  local opt => %.2e (itNr=%d)\n",
                   sampled_points[i].fvalue, itNr);
            fflush(stdout);
          }
        }
      }
    } // end of local optimizations inside this iTGO loop
 
  } /* end of tgo iterations */
 
  if(verbose>1) { // Print the final topographical minima
    if(verbose>2) printf("Final topographical minima and deltas\n");
    else printf("Final topographical minima\n");
    for(i=0; i<samplNr; i++) if(sampled_points[i].topomin==1) {
      k=0; printf("  %3d: %.2e", i, sampled_points[i].par[k]);
      for(k=1; k<dim; k++) printf(" %.2e", sampled_points[i].par[k]);
      printf(" => %.2e\n", sampled_points[i].fvalue); fflush(stdout);
      if(verbose>2) {
        k=0; printf("       %.2e", sampled_points[i].delta[k]);
        for(k=1; k<dim; k++) printf(" %.2e", sampled_points[i].delta[k]);
        printf(" => %.2e\n", sampled_points[i].fvalrange); fflush(stdout);
      }
    }
  }
 
  if(TGO_LOCAL_INSIDE==0) { 
    /*
     *  Use the points in TM as starting points for local optimization;
     *  this first local opt is done only if not done already inside iTGO 
     */
    if(verbose>2) {printf("Topographic minima:\n"); fflush(stdout);}
    for(i=0; i<samplNr; i++) if(sampled_points[i].topomin==1) {
      //tol=sampled_points[IDmin].fvalue*1.0E-02;
      for(k=0; k<dim; k++) {
        if(verbose>2) {printf("%e ", sampled_points[i].par[k]); fflush(stdout);}
        delta[k]=0.1*sampled_points[i].delta[k];
      }
      if(verbose>3) {printf("=> %e ", sampled_points[i].fvalue); fflush(stdout);}
      if(TGO_LOCAL_OPT==1) {
        tol=1.0E-09; //tol=1.0E-09;
        ret=bobyqa(dim, 0, sampled_points[i].par, lowlim, uplim, delta, 0.0, 1.0E-03, 
                   1.0E-10, tol, tol, 2000, &nevals, 
                   &sampled_points[i].fvalue, objf, objfData, NULL, verbose-3);
        if(ret<0 && verbose>0) {
          printf("bobyqa error %d\n", ret); fflush(stdout);}
        if(ret<0 && ret!=BOBYQA_ROUNDOFF_LIMITED) {
          free(sampled_points); free(delta); free(tempp);
          return(5);
        }
        if(verbose>2) {
          printf("local opt 1st round point %d => %e (nr of evals=%d)\n",
            i+1, sampled_points[i].fvalue, nevals);
          fflush(stdout);
        }
      } else {
        itNr=50; //itNr=100; 
        tol=1.0E-03; //tol=1.0E-04;
        POWELL_LINMIN_MAXIT=60; // POWELL_LINMIN_MAXIT=50; // 100;
        ret=powell(sampled_points[i].par, delta, dim, tol, &itNr,
                 &sampled_points[i].fvalue, objf, objfData, verbose-3);
        if(ret>1 && verbose>0) {printf("powell error %d\n", ret); fflush(stdout);}
        if(ret>3) {
          if(verbose>0) {printf("powell error %d\n", ret); fflush(stdout);}
          free(sampled_points); free(delta); free(tempp);
          return(5);
        }
        if(verbose>2) {
          printf("=> %e (itNr=%d) ", sampled_points[i].fvalue, itNr);
          fflush(stdout);
        }
      }
    }
    if(verbose>0) { // Print the topographical minima after local optimization
      printf("Final topographical minima after local optimization\n");
      for(i=0; i<samplNr; i++) if(sampled_points[i].topomin==1) {
        k=0; printf("  %3d: %.2e", i, sampled_points[i].par[k]);
        for(k=1; k<dim; k++) printf(" %.2e", sampled_points[i].par[k]);
        printf(" => %.2e\n", sampled_points[i].fvalue); fflush(stdout);
      }
    }
  }
 
  /* Rerun of local optimization with smaller tolerance and delta */
  for(i=0; i<samplNr; i++) if(sampled_points[i].topomin==1) {
    //tol=sampled_points[IDmin].fvalue*1.0E-04;
    for(k=0; k<dim; k++) delta[k]=0.1*sampled_points[i].delta[k];
    if(TGO_LOCAL_OPT==1) {
      tol=1.0E-10;
      ret=bobyqa(dim, 0, sampled_points[i].par, lowlim, uplim, delta, 0.0, 1.0E-05, 
                 1.0E-10, tol, tol, 1000, &nevals, 
                 &sampled_points[i].fvalue, objf, objfData, NULL, verbose-3);
      if(ret<0 && verbose>0) {
        printf("bobyqa error %d\n", ret); fflush(stdout);}
      if(ret<0 && ret!=BOBYQA_ROUNDOFF_LIMITED) {
        free(sampled_points); free(delta); free(tempp);
        return(5);
      }
      if(verbose>2) {
        printf("local opt 2nd round point %d => %e (nr of evals=%d)\n",
          i+1, sampled_points[i].fvalue, nevals);
        fflush(stdout);
      }
    } else {
      itNr=40; /*itNr=100;*/
      tol=1.0E-04; //tol=1.0E-03; //tol=1.0E-08;
      POWELL_LINMIN_MAXIT=60; // 100;
      ret=powell(sampled_points[i].par, delta, dim, tol, &itNr,
               &sampled_points[i].fvalue, objf, objfData, verbose-3);
      if(ret>1 && verbose>0) {printf("powell error %d\n", ret); fflush(stdout);}
      if(ret>3) {
        free(sampled_points); free(delta); free(tempp);
        return(6);
      }
      if(verbose>2) {
        printf("=> %e (itNr=%d)\n", sampled_points[i].fvalue, itNr); 
        fflush(stdout);
      }
    }
  }
 
  if(verbose>0) { // Print the topographical minima after 2nd local optimization
    printf("Final topographical minima after 2nd local optimization\n");
    for(i=0; i<samplNr; i++) if(sampled_points[i].topomin==1) {
      k=0; printf("  %3d: %.2e", i, sampled_points[i].par[k]);
      for(k=1; k<dim; k++) printf(" %.2e", sampled_points[i].par[k]);
      printf(" => %.2e\n", sampled_points[i].fvalue); fflush(stdout);
    }
  }
 
 
  /*
   *  Find the best locally optimized TM and run local opt again from
   *  this point with better accuracy
   */
 
  for(i=0, min=1e+99, IDmin=0; i<samplNr; i++) if(sampled_points[i].topomin==1) {
    if(isfinite(sampled_points[i].fvalue) && sampled_points[i].fvalue<min) {
      min=sampled_points[i].fvalue; IDmin=i;}
  }
  if(verbose>1) {
    printf("Best topographical minimum:");
    for(k=0; k<dim; k++) printf("%e ", sampled_points[IDmin].par[k]);
    printf("-> %e \n", sampled_points[IDmin].fvalue); fflush(stdout); 
  }
 
  /* Rerun of local optimization to the best point */
  deltaf=0.01; tol=5.0E-04; //tol=1.0E-15;
  do {
    for(k=0; k<dim; k++) delta[k]=deltaf*sampled_points[IDmin].delta[k];
    //for(k=0; k<dim; k++) delta[k]=deltaf*(uplim[k]-lowlim[k]);
    if(TGO_LOCAL_OPT==1) {
      ret=bobyqa(dim, 0, sampled_points[IDmin].par, lowlim, uplim, delta, 0.0, tol, // !!! 
                 1.0E-10, tol, tol, 5000, &nevals, 
                 &sampled_points[IDmin].fvalue, objf, objfData, NULL, verbose-3);
      if(ret<0 && verbose>0) {
        printf("bobyqa error %d\n", ret); fflush(stdout);}
      if(ret<0 && ret!=BOBYQA_ROUNDOFF_LIMITED) {
        free(sampled_points); free(delta); free(tempp);
        return(5);
      }
      if(verbose>2) {
        printf("local opt of the best point with tol=%g => %e (nr of evals=%d)\n",
          tol, sampled_points[IDmin].fvalue, nevals);
        fflush(stdout);
      }
      itNr=nevals;
      deltaf*=0.5; tol*=0.1;
    } else {
      itNr=100;
      POWELL_LINMIN_MAXIT=100; // 100;
      ret=powell(sampled_points[IDmin].par, delta, dim, tol, &itNr,
                 &sampled_points[IDmin].fvalue, objf, objfData, verbose-3);
      if(ret>1 && verbose>0) {printf("powell error %d\n", ret); fflush(stdout);}
      if(ret>3) {
        free(sampled_points); free(delta); free(tempp);
        return(7);
      }
      if(verbose>1) {
        printf("  powell once more with %d iteration(s) -> WSS=%e\n",
          itNr, sampled_points[IDmin].fvalue);
          fflush(stdout);
      }
      //deltaf*=0.5; tol*=0.5;
      deltaf*=0.5; tol*=0.25;
    }
  } while(itNr>1 && deltaf>1.0E-05);
//} while(itNr>1 && deltaf>1.0E-15);
 
 
  /* Save best point to gmin */
  for(k=0; k<dim; k++) gmin[k]=sampled_points[IDmin].par[k];
  *fmin=sampled_points[IDmin].fvalue;
  if(!isfinite(sampled_points[IDmin].fvalue)) {
    if(verbose>0) {printf("TGO error: valid minimum value was not reached.\n");
    fflush(stdout);}
    free(sampled_points); free(delta); free(tempp); return(9);
  }
 
  /* Exit TGO */
  free(sampled_points); free(delta); free(tempp);
  if(verbose>0) {printf("out of tgo\n"); fflush(stdout);}
  return(0);
} /* end tgo */

◆ tgoRandomParameters()

void tgoRandomParameters	(	TGO_POINT *	p,
		int	parNr,
		int	sNr,
		double *	low,
		double *	up )

extern

Create randomized parameters for TGO.

See also: tgoRandomParametersST

Parameters

p	Pointer to list of TGO points.
parNr	Nr of parameters in the point.
sNr	Nr of TGO points.
low	List of lower limits for each parameter.
up	List of upper limits for each parameter.

Definition at line 533 of file tgo.c.

  {
  int i, j;
  double dif;
 
  for(j=0; j<parNr; j++) {
    dif=up[j]-low[j];
    if(dif<=0.0) {
      for(i=0; i<sNr; i++) if(p[i].topomin==0) p[i].par[j]=low[j];
    } else {
      for(i=0; i<sNr; i++) if(p[i].topomin==0) {
        p[i].par[j]= drand()*dif + low[j];
      }
    }
  }
}

Referenced by tgo().

◆ tgoRandomParametersST()

void tgoRandomParametersST	(	TGO_POINT *	p,
		int	parNr,
		int	sNr,
		double *	low,
		double *	up )

extern

Create randomized parameters for TGO with square-root transformation, that is, parameter distribution is biased towards low absolute value.

See also: tgoRandomParameters

Parameters

p	Pointer to list of TGO points.
parNr	Nr of parameters in the point.
sNr	Nr of TGO points.
low	List of lower limits for each parameter.
up	List of upper limits for each parameter.

Definition at line 564 of file tgo.c.

  {
  int i, j;
  double v, stl, stu, dif;
 
  for(j=0; j<parNr; j++) {
    dif=up[j]-low[j];
    if(dif<=0.0) {
      for(i=0; i<sNr; i++) if(p[i].topomin==0) p[i].par[j]=low[j];
    } else {
      stl=copysign(sqrt(fabs(low[j])),low[j]); if(!isnormal(stl)) stl=0.0;
      stu=copysign(sqrt(fabs(up[j])), up[j]); if(!isnormal(stu)) stu=0.0;
      dif=stu-stl;
      for(i=0; i<sNr; i++) if(p[i].topomin==0) {
        v=drand()*dif + stl;
        p[i].par[j]=copysign(v*v, v);
      }
    }
  }
}

Referenced by tgo().

Variable Documentation

◆ GAUSSDEV_SEED

long int GAUSSDEV_SEED

extern

Seed for random number generator; declared in gaussdev.c

Seed for random number generator

Definition at line 7 of file gaussdev.c.

Referenced by init_gaussdev().

◆ TGO_LOCAL_INSIDE

int TGO_LOCAL_INSIDE

extern

Local optimization outside (0) or inside (1) iTGO

Definition at line 29 of file tgo.c.

Referenced by tgo().

◆ TGO_LOCAL_OPT

int TGO_LOCAL_OPT

extern

Local optimization method is Powell-Brent (0) or Bobyqa (1)

Local optimization is done using Powell-Brent (0) or Bobyqa (1).

Definition at line 31 of file tgo.c.

Referenced by tgo().

◆ TGO_SQUARED_TRANSF

int TGO_SQUARED_TRANSF

extern

Biased (1) or even (0) parameter distribution

Definition at line 27 of file tgo.c.

Referenced by tgo().

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ DEFAULT_CHB

◆ DEFAULT_CMB

◆ DEFAULT_NHB

◆ DEFAULT_P50HB

◆ DEFAULT_P50MB

◆ DEFAULT_SAO2

◆ MAX_PARAMETERS

◆ MAX_PARAMS

◆ MTGA_BEST_MIN_NR

◆ TPCCLIB_MERTWI_A

◆ TPCCLIB_MERTWI_NN

Typedef Documentation

◆ bobyqa_func

Enumeration Type Documentation

◆ bobyqa_result

◆ linefit_method

◆ linefit_range

Function Documentation

◆ aicModel()

◆ aicSS()

◆ aicWeightedAvg()

◆ aicWeights()

◆ best_llsqwt()

◆ best_pearson()

◆ bobyqa()

◆ bobyqa_free_memory()

◆ bobyqa_minimize_single_parameter()

◆ bobyqa_print()

◆ bobyqa_rc()

◆ bobyqa_reset_memory()

◆ bobyqa_set_memory()

◆ bobyqa_set_optimization()

◆ bobyqa_working_memory_size()

◆ bobyqa_x_funcval()

◆ bobyqa_xfull()

◆ bobyqb()

◆ bootstrap()

◆ bvls()

◆ d_kth_smallest()

◆ dmean()

◆ dmean_nan()

◆ dmedian()

◆ drand()

◆ drandSeed()

◆ fintegrate()

◆ finterpolate()

◆ finterpolate4pet()

◆ fitExpDecayNNLS()

◆ fixed_params()

◆ fpetintegral()

◆ fpetintegrate()

◆ fpetintegrate2fe()

◆ gaussdev()

◆ gaussdev2()

◆ highest_slope()

◆ highest_slope_after()

◆ householder_hm()

◆ householder_hv()

◆ householder_norm()

◆ householder_transform()

◆ huber()

◆ init_gaussdev()

◆ integrate()

◆ interpolate()

◆ interpolate4pet()

◆ least_median_of_squares()

◆ least_trimmed_square()

◆ llsqperp()

◆ llsqperp3()

◆ llsqWght()

◆ llsqWghtSquared()

◆ llsqwt()