pf_alloc.c

LastWave

	scale = PFGetIndexMax(lwpf->pf) + 1;
      
      Y = signal->Y;
      size = signal->size;
      flagMinimalSort = NO;
      while( (opt = ParseOption(&argv)) ) { 
	switch(opt) {
	case 'c':
	  Y = signal->Y + signal->firstp;
	  size = signal->lastp - signal->firstp + 1;
	  break;
	case 's':
	  flagMinimalSort = YES;
	  break;
	default:
	  ErrorOption(opt);
	}
      }
      NoMoreArgs(argv);

      if(flagMinimalSort == YES)
	PFChangeQsort(PFMinimalQsortData);
      else
	PFChangeQsort(NULL);

	res = PFComputeOneScaleFLOAT(lwpf->pf,scale,Y,size);
	switch(res)
	  {
	  case PFYes:
	    SetResultInt(res);
	    break;
	  case PFNotValid:
	    Errorf("One of the parameter isn\'t valid");
	    break;
	  default:
	    Errorf("serious error. (maybe the lwpf->pf pointer was NULL)");
	  }
    }
  /* 'write' action */
  else if (!strcmp(action,"write"))
    {
      LWPARTFUNC lwpf;
      STREAM stream;
      FILE *fp;
      int flagToBeClosed = NO;
      int res;
      char *fileName;

      argv = ParseArgv(argv,tPF,&lwpf,tSTREAM_,NULL,&stream,-1);
      
      if(stream != NULL)
	{
	  fp = stream2File(stream);
	  NoMoreArgs(argv);
	}
      /* if the last argument is not a stream it may be a filename */
      else 
	{
	  ParseArgv(argv,tSTR_,NULL,&fileName,0);
	  if(fileName != NULL)
	    {
	      fp = FOpen(fileName,"w");
	      flagToBeClosed = YES;
	      if (fp == NULL) 
		Errorf("Can't open file: %s",fileName);
	    }
	  /* if there is no last argument we use stdoutStream */
	  else fp = stream2File(stdoutStream);
	}
      
      res = PFWriteAscii(fp,lwpf->pf);
      if(flagToBeClosed == YES)
	FClose(fp);
      switch(res)
	{
	case PFYes:
	  SetResultInt(res);
	  break;
	case PFWriErr:
	  Errorf("probleme while writing");
	  break;
	default:
	  Errorf("serious writing error. (maybe the file descriptor was NULL)");
	}
    }
  /* 'writebin' action */
  else if (!strcmp(action,"writebin"))
    {
      LWPARTFUNC lwpf;
      FILE *fp;
      char *fileName;
      int res;

      argv = ParseArgv(argv,tPF,&lwpf,tSTR,&fileName,0);
      
      fp = FOpen(fileName,"w");
      if (fp == NULL) 
	Errorf("Can't open file: %s",fileName);
      
      res = PFWriteBin(fp,lwpf->pf);
      FClose(fp);
      
      switch(res)
	{
	case PFYes:
	  SetResultInt(res);
	  break;
	case PFWriErr:
	  Errorf("probleme while writing");
	  break;
	default:
	  Errorf("serious writing error. (maybe the file descriptor was NULL)");
	}
    }

  /* 'read' action */
  else if (!strcmp(action,"read"))
    {
      LWPARTFUNC lwpf;
      STREAM stream;
      FILE *fp;
      char *fileName;
      int flagToBeClosed = NO;
      int res;
      argv = ParseArgv(argv,tPF_,NULL,&lwpf,tSTREAM_,NULL,&stream,-1);
      
      if(stream != NULL)
	{
	  fp = stream2File(stream);
	  NoMoreArgs(argv);
	}
      /* if the last argument is not a stream it may be a filename */
      else 
	{
	  argv = ParseArgv(argv,tSTR_,NULL,&fileName,0);
	  if(fileName != NULL)
	    {
	      fp = FOpen(fileName,"r");
	      flagToBeClosed = YES;
	      if (fp == NULL) 
		Errorf("Can't open file: %s",fileName);
	    }
	  /* if there is no last argument we use stdinStream */
	  else fp = stream2File(stdinStream);
	}

      if(lwpf == NULL) {
	lwpf = NewPartitionFunction();
	TempValue(lwpf);
      }
	
      res = PFRead(fp,lwpf->pf);
      if(flagToBeClosed == YES)
	FClose(fp);

      switch(res)
	{
	case PFYes:
	  SetResultValue(lwpf);
	  break;
	case PFErrFormat:
	  Errorf("the input has a bad format");
	  break;
	case PFNotValid:
	  Errorf("one of the value read is not meaningful");
	  break;
	default:
	  Errorf("serious reading error. (maybe the file descriptor was NULL)");
	}
    }  

  /* 'copy' action */
  else if (!strcmp(action,"copy"))
    {
      LWPARTFUNC lwpf,lwpf1;
      PartitionFunction pfTemp;

      argv = ParseArgv(argv,tPF,&lwpf,tPF,&lwpf1,0);
      
      
      if( PFIsValid(lwpf->pf) != PFYes )
	Errorf("The input pf is not valid.");

      pfTemp = PFCopy(lwpf->pf);
      if(pfTemp == NULL)
	Errorf("An error occured while copying.");
      PFDelete(lwpf1->pf);
      lwpf1->pf = pfTemp;
    }

  /* 'wtmm' action */
  else if (!strcmp(action,"wtmm")) 
    {
      LWPARTFUNC lwpf;
      EXTREP extrep;
      LISTV lv;
      SIGNAL sig;
      double *qArray;
      int qNumber;

      argv = ParseArgv(argv,tPF_,NULL,&lwpf,tEXTREP,&extrep,
		       tLISTV_,NULL,&lv,-1);
      if( lv == NULL) {
	argv = ParseArgv(argv,tSIGNALI,&sig,0);
	if( (qArray = PFSignal2QArray(sig)) == NULL )
	  Errorf1("");
	qNumber = sig->size;
      } else { 
	NoMoreArgs(argv);
	if( (qArray = PFListv2QArray(lv)) == NULL )
	  Errorf1("");
	qNumber = lv->length;
      }
      
      if(lwpf == NULL) {
	lwpf = NewPartitionFunction();
	TempValue(lwpf);
      }
      
      PFChangeQsort(NULL); /* To be sure we sort */
      ComputePartFuncOnExtrep(lwpf,extrep,qNumber,qArray);
      
      SetResultValue(lwpf);
    }
  /* 'cont' action */
  else if (!strcmp(action,"cont")) 
    {
      LWPARTFUNC lwpf;
      WTRANS wtrans;
      LISTV lv;
      SIGNAL sig;
      double *qArray;
      int qNumber;
      int flagCausal,flagMinimalSort;
      char opt;

      argv = ParseArgv(argv,tPF_,NULL,&lwpf,tWTRANS,&wtrans,
		       tLISTV_,NULL,&lv,-1);
      if( lv == NULL) {
	argv = ParseArgv(argv,tSIGNALI,&sig,-1);
	if( (qArray = PFSignal2QArray(sig)) == NULL )
	  Errorf1("");
	qNumber = sig->size;
      } else { 
	if( (qArray = PFListv2QArray(lv)) == NULL )
	  Errorf1("");
	qNumber = lv->length;
      }
  

      flagMinimalSort = NO;
      flagCausal = NO;
      while( (opt = ParseOption(&argv)) ) { 
	switch(opt) {
	case 'c':
	  flagCausal = YES;
	  break;
	case 's':
	  flagMinimalSort = YES;
	  break;
	default:
	  ErrorOption(opt);
	}
      }
      
      if(lwpf == NULL) {
	lwpf = NewPartitionFunction();
	TempValue(lwpf);
      }

      if(flagMinimalSort == YES)
	PFChangeQsort(PFMinimalQsortData);
      else
	PFChangeQsort(NULL);
      
      ComputePartFuncOnWtrans(lwpf,wtrans,qNumber,qArray,flagCausal);

      SetResultValue(lwpf);
    }
  /* 'get', 'getq', 'geti' action */
  else if ( !strcmp(action,"get")
	    ||  !strcmp(action,"getq")
	    ||  !strcmp(action,"geti")
	    ) 
    {
      LWPARTFUNC lwpf;
      LISTV lv,lvsig;
      SIGNAL signal,sig;
      LWFLOAT q;
      char *type;
      char opt;
      int mode;
      char access_mode = 'q';
      
      if( !strcmp(action,"geti") ) 
	access_mode = 'i';


      argv = ParseArgv(argv,tWORD,&type,tPF,&lwpf,
		       tLISTV_,NULL,&lv,-1);
      if( lv == NULL)
	argv = ParseArgv(argv,tFLOAT_,FLOAT_MAX,&q,-1);
      
      if( q == FLOAT_MAX ) {
	argv = ParseArgv(argv,tSIGNALI_,NULL,&sig,-1);
      }

      mode = PFEXTENSIVE;
      while( (opt = ParseOption(&argv)) ) 
	{ 
	  switch(opt) 
	    {
	    case 'i':
	      mode = PFINTENSIVE;
	      break;
	    default:
	      ErrorOption(opt);
	    }
	}
      NoMoreArgs(argv);

      if(lv != NULL) {
	if( access_mode == 'q' ) {
	  if( (lvsig = PFListvQ2ListvSig(lwpf,lv,type,mode)) == NULL)
	    Errorf1("");
	} else {
	  if( (lvsig = PFListvInd2ListvSig(lwpf,lv,type,mode)) == NULL)
	    Errorf1("");
	}
	SetResultValue(lvsig);
      } else if (q != FLOAT_MAX) {
	if( access_mode == 'q' ) {
	  if( (signal = PFQ2Signal(lwpf,type, q,mode)) == NULL)
	    Errorf1("");
	} else {
	  if( (signal = PFIndQ2Signal(lwpf,type,(int) (q+0.5),mode)) == NULL)
	    Errorf1("");
	}
	SetResultValue(signal);
      } else if (sig != NULL) {
	if( access_mode == 'q' ) {
	  if( (lvsig = PFSigQ2ListvSig(lwpf,sig,type,mode)) == NULL)
	    Errorf1("");
	} else {
	  if( (lvsig = PFSigInd2ListvSig(lwpf,sig,type,mode)) == NULL)
	    Errorf1("");
	}
	SetResultValue(lvsig);
      } else {
	if( (lvsig = PF2ListvSig(lwpf,type,mode)) == NULL)
	  Errorf1("");
	SetResultValue(lvsig);
      }

    }
  /* 'add' action */
  else if (!strcmp(action,"add"))
    {
      LWPARTFUNC lwpf,lwpf1,lwpf2;
      char opt;
      int flagNonstandard,res;

      argv = ParseArgv(argv,tPF,&lwpf1,tPF,&lwpf2,-1);

      flagNonstandard = NO;
      while( (opt = ParseOption(&argv)) ) 
	{ 
	  switch(opt) 
	    {
	    case 'n':
	      flagNonstandard = YES;
	      break;
	    default:
	      ErrorOption(opt);
	    }
	}
      NoMoreArgs(argv);

      if( PFGetOctaveNumber(lwpf1->pf) < PFGetOctaveNumber(lwpf2->pf) ) {
	lwpf = lwpf1;
	lwpf1 = lwpf2;
	lwpf2 = lwpf;
      }

      if( (lwpf = CopyPartitionFunction(lwpf1,NULL)) == NULL)
	Errorf1("");
      TempValue(lwpf);

      if(flagNonstandard == NO) {
	res = PFStandardAddition(lwpf->pf,lwpf2->pf);
      } else {
	res = PFNonStandardAddition(lwpf->pf,lwpf2->pf);
      }

      switch(res)
	{
	case PFYes:
	  SetResultValue(lwpf);
	  break;
	case PFNotValid:
	  Errorf("one of the pf's is not valid");
	  break;
	case PFNotCompatible:
	  Errorf("The pf's are not compatible for addition");
	  break;
	default:
	  Errorf("serious error. (shouldn't occur)");
	}
    }

  /* 'reset' action */
  else if (!strcmp(action,"reset"))
    {
      LWPARTFUNC lwpf;
      int res;

      argv = ParseArgv(argv,tPF,&lwpf,0);
      res = PFReset(lwpf->pf);

      switch(res)
	{
	case PFYes:
	  SetResultValue(lwpf);
	  break;
	case PFNotValid:
	  Errorf("pf is not valid");
	  break;
	case PFNo:
	  Errorf("serious error: pf was NULL !!");
	  break;
	default:
	  Errorf("serious error. (shouldn't occur)");
	}
    }

  else Errorf("Unknow action '%s'",action);  
  
}


