signal_alloc.c

LastWave

    if (field == NULL || !strcmp(field,"")) return(optionDoc);
    if (!strcmp(field,"index")) return(indexoptionDoc);
    if (!strcmp(field,"X")) return(xoptionDoc);
    if (!strcmp(field,"Y")) return(yoptionDoc);
  }

  signal = (SIGNAL) value;

  if (field != NULL && !strcmp(field,"X") && signal->type == YSIG) return(NULL);

  if (field != NULL && !strcmp(field,"index")) return(indexextractOptions);
  
  return(extractOptionsSig);
}


/*
 * Function to get the ExtractInfo for fields NULL, X or Y
 */

static void *GetExtractInfoSignalV(VALUE value, void **arg)
{
  static ExtractInfo extractInfo;
  static char flagInit = YES;
  
  SIGNAL signal = (SIGNAL) value;
  char *field = ARG_EI_GetField(arg);
  unsigned long *options = ARG_EI_GetPOptions(arg);

  if (signal->size == 0) {
    SetErrorf("No extraction on empty signal");
    return(NULL);
  }
  
  
  if (field != NULL && !strcmp(field,"index")) {
    extractInfo.nSignals = 1;
    if (signal->type == YSIG) {
      extractInfo.xmax = signal->dx*(signal->size-1)+signal->x0;
      extractInfo.dx = signal->dx;
      extractInfo.xmin = signal->x0;
    }
    else {
      extractInfo.xmax = signal->X[signal->size-1];
      extractInfo.dx = -1;
      extractInfo.xsignal = signal;
      extractInfo.xmin = signal->X[0];
    }
    if (*options & FSIOptSigNoLimit) extractInfo.flags = 0;
    else extractInfo.flags = EIErrorBound;
    return(&extractInfo);
  }
        
  /* Some checkings */
  if (signal->type == XYSIG && *options & (FSIOptSigBPer | FSIOptSigBMir | FSIOptSigBMir1)) {
    SetErrorf("Cannot use any of the options *bperiodic, *bmirror or *bmirror1 for XYSignals");
    return(NULL);
  }

  /* Some checkings */
  if (signal->type == XYSIG && *options & (FSIOptSigBCon | FSIOptSigB0) && !(*options & (FSIOptSigX | FSIOptSigXLin))) {
    SetErrorf("Cannot use any of the options *bconst or *b0 for XYSignals without *x or *xlin");
    return(NULL);
  }

  /* Some checkings */
  if (*options & FSIOptSigXLin && *options & (FSIOptSigBPer | FSIOptSigBMir | FSIOptSigBMir1)) {
    SetErrorf("Cannot use any of the options *bperiodic, *bmirror or *bmirror1 with *xlin");
    return(NULL);
  }

  /* If *bperiodic,... then *nolimit must be off */
  if (*options & (FSIOptSigBPer | FSIOptSigBMir | FSIOptSigBMir1 | FSIOptSigB0 | FSIOptSigBCon)) *options &= ~FSIOptSigNoLimit;
      
  /* Init of the extraction info */
  if (flagInit) {
    extractInfo.nSignals = 1;
    flagInit = NO;
  }
  
  if (*options & (FSIOptSigX | FSIOptSigXLin)) {
    if (signal->type == YSIG) {
      extractInfo.xmax = signal->dx*(signal->size-1)+signal->x0;
      extractInfo.dx = signal->dx;
      extractInfo.xmin = signal->x0;
    }
    else {
      extractInfo.xmax = signal->X[signal->size-1];
      extractInfo.dx = -1;
      extractInfo.xsignal = signal;
      extractInfo.xmin = signal->X[0];
    }
  }
  else {
    extractInfo.xmax = signal->size-1;
    extractInfo.dx = 1;
    extractInfo.xmin = 0;
  }        
      
  /* '*nolimit' option : set some flags */
  if (*options & (FSIOptSigX | FSIOptSigXLin)) extractInfo.flags = 0;
  else extractInfo.flags = EIIntIndex;
  if (!(*options & (FSIOptSigNoLimit | FSIOptSigBPer | FSIOptSigBMir | FSIOptSigBMir1 | FSIOptSigBCon | FSIOptSigB0))) extractInfo.flags |= EIErrorBound;
      
  return(&extractInfo);
}

/*
 * 'size' field
 */

static char *sizeDoc = "{[= <size>]} {Sets/Gets the size of a signal. In a case of a Set no initialization is performed. Moreover, if the asked size \
is smaller than the allocation size no additional allocation is performed.}";


static void * GetSizeSignalV(VALUE value, void **arg)
{
  /* Documentation */
  if (value == NULL) return(sizeDoc);
  
  return(GetIntField(((SIGNAL) value)->size,arg));
}

int SetSizeSignal(SIGNAL sig, int size)
{
  if (size < 0) {
    SetErrorf("SetSizeSignal() : size must be positive");
    return(0);
  }
  SizeSignal(sig,size,sig->type);
  return(1);
}

