par.c File Reference

PAR struct processing. More...

#include "tpcclibConfig.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <string.h>
#include "tpcextensions.h"
#include "tpcmodels.h"
#include "tpcift.h"
#include "tpcpar.h"

Go to the source code of this file.

Functions
void	parInit (PAR *par)
void	parrInit (PARR *parr)
void	parnInit (PARN *parn)
void	parFree (PAR *par)
void	parrFree (PARR *parr)
int	parAllocate (PAR *par, int parNr, int tacNr)
int	parrAllocate (PARR *parr, int parNr)
int	parAllocateMore (PAR *par, int parNr, int tacNr)
int	parIsWSS (PAR *par)
int	parIsFitRange (PAR *par)
int	parIsModel (PAR *par)
int	parSDWithPar (PAR *par, int pi)
int	parCLWithPar (PAR *par, int pi)
int	parIsFitNr (PAR *par)
int	parIsDataNr (PAR *par)
char *	parIsOptcrit (PAR *par)
char *	parIsStudyNr (PAR *par)
int	parSetStudyNr (PAR *par, const char *s)
void	parEnsureNames (PAR *d)
int	parDeletePar (PAR *par, int pi)
int	parDeleteTAC (PAR *par, int ti)

Detailed Description

PAR struct processing.

Definition in file par.c.

Function Documentation

parAllocate()

int parAllocate	(	PAR *	par,
		int	parNr,
		int	tacNr )

Allocate memory for PAR data.

Any previous contents are deleted.

Returns

Returns TPCERROR status.

See also

parInit, parFree, parAllocateMore, parAllocateWithTAC

Parameters

par	Pointer to initiated PAR struct data; any old contents are deleted. tacNr and parNr inside the struct are set to or kept at zero.
parNr	Nr of parameters to allocate
tacNr	Nr of parameter sets (TACs) to allocate

Definition at line 108 of file par.c.

  {
  if(par==NULL) return TPCERROR_FAIL;
  /* Delete any previous contents */
  parFree(par);
  /* If no memory is requested, then just return */
  if(parNr<1 && tacNr<1) return TPCERROR_OK;
  if(parNr<1 || tacNr<1) return TPCERROR_FAIL;
 
  /* Allocate memory for PARR data */
  int ret;
  par->r=(PARR*)malloc(tacNr*sizeof(PARR));
  if(par->r==NULL) return TPCERROR_OUT_OF_MEMORY;
  for(int i=0; i<tacNr; i++) {
    parrInit(&par->r[i]);
    ret=parrAllocate(par->r+i, parNr); if(ret!=TPCERROR_OK) return ret;
  }
  par->_tacNr=tacNr;
 
  /* Allocate memory for parameter names and units */
  par->n=(PARN*)malloc(parNr*sizeof(PARN));
  if(par->n==NULL) return TPCERROR_OUT_OF_MEMORY;
  for(int i=0; i<parNr; i++) parnInit(&par->n[i]);
  par->_parNr=parNr;
 
  return TPCERROR_OK;
}

Referenced by parAllocateWithTAC(), parExamplePerfectBolus(), parExampleTTACs(), parFromIFT(), parReadCSV(), parReadFIT(), and parReadRES().

parAllocateMore()

int parAllocateMore	(	PAR *	par,
		int	parNr,
		int	tacNr )

Allocate more memory for PAR data. Previous contents are preserved.

Returns

Returns TPCERROR status.

See also

parAllocate, parInit, parRead, parFree

Parameters

par	Pointer to initiated and previously allocated PAR struct data; any old contents are preserved, including tacNr and parNr.
parNr	Nr of additional parameters to allocate; if struct contains unused space for requested parameters already, then nothing is done.
tacNr	Nr of additional parameter sets (TACs) to allocate; if struct contains unused space for requested parameters already, then nothing is done.