/*
 * The field list
 */
struct field fieldsPartitionFunction[] = {

  "method", GetMethodPFV, SetMethodPFV, NULL, NULL,
  "amin", GetAminPFV, SetAminPFV, NULL, NULL,
  "noct", GetNOctPFV, NULL, NULL, NULL,
  "nvoice", GetNVoicePFV, NULL, NULL, NULL,
  "nscale", GetNScalePFV, NULL, NULL, NULL,
  "sigsize", GetSigSizePFV, SetSigSizePFV, NULL, NULL,
  "signum", GetSigNumPFV, NULL, NULL, NULL,
  "qnumber", GetQNumberPFV, NULL, NULL, NULL,
  "qlist", GetQListPFV, SetQListPFV, NULL, NULL,
  "dim", GetDimPFV, SetDimPFV, NULL, NULL,

  NULL, NULL, NULL, NULL, NULL
};



/*
 * The type structure for LWPARTFUNC
 */

TypeStruct tsPartitionFunction = {

  /* Documentation */
  "{{{&PF} "
  "{This type is the basic type for partition function handling "
  "for the multifractal formalism and in particular the WTMM method.}}} ",

  &partitionFunctionType,       /* The basic (unique) type name */
  NULL,     /* The GetType function */                       
  
  DeletePartitionFunction,     /* The Delete function */
  NewPartitionFunction,     /* The Delete function */
  
  CopyPartitionFunction,       /* The copy function */
  ClearPartitionFunction,       /* The clear function */
  
  ToStrPartitionFunction,       /* String conversion */
  PrintPartitionFunction,   /* The Print function : print the object when 'print' is called */
  PrintInfoPartitionFunction,   /* The PrintInfo function : called by 'info' */

  NULL,              /* The NumExtract function : used to deal with syntax like 10a */
   
  fieldsPartitionFunction      /* The list of fields */
};