static void * SetSizeSignalV(VALUE value, void **arg)
{
 SIGNAL signal = (SIGNAL) value;
 int size;
  
 /* doc */
 if (value == NULL) return(sizeDoc);

 size = signal->size;
 if (SetIntField(&size,arg,FieldPositive)==NULL) return(NULL);
 if (SetSizeSignal(signal,size)==0) return(NULL);
 return(numType);

}

/*
 * 'dx' field
 */

static char *dxDoc = "{[= <dx>]} {Sets/Gets the dx of a Y-signal}";

static void * GetDxSignalV(VALUE value, void **arg)
{
  /* Documentation */
  if (value == NULL) return(dxDoc);
  
  return(GetFloatField(((SIGNAL) value)->dx,arg));
}

int SetDxSignal(SIGNAL sig,LWFLOAT dx)
{
  if (dx <= 0) {
    SetErrorf("SetDxSignal() : Bad value %g for 'dx' field",dx);
    return(0);
  }
  sig->dx=dx;
  return(1);
}

static void *SetDxSignalV(VALUE value, void **arg)
{
  /* Documentation */
  if (value == NULL) return(dxDoc);

 return(SetFloatField(&(((SIGNAL) value)->dx),arg,FieldSPositive));
}

/*
 * 'x0' field
 */

static char *x0Doc = "{[= <x0>]} {Sets/Gets the x0 of a Y-signal}";

static void * GetX0SignalV(VALUE value, void **arg)
{
  /* Documentation */
  if (value == NULL) return(x0Doc);
  
  return(GetFloatField(((SIGNAL) value)->x0,arg));
}

int SetX0Signal(SIGNAL sig,LWFLOAT x0)
{
  sig->x0=x0;
  return(1);
}

static void * SetX0SignalV(VALUE value, void **arg)
{
     /* doc */
  if (value == NULL) return(x0Doc);

 return(SetFloatField(&(((SIGNAL) value)->x0),arg,0));
}

/*
 * 'name' field
 */

static char *nameDoc = "{[= <name>]} {Sets/Gets the name of a signal}";

static void * GetNameSignalV(SIGNAL signal, void **arg)
{
  /* Documentation */
  if (signal == NULL) return(nameDoc);
  
  return(GetStrField(signal->name,arg));
}

/* Set the name of a signal */
int SetNameSignal(SIGNAL signal, char *name)
{
  if (signal->name != defaultName && signal->name != NULL) {
    Free(signal->name);
    signal->name = NULL;
  }
  if (name == NULL) signal->name = defaultName;
  else signal->name = CopyStr(name);
  return(1);
}


static void * SetNameSignalV(SIGNAL signal, void **arg)
{
     /* doc */
  if (signal == NULL) return(nameDoc);

  if (signal->name==defaultName) {
    signal->name=CharAlloc(1);
    signal->name[0] = '\0';
  }
  return(SetStrField(&(signal->name),arg));
}


/*
 * 'xy' field
 */

static char *xyDoc = "{[= (0|1)]} {Sets/Gets 'xy' flag signal. If 0 it means that the signal is a Y-signal, otherwise, it is a XY-signal.}";

static void * GetXYSignalV(VALUE value, void **arg)
{
  /* Documentation */
  if (value == NULL) return(xyDoc);
  
  return(GetIntField(((SIGNAL) value)->type==XYSIG,arg));
}

int SetXYSignal(SIGNAL sig,int xy)
{
  if (xy == 0) sig->type = YSIG;
  else {
    SizeSignal(sig,sig->size,XYSIG);
  }
  return(1);
}

static void * SetXYSignalV(VALUE value, void **arg)
{
  int xy;
    
  /* doc */
  if (value == NULL) return(xyDoc);
  
  xy = (((SIGNAL) value)->type == XYSIG);

  if (SetIntField(&xy,arg,FieldPositive)==NULL) return(NULL);
  
  if (SetXYSignal(((SIGNAL) value),xy)==0) return(NULL);

  return(numType);
}

/*
 * 'sizeAllocX' field
 */

static char *SizeAllocXDoc = "{[= <sizeAllocX>]} {Gets/Sets the allocation size of the X array of a signal.}";

static void * GetSizeAllocXSignalV(VALUE value, void **arg)
{
  /* Documentation */
  if (value == NULL) return(SizeAllocXDoc);
  
  return(GetIntField(((SIGNAL) value)->sizeMallocX,arg));
}

int SetSizeAllocXSignal(SIGNAL s,int size)
{  
  if (s->type == XYSIG && size < s->size) {
    SetErrorf("SetSizeAllocXSignal() : Cannot set the 'sizeAllocX' field to an integer smaller than the 'size' field");
    return(0);
  }
  
  if (s->X != NULL) Free(s->X);
  s->X = NULL;
  if (size != 0) s->X = FloatAlloc(size);
  s->sizeMallocX = size;
  return(1);
}

static void * SetSizeAllocXSignalV(VALUE value, void **arg)
{
  int size;
  SIGNAL s;
    
     /* doc */
  if (value == NULL) return(SizeAllocXDoc);

  s = (SIGNAL) value;
  size = s->sizeMallocX;

  if (SetIntField(&size,arg,FieldPositive)==NULL) return(NULL);
    
  if (SetSizeAllocXSignal(s,size)==0) return(NULL);
  
  return(numType);
}