Definition at line 183 of file par.c.

  {
  if(par==NULL) return TPCERROR_FAIL;
  if(par->_parNr<1 || par->_tacNr<1) return TPCERROR_FAIL;
  if(parNr<0 || tacNr<0) return TPCERROR_FAIL;
  /* Check if there is enough space already */
  int newTacNr, addTacNr, newParNr, addParNr;
  newTacNr=par->tacNr+tacNr; addTacNr=newTacNr-par->_tacNr;
  newParNr=par->parNr+parNr; addParNr=newParNr-par->_parNr;
  if(addTacNr<=0 && addParNr<=0) return TPCERROR_OK;
 
  /* Reallocate memory for parameter names and units, if necessary */
  if(addParNr>0) {
    PARN *parnPtr;
    parnPtr=realloc(par->n, sizeof(PARN)*newParNr);
    if(parnPtr==NULL) return TPCERROR_OUT_OF_MEMORY;
    par->n=parnPtr;
    parnPtr+=par->_parNr; for(int i=0; i<addParNr; i++) parnInit(parnPtr++);
  }
 
  /* Reallocate memory for parameters of previous TACs, if necessary */
  if(addParNr>0) {
    int i, j;
    for(i=0; i<par->tacNr; i++) {
      par->r[i].p=realloc(par->r[i].p, sizeof(double)*newParNr);
      par->r[i].sd=realloc(par->r[i].sd, sizeof(double)*newParNr);
      par->r[i].cl1=realloc(par->r[i].cl1, sizeof(double)*newParNr);
      par->r[i].cl2=realloc(par->r[i].cl2, sizeof(double)*newParNr);
      if(par->r[i].p==NULL || par->r[i].sd==NULL || par->r[i].cl1==NULL || par->r[i].cl2==NULL) 
        return TPCERROR_OUT_OF_MEMORY;
      for(j=par->parNr; j<newParNr; j++)
        par->r[i].p[j]=par->r[i].sd[j]=par->r[i].cl1[j]=par->r[i].cl2[j]=nan("");
    }
  }
 
  /* Allocate memory for more TACs, if necessary */
  if(addTacNr>0) {
    PARR *parrPtr;
    parrPtr=realloc(par->r, sizeof(PARR)*newTacNr);
    if(parrPtr==NULL) return TPCERROR_OUT_OF_MEMORY;
    par->r=parrPtr;
    parrPtr+=par->_tacNr; 
    for(int i=0; i<addTacNr; i++, parrPtr++) {
      parrInit(parrPtr);
      if(parrAllocate(parrPtr, newParNr)!=TPCERROR_OK)
        return TPCERROR_OUT_OF_MEMORY;
    }
  }
  
  par->_parNr=newParNr;
  par->_tacNr=newTacNr;
  return TPCERROR_OK;
}

Referenced by parCombineTACs().

parCLWithPar()

int parCLWithPar	(	PAR *	par,
		int	pi )

Check if specified parameter has confidence limits in at least one of the regions.

See also

parSDWithPar, parIsWSS

Returns

Returns 1 if CLs exist, and 0 if not (or in case of an error).

Parameters

par	Pointer to parameter data.
pi	Index of parameter [0..parNr-1] to check.

Definition at line 325 of file par.c.

  {
  if(par==NULL || par->tacNr<1 || pi<0 || pi>=par->parNr) return(0);
  for(int i=0; i<par->tacNr; i++)
    if(!isnan(par->r[i].cl1[pi]) && !isnan(par->r[i].cl2[pi])) return(1);
  return(0);
}

Referenced by parWriteCSV(), and parWriteXML().

parDeletePar()

int parDeletePar	(	PAR *	par,
		int	pi )

Deletes the specified parameter (column) from data.

Returns

Returns TPCERROR status.

See also

parDeleteTAC

Parameters

par	Pointer to parameter data.
pi	Index of parameter [0..parNr-1] to remove.

Definition at line 478 of file par.c.

  {
  if(par==NULL || par->tacNr<1 || pi<0 || pi>=par->parNr) return(TPCERROR_FAIL);
  if(pi==par->parNr-1) {par->parNr--; return(TPCERROR_OK);}
 
  int i, j;
 
  /* Parameter name and unit */
  PARN parn;
  memcpy(&parn, &par->n[pi], sizeof(PARN));
  for(i=pi+1; i<par->parNr; i++)
    memcpy(&par->n[i-1], &par->n[i], sizeof(PARN));
  memcpy(&par->n[par->parNr-1], &parn, sizeof(PARN));
 
  /* Parameter values */
  double p, sd, cl1, cl2;
  for(j=0; j<par->tacNr; j++) {
    p=par->r[j].p[pi]; sd=par->r[j].sd[pi];
    cl1=par->r[j].cl1[pi]; cl2=par->r[j].cl2[pi];
    for(i=pi+1; i<par->parNr; i++) {
      par->r[j].p[i-1]=par->r[j].p[i]; par->r[j].sd[i-1]=par->r[j].sd[i];
      par->r[j].cl1[i-1]=par->r[j].cl1[i]; par->r[j].cl2[i-1]=par->r[j].cl2[i];
    }
    par->r[j].p[par->parNr-1]=p; par->r[j].sd[par->parNr-1]=sd;
    par->r[j].cl1[par->parNr-1]=cl1; par->r[j].cl2[par->parNr-1]=cl2;
  }
 
  par->parNr--;
  return(TPCERROR_OK);
}

Referenced by parReadCSV(), and parReadRES().

parDeleteTAC()

int parDeleteTAC	(	PAR *	par,
		int	ti )

Deletes the specified TAC (row) from data.

Returns

Returns TPCERROR status.

See also

parDeletePar, parSortByName

Parameters

par	Pointer to parameter data.
ti	Index of TAC [0..tacNr-1] to remove.

Definition at line 519 of file par.c.

  {
  if(par==NULL || par->tacNr<1 || ti<0 || ti>=par->tacNr) return(TPCERROR_FAIL);
  /* Free the memory allocated for the TAC */
  parrFree(par->r+ti);
  /* If the last TAC is to be deleted, then just reduce the tacNr */
  if(ti==par->tacNr-1) {par->tacNr--; return(TPCERROR_OK);}
  /* Otherwise move the following TACs in its place */
  for(int i=ti+1; i<par->tacNr; i++) par->r[i-1]=par->r[i];
  par->tacNr--; parrInit(par->r+par->tacNr);
  return(TPCERROR_OK);
}

parEnsureNames()

void parEnsureNames

(

PAR *

d

)

Ensure that PAR struct contains a name for each TAC and parameters. If not available, then index+1 is written as name.

See also

parSetStudyNr, parSortByName

Parameters

d	Pointer to parameter data.

Definition at line 449 of file par.c.

  {
  if(d==NULL || d->tacNr<1 || d->parNr<1) return;
  /* Ensure TAC names */
  int u, n;
  u=d->tacNr; n=1; while((u/=10)>=1) n++;
  if(n>MAX_TACNAME_LEN) n=MAX_TACNAME_LEN;
  for(int i=0; i<d->tacNr; i++) {
    if(strlen(d->r[i].name)<1 || strcmp(d->r[i].name, ".")==0)
      sprintf(d->r[i].name, "%0*d", n, 1+i);
  }
  /* Ensure parameter names */
  u=d->parNr; n=1; while((u/=10)>=1) n++;
  if(n>MAX_PARNAME_LEN-1) n=MAX_PARNAME_LEN-1;
  for(int i=0; i<d->parNr; i++) {
    if(strlen(d->n[i].name)<1 || strcmp(d->n[i].name, ".")==0)
      sprintf(d->n[i].name, "P%0*d", n, 1+i);
  }
  return;
}

parFree()