/*
 * 'sizeAllocY' field
 */

static char *SizeAllocYDoc = "{[= <sizeAllocY>]} {Gets the allocation size of the X array of a signal.}";

static void * GetSizeAllocYSignalV(VALUE value, void **arg)
{
  /* Documentation */
  if (value == NULL) return(SizeAllocYDoc);
  
  return(GetIntField(((SIGNAL) value)->sizeMallocY,arg));
}

int SetSizeAllocYSignal(SIGNAL s,int size)
{
  if ( size < s->size) {
    SetErrorf("SetSizeAllocYSignal() : Cannot set the 'sizeAllocY' field to an integer smaller than the 'size' field");
    return(0);
  }
  
  if (s->Y != NULL) Free(s->Y);
  s->Y = NULL;
  if (size != 0) s->Y = FloatAlloc(size);
  s->sizeMallocY = size;
  return(1);
}

static void * SetSizeAllocYSignalV(VALUE value, void **arg)
{
  int size;
  SIGNAL s;
    
     /* doc */
  if (value == NULL) return(SizeAllocYDoc);

  s = (SIGNAL) value;
  size = s->sizeMallocY;

  if (SetIntField(&size,arg,FieldPositive)==NULL) return(NULL);

  if (SetSizeAllocYSignal(s,size)==0) return(NULL);
  
  return(numType);
}


/*
 * 'firstp' field
 */

static char *firstpDoc = "{[= <firstp>]} {Sets/Gets the 'firstp' field of a signal ('firstp' is the index number used for storing the first index affected by border effects).}";
static void * GetFirstpSignalV(VALUE value, void **arg)
{
  /* Documentation */
  if (value == NULL) return(firstpDoc);
  
  return(GetIntField(((SIGNAL) value)->firstp,arg));
}

static void * SetFirstpSignalV(VALUE value, void **arg)
{
     /* doc */
  if (value == NULL) return(firstpDoc);

 return(SetIntField(&(((SIGNAL) value)->firstp),arg,FieldPositive));
}

/*
 * 'lastp' field
 */

static char *lastpDoc = "{[= <lastp>]} {Sets/Gets the 'lastp' field of a signal ('lastp' is the index number used for storing the last index affected by border effects).}";

static void * GetLastpSignalV(VALUE value, void **arg)
{
  /* Documentation */
  if (value == NULL) return(lastpDoc);
  
  return(GetIntField(((SIGNAL) value)->lastp,arg));
}

static void * SetLastpSignalV(VALUE value, void **arg)
{
     /* doc */
  if (value == NULL) return(lastpDoc);

  return(SetIntField(&(((SIGNAL) value)->lastp),arg,FieldPositive));
}

/*
 * 'tolistv' field
 */

static char *tolistvDoc = "{} {Gets a listv made of the y-values of the signal}";

static void * GetTolistvSignalV(SIGNAL sig, void **arg)
{
  LISTV lv;
  
  /* Documentation */
  if (sig == NULL) return(tolistvDoc);
  
  lv = TNewListv();
  AppendFloatArray2Listv(lv,sig->Y,sig->size);

  return(GetValueField(lv,arg));
}



/*
 * Function to get the type of a signal
 */
static char * GetTypeSignal(VALUE value)
{
  SIGNAL s = (SIGNAL) value;
  
  if (s->size == 0) return(signalType);
  return(signaliType);
}


/*
 * Function for allocating a signal
 */
extern int flagOn;
SIGNAL NewSignal(void)
{
  extern TypeStruct tsSignal;
  SIGNAL signal;

#ifdef DEBUGALLOC
DebugType = "Signal";
#endif
  
  signal = (SIGNAL) (Malloc(sizeof(struct signal)));

  InitValue(signal,&tsSignal);
  
  signal->X = NULL;
  signal->Y = NULL;
  signal->sizeMallocX = signal->sizeMallocY =0;
  signal->size = 0;
  signal->x0 = 0;
  signal->dx = 1;
  signal->name = defaultName;
   
  signal->firstp = 0;
  signal->lastp = 0;
  signal->param = 1.;

  signal->type = YSIG;

  if (flagOn) Printf("** New Signal %p\n",signal); 

  return (signal);
}

/* Allocating a temporary signal */
SIGNAL TNewSignal(void)
{
  SIGNAL signal;
  
  signal = NewSignal();
  TempValue(signal);
  return(signal);
}



/*
 * Initialization of 'signal' and desallocation  
 * of the array of LWFLOAT signal->Y          
 */
 
void ClearSignal(SIGNAL signal)
{
  if (signal->X) {
    Free(signal->X);
    signal->X=NULL;
  }
  if (signal->Y) {
    Free(signal->Y);
    signal->Y=NULL;
  }
  signal->size = 0;
  signal->sizeMallocX = signal->sizeMallocY = 0;
  
}
    
/*