void parFree

(

PAR *

par

)

Free memory allocated for PAR. All data is cleared.

See also

parInit, parAllocate, parRead

Parameters

par	Pointer to PAR struct

Definition at line 75 of file par.c.

  {
  if(par==NULL) return;
  for(int i=0; i<par->_tacNr; i++) parrFree(par->r+i);
  free(par->r);
  free(par->n);
  iftFree(&par->h);
  parInit(par);
}

Referenced by parAllocate(), parFromIFT(), parRead(), parReadCSV(), parReadFIT(), and parReadRES().

parInit()

void parInit

(

PAR *

par

)

Initiate the PAR struct before any use.

Author

Vesa Oikonen

See also

parrInit, parnInit, parFree, parAllocate, parRead

Parameters

par	Pointer to PAR

Definition at line 25 of file par.c.

  {
  if(par==NULL) return;
  par->format=PAR_FORMAT_UNKNOWN;
  par->tacNr=par->_tacNr=0;
  par->parNr=par->_parNr=0;
  par->n=NULL;
  par->r=NULL;
  iftInit(&par->h);
}

Referenced by parFree().

parIsDataNr()

int parIsDataNr

(

PAR *

par

)

Check if any of parameter sets has dataNr specified.

See also

parIsFitNr, parIsWSS

Returns

Returns 0 if not, 1 if the same in each set, and 2 if variable.

Parameters

par	Pointer to parameter data

Definition at line 362 of file par.c.

  {
  if(par==NULL || par->tacNr<1) return(0);
  int ri, ret=0;
  for(ri=0; ri<par->tacNr; ri++) {
    if(ret==0 && par->r[ri].dataNr>0) ret=1;
    if(ri>0 && par->r[ri].dataNr!=par->r[ri-1].dataNr) {ret=2; break;}
  }
  return(ret);
}

Referenced by parToIFT(), parWriteCSV(), and parWriteXML().

parIsFitNr()

int parIsFitNr

(

PAR *

par

)

Check if any of parameter sets has fitNr specified.

See also

parIsDataNr, parIsWSS

Returns

Returns 0 if not, 1 if the same in each set, and 2 if variable.

Parameters

par	Pointer to parameter data.

Definition at line 343 of file par.c.

  {
  if(par==NULL || par->tacNr<1) return(0);
  int ri, ret=0;
  for(ri=0; ri<par->tacNr; ri++) {
    if(ret==0 && par->r[ri].fitNr>0) ret=1;
    if(ri>0 && par->r[ri].fitNr!=par->r[ri-1].fitNr) {ret=2; break;}
  }
  return(ret);
}

Referenced by parToIFT(), parWriteCSV(), and parWriteXML().

parIsFitRange()

int parIsFitRange

(

PAR *

par

)

Check if any of parameter sets has fit range specified.

See also

parIsFitNr, parIsDataNr, parIsWSS

Returns

Returns 0 if not, 1 if the same in each set, and 2 if variable.

Parameters

par	Pointer to parameter data.

Definition at line 267 of file par.c.

  {
  if(par==NULL || par->tacNr<1) return(0);
  int ri, ret=0;
  for(ri=0; ri<par->tacNr; ri++) {
    if(!isnan(par->r[ri].start) || !isnan(par->r[ri].end)) ret=1;
    if(ri==0 || ret==0) continue;
    if(!doubleMatch(par->r[ri].start, par->r[0].start, 0.01)) {ret=2; break;}
    if(!doubleMatch(par->r[ri].end,   par->r[0].end,   0.01)) {ret=2; break;}
  }
  return(ret);
}

Referenced by parToIFT(), parWriteCSV(), and parWriteXML().

parIsModel()

int parIsModel

(

PAR *

par

)

Check if any of parameter sets has model id specified.

See also

parIsFitNr, parIsWSS, parRead, parIsOptcrit

Returns

Returns 0 if not, 1 if the same in each set, and 2 if variable.

Parameters

par	Pointer to parameter data.

Definition at line 288 of file par.c.

  {
  if(par==NULL || par->tacNr<1) return(0);
  int ri, ret=0;
  for(ri=0; ri<par->tacNr; ri++) {
    if(ret==0 && par->r[ri].model>0) ret=1;
    if(ri>0 && par->r[ri].model!=par->r[ri-1].model) {ret=2; break;}
  }
  return(ret);
}

Referenced by parToIFT(), parWriteCSV(), and parWriteXML().

parIsOptcrit()

char * parIsOptcrit

(

PAR *

par

)

Check if PAR data contains optimality criterion.

See also

parIsModel, parIsWSS, studynrFromFilename

Returns

Returns pointer to optimization criterion name, or NULL if not found.

Parameters

par	Pointer to parameter data.

Definition at line 381 of file par.c.

  {
  if(par==NULL || par->h.keyNr<1) return((char*)NULL);
  int li=iftFindKey(&par->h, "optimality_criterion", 0);
  if(li<0) li=iftFindKey(&par->h, "optcrit", 0);
  if(li<0) return((char*)NULL);
  if(par->h.item[li].value==NULL || strlen(par->h.item[li].value)<1) return((char*)NULL);
  return(par->h.item[li].value);
}

parIsStudyNr()

char * parIsStudyNr

(

PAR *

par

)

Check if PAR data contains study number.

See also

parSetStudyNr, parIsModel, parIsWSS, studynrFromFilename, parEnsureNames

Returns

Returns pointer to study number, or NULL if not found.

Parameters

par	Pointer to parameter data.

Definition at line 399 of file par.c.

  {
  if(par==NULL || par->h.keyNr<1) return((char*)NULL);
  int li=iftFindKey(&par->h, "studynr", 0);
  if(li<0) li=iftFindKey(&par->h, "study_number", 0);
  if(li<0) return((char*)NULL);
  if(par->h.item[li].value==NULL || strlen(par->h.item[li].value)<1) return((char*)NULL);
  return(par->h.item[li].value);
}

parIsWSS()

int parIsWSS

(

PAR *

par

)

Check if any of parameter sets has WSS.

See also

parIsFitNr, parIsDataNr, parCLWithPar, parSDWithPar, parIsOptcrit

Returns

Returns 1 if WSS exists, and 0 if not (or in case of an error).

Parameters

par	Pointer to parameter data.

Definition at line 252 of file par.c.

  {
  if(par==NULL || par->tacNr<1) return(0);
  for(int ri=0; ri<par->tacNr; ri++) if(!isnan(par->r[ri].wss)) return(1);
  return(0);
}

Referenced by parWriteCSV(), parWriteRES(), and parWriteXML().

parnInit()

void parnInit

(

PARN *

parn

)

Initiate the PARN struct before any use.

Author

Vesa Oikonen

See also

parInit, parrInit

Parameters

parn	Pointer to PARN

Definition at line 59 of file par.c.

  {
  if(parn==NULL) return;
  parn->name[0]='\0';
  parn->unit=UNIT_UNKNOWN;
  parn->lim1=parn->lim2=parn->tol=nan("");
  parn->sw=0;
}

Referenced by parAllocate(), and parAllocateMore().

parrAllocate()

int parrAllocate	(	PARR *	parr,
		int	parNr )

Allocate memory for PARR data. Any previous contents are deleted.

See also

parrInit, parrFree, parAllocate

Returns

Returns TPCERROR status.

Parameters

parr	Pointer to initiated PARR struct data; any old contents are deleted.
parNr	Nr of parameters to allocate.

Definition at line 150 of file par.c.

  {
  if(parr==NULL) return TPCERROR_FAIL;
  /* Delete any previous contents */
  parrFree(parr);
  /* If no memory is requested, then just return */
  if(parNr<1) return TPCERROR_OK;
 
  /* Allocate memory for PARR data */
  parr->p=malloc(parNr*sizeof(double));
  parr->sd=malloc(parNr*sizeof(double));
  parr->cl1=malloc(parNr*sizeof(double));
  parr->cl2=malloc(parNr*sizeof(double));
  if(parr->p==NULL || parr->sd==NULL || parr->cl1==NULL || parr->cl2==NULL)
    return TPCERROR_OUT_OF_MEMORY;
  /* Initiate values to NaNs */
  for(int i=0; i<parNr; i++)
    parr->p[i]=parr->sd[i]=parr->cl1[i]=parr->cl2[i]=nan("");
 
  return TPCERROR_OK;
}

Referenced by parAllocate(), and parAllocateMore().

parrFree()

void parrFree

(

PARR *

parr

)

Free memory allocated for PARR. All data is cleared.

Parameters

parr	Pointer to PARR struct

Definition at line 87 of file par.c.

  {
  if(parr==NULL) return;
  free(parr->p);
  free(parr->sd);
  free(parr->cl1);
  free(parr->cl2);
  parrInit(parr);
}

Referenced by parDeleteTAC(), parFree(), and parrAllocate().

parrInit()

void parrInit

(

PARR *

parr

)

Initiate the PARR struct before any use.

Author

Vesa Oikonen

See also

parInit, parnInit

Parameters

parr	Pointer to PARR

Definition at line 41 of file par.c.

  {
  if(parr==NULL) return;
  parr->model=0;
  parr->name[0]='\0';
  parr->start=parr->end=nan("");
  parr->fitNr=0;
  parr->dataNr=0;
  parr->p=parr->sd=parr->cl1=parr->cl2=NULL;
  parr->wss=nan("");
  parr->sw=0;
}

Referenced by parAllocate(), parAllocateMore(), parDeleteTAC(), and parrFree().

parSDWithPar()

int parSDWithPar	(	PAR *	par,
		int	pi )

Check if specified parameter has SD in at least one of the regions.

See also

parCLWithPar, parIsWSS

Returns

Returns 1 if SD exists, and 0 if not (or in case of an error).

Parameters

par	Pointer to parameter data.
pi	Index of parameter [0..parNr-1] to check.

Definition at line 307 of file par.c.

  {
  //printf("%s(%d)\n", __func__, pi); fflush(stdout);
  if(par==NULL || par->tacNr<1 || pi<0 || pi>=par->parNr) return(0);
  for(int i=0; i<par->tacNr; i++) if(!isnan(par->r[i].sd[pi])) return(1);
  return(0);
}

Referenced by parWriteCSV(), and parWriteXML().

parSetStudyNr()

int parSetStudyNr	(	PAR *	par,
		const char *	s )

Set study number in PAR data, overwriting any previous study number.

See also

parIsStudyNr, tacSetHeaderStudynr, tacGetHeaderStudynr, studynrFromFilename

Returns

enum tpcerror (TPCERROR_OK when successful).

Parameters

par	Pointer to parameter data.
s	Pointer to string containing the study number; enter NULL or "" if you only want to delete studynr in header.

Definition at line 417 of file par.c.

  {
  if(par==NULL) return TPCERROR_FAIL;
 
  /* Find and delete previous studynr(s) */
  int i=0, start=0;
  while(1) {
    i=iftFindKey(&par->h, "studynr", start);
    if(i<0) i=iftFindKey(&par->h, "study_number", start);
    if(i<0) i=iftFindKey(&par->h, "study number", start);
    if(i<0) break;
    iftDelete(&par->h, i); if(i>start) start=i;
  }
 
  /* If new studynr is empty, then just return */
  if(s==NULL || *s=='\0') return(TPCERROR_OK);
  
  /* Otherwise create new key and value */
  return(iftPut(&par->h, "studynr", s, (char)1, NULL));
}