signal_alloc.c

LastWave

      if (fsi->val.r->step != 1) {
        SetErrorf("Sorry, only ranges with a step of 1 are valid indexes for this operation");
        DeleteSignal(sig);
        return(NULL);
      }
      _iold = _j+fsi->val.r->size-1;
      memcpy(sig->Y+k,sigLeft->Y+j,(_j-j)*sizeof(LWFLOAT));
      if (!flagY && sigLeft->type == XYSIG) memcpy(sig->X+k,sigLeft->X+j,(_j-j)*sizeof(LWFLOAT));
      k+=_j-j;
      if (sigRight) {
        if (sigRight->size != 0) {
          memcpy(sig->Y+k,sigRight->Y,sizeof(LWFLOAT)*sigRight->size);
          if (!flagY && sig->type == XYSIG) {
            if (sigRight->type == XYSIG) memcpy(sig->X+k,sigRight->X,sizeof(LWFLOAT)*sigRight->size);
            else for (i=0;i<sigRight->size;i++) sig->X[k+i]= sigLeft->X[(_j-1<0 ? 0 : _j-1)];
          }
          k+=sigRight->size;
        }
      }
      else {sig->Y[k]=fltRight;k++;}
      j=_j+fsi->val.r->size;
      break;
    case FSISignal :
      SetErrorf("Sorry, only ranges or numbers are valid indexes for this operation");
      DeleteSignal(sig);
      return(NULL);
    }
    FSI_FOR_END1;

    memcpy(sig->Y+k,sigLeft->Y+j,sizeof(LWFLOAT)*(sigLeft->size-j));  
    if (!flagY && sigLeft->type == XYSIG) memcpy(sig->X+k,sigLeft->X+j,sizeof(LWFLOAT)*(sigLeft->size-j));
    CopySig(sig,sigLeft);
    DeleteSignal(sig);    
    return(signaliType);
  }

  /* 
   * Case of s[range1,...,rangeN] := sig or LWFLOAT (i.e., NOT SAME SIZE)
   */   

  if (*equal == ':') {
    
    if (fsiList == NULL) {
      SetErrorf("Inadequate ':=' syntax");
      return(NULL);
    }
    /* Case of s[range1,...,rangeN] := LWFLOAT */
    if (type == numType) {
      FSI_FOR_START(fsiList);
      sigLeft->Y[_i]=fltRight;
      FSI_FOR_END;
      return(signaliType);
    }
        
    if (sigLeft->type == XYSIG) {
      SetErrorf("Sorry, cannot perform sig[...]:=sig1, where sig is an XYSig");
      return(NULL);
    }

    /* If LWFLOAT then we create signal of size 1 */
    if (sigRight == NULL) {
      sigRight = NewSignal();
      SizeSignal(sigRight,1,YSIG);
      sigRight->Y[0] = fltRight;
    }    
      
    /* We start by creating a new signal which is a copy of sig */
    sig = NewSignal();
    CopySig(sigLeft,sig);
      
    /* We must reallocate sig */
    SizeSignal(sigLeft,sig->size - fsiList->nx + fsiList->nx*sigRight->size,sig->type);
  
    /* Then we peform the set */
    j = 0; /* Index in sig */
    k = 0; /* Index in sigLeft */
    _iold = -1;
    FSI_FOR_START(fsiList);
      /* We check the fsiList is sorted */
      if (_i <= _iold) {
        SetErrorf("Sorry, this operation with non sorted indexes is not implemented");
        DeleteSignal(sig);
        if ((VALUE) sigRight != value) DeleteSignal(sigRight);
        return(NULL);
      }
      _iold = _i;
      memcpy(sigLeft->Y+k,sig->Y+j,(_i-j)*sizeof(LWFLOAT));        
      if (!flagY && sigLeft->type == XYSIG) memcpy(sigLeft->X+k,sig->X+j,(_i-j)*sizeof(LWFLOAT));        
      k+=_i-j;
      memcpy(sigLeft->Y+k,sigRight->Y,sigRight->size*sizeof(LWFLOAT));
      k+=sigRight->size;
      j=_i+1;
    FSI_FOR_END;
    memcpy(sigLeft->Y+k,sig->Y+j,(sig->size-j)*sizeof(LWFLOAT));
    if (!flagY && sigLeft->type == XYSIG) memcpy(sigLeft->X+k,sig->X+j,(sig->size-j)*sizeof(LWFLOAT));        
    DeleteSignal(sig);
    if ((VALUE) sigRight != value) DeleteSignal(sigRight);
    return(signaliType);
            
  }

  SetErrorf("Weird error");
  return(NULL);
}


/*
 * Basic routine to deal with setting fields of a signal
 */
void *SetSignalField(SIGNAL sig,void **arg)
{
  char *field = ARG_S_GetField(arg);
  FSIList *fsiList = ARG_S_GetFsiList(arg);
  char *type = ARG_S_GetRightType(arg);    
  LWFLOAT flt = ARG_S_GetRightFloat(arg);   
  VALUE value = ARG_S_GetRightValue(arg);
  char *equal = ARG_S_GetEqual(arg);

  if (SetSignalField_(sig,NULL,fsiList,flt,value,equal,NULL) == NULL) return(NULL);
  ARG_S_SetResValue(arg,(VALUE) sig);
  return(signaliType);
}  



/* 
 * Routine to deal with setting of signals
 */

static char *doc = "{[*opt,...] [:]= (<LWFLOAT> | <range> | <signal> | <listv>)} {Get/Set the signal values}"; 
static char *xdoc = "{[*opt,...] [:]= (<LWFLOAT> | <range> | <signal> | <listv>)} {Get/Set the X field of a signal}"; 
static char *ydoc = "{[*opt,...] [:]= (<LWFLOAT> | <range> | <signal> | <listv>)} {Get/set the Y field of a signal}"; 
static char *indexdoc = "{[[*nolimit],<xValue>]} {Get the index corresponding to a given <xValue>}";

static void *SetExtractSignalV(SIGNAL sig,void **arg)
{
  char *field;
  FSIList *fsiList;
  char *type;    
  LWFLOAT flt;   
  char *equal;
  VALUE value;
  
  field = ARG_S_GetField(arg);

   /* doc */
  if (sig == NULL) {
    if (field == NULL || !strcmp(field,"")) return(doc);
    if (!strcmp(field,"X")) return(xdoc);
    if (!strcmp(field,"Y")) return(ydoc);
  }

  fsiList = ARG_S_GetFsiList(arg);
  type = ARG_S_GetRightType(arg);    
  flt = ARG_S_GetRightFloat(arg);   
  value = ARG_S_GetRightValue(arg);
  equal = ARG_S_GetEqual(arg);

  if (SetSignalField_(sig,field,fsiList,flt,value,equal,NULL) == NULL) return(NULL);
  ARG_S_SetResValue(arg,(VALUE) sig);
  return(signaliType);
}
 

/* 
 * Routine to deal with getting of signals managing extraction
 */
void *GetSignalField_(SIGNAL signal, void **arg)
{
  char *field;
  FSIList *fsiList;
  LWFLOAT *pFlt;
  char **pStr;
  VALUE *pValue;
  
  int max;
  FSI_DECL;
  BorderType bt;
  SIGNAL sigResult;
  LWFLOAT xmax,xmin;
  ExtractInfo *ei;
  InterMode im;
  char flagIndex;
  LWFLOAT firstFlt;
  int n,first,last;
  char flagX,flagY;
  RANGE rg;
  int i;

  field = ARG_G_GetField(arg);
  fsiList = ARG_G_GetFsiList(arg);
  pFlt = ARG_G_GetResPFloat(arg);
  pStr = ARG_G_GetResPStr(arg);
  pValue = ARG_G_GetResPValue(arg);

  if (field == NULL && fsiList == NULL) {
    *pValue = (VALUE) signal;
    return(signaliType);
  }
  
  if (field != NULL && !strcmp(field,"index")) {
    if (fsiList == NULL) {
      SetErrorf("Field 'index' needs extraction : index[]");
      return(NULL);
    }
      
    /* 1 LWFLOAT in between the [] */
    if (fsiList->nx != 1) {
      SetErrorf("index[] expects 1 xValue only");
      return(NULL);
    }
    i = ISig(signal, FSIArray((&(fsiList->fsi[0])),0));
    if (signal->type==YSIG) {
      i = (i<0 ? 0 : i);
      i = (i>=signal->size ? signal->size-1 : i);
    }
    return(GetFloatField(i,arg));
  }
  
  
  /* case of an empty extraction */
  if (fsiList != NULL && fsiList->nx == 0) {
    *pValue = (VALUE) TNewSignal();
    return(signalType);
  }
  
  if (fsiList == NULL && field != NULL && !strcmp(field,"X")) {
    if (signal->type == XYSIG) {
      sigResult = TNewSignal();
      SizeSignal(sigResult,signal->size,YSIG);
      CopySigXX(signal,sigResult,"XY");
      *pValue = (VALUE) sigResult;
      return(signaliType);
    }
    rg = TNewRange();
    rg->first = signal->x0;
    rg->step = signal->dx;
    rg->size = signal->size;
    *pValue = (VALUE) rg;
    return(rangeType);
  }

  if (fsiList == NULL && field != NULL && !strcmp(field,"Y")) {
    sigResult = TNewSignal();
    SizeSignal(sigResult,signal->size,YSIG);
    CopySigXX(signal,sigResult,"YY");
    *pValue = (VALUE) sigResult;
    return(signaliType);
  }

  flagX = flagY = 0;
  if (field) {
    if (!strcmp(field,"X")) flagX = 1;
    else flagY = 1;
  }
  
  /* Get extractInfo */
  ei = fsiList->ei;
  xmax = ei->xmax;
  xmin = ei->xmin;
  max = signal->size;

  if (fsiList->options & FSIOptSigBPer) bt = BorderPer;
  else if (fsiList->options & FSIOptSigBMir) bt = BorderMir;
  else if (fsiList->options & FSIOptSigBMir1) bt = BorderMir1;
  else if (fsiList->options & FSIOptSigBCon) bt = BorderCon;
  else if (fsiList->options & FSIOptSigB0) bt = Border0;
  else bt = BorderNone;

  if (fsiList->options & FSIOptSigXLin) im = InterLinear;
  else im = InterNone;
 
  if (fsiList->options & (FSIOptSigX | FSIOptSigXLin)) flagIndex = NO;
  else flagIndex = YES;
  
  /*
   * Case the result will be a simple LWFLOAT
   */
  if (bt == BorderNone && fsiList->nx1 == 1 || bt != BorderNone && fsiList->nx == 1) {

    if (fsiList->options & FSIOptSigNoLimit) {
      FSI_FOR_START(fsiList); 
      if (_f<xmin || _f > xmax) continue;
      break;
      FSI_FOR_END;
    }
    else  _f =  FSIArray((&(fsiList->fsi[0])),0);

    if (field == NULL || !strcmp(field,"Y")) *pFlt = X2YSig(signal,_f,im,bt,flagIndex);
    else if (flagIndex) *pFlt = XSig(signal,(int) _f);
    else *pFlt = _f;

    return(numType);
  }

  /* 
   * Allocation of the signal result 
   */
  sigResult = TNewSignal();
  if (field != NULL || signal->type == XYSIG && !flagIndex && fsiList->size == 1 && fsiList->fsi[0].type == FSIRange) n = YSIG;
  else n = signal->type;
  if (bt != BorderNone) SizeSignal(sigResult,fsiList->nx,n);
  else SizeSignal(sigResult,fsiList->nx1,n);

  /* ????? Utiliser memcpy dans le cas de signaux XY que l'on extrait avec *x */
  
  /* The loop in the case of *nolimit */
  if (fsiList->options & FSIOptSigNoLimit) {
    FSI_FOR_START1(fsiList); 
  
    if (fsi->type == FSIRange && 
        (flagIndex && fsi->val.r->step == 1 || 
         (field == NULL && signal->type == YSIG && fsi->val.r->step == signal->dx  &&
          (fsi->val.r->first-signal->x0)/signal->dx == (int) ((fsi->val.r->first-signal->x0)/signal->dx) ))) {
         
      if (flagIndex) {
        first = (int) RangeFirst(fsi->val.r);
        last = (int) RangeLast(fsi->val.r);
        if (_k == 0) firstFlt = MAX(first,0);
      }
      else {
        first = (int) ((RangeFirst(fsi->val.r)-signal->x0)/signal->dx);
        last = (int) ((RangeLast(fsi->val.r)-signal->x0)/signal->dx);
        if (_k == 0) firstFlt = XSig(signal,MAX(first,0));
      }
      
      /* MACINTOSH "scary" bug keeps from writing just instead of the 2 lines below  
      if (signal->size<first || last <0) continue; */
      
      n = signal->size;
      if (n<=first || last <0) continue; 
      
      if (field == NULL) {
        memcpy(sigResult->Y+_k,signal->Y+MAX(first,0),(MIN(last,signal->size-1)-MAX(first,0)+1)*sizeof(LWFLOAT));
        if (sigResult->type == XYSIG) 
          memcpy(sigResult->X+_k,signal->X+MAX(first,0),(MIN(last,signal->size-1)-MAX(first,0)+1)*sizeof(LWFLOAT));
      }
      else if (!strcmp(field,"Y"))
        memcpy(sigResult->Y+_k,signal->Y+MAX(first,0),(MIN(last,signal->size-1)-MAX(first,0)+1)*sizeof(LWFLOAT));
      else
        memcpy(sigResult->Y+_k,signal->X+MAX(first,0),(MIN(last,signal->size-1)-MAX(first,0)+1)*sizeof(LWFLOAT));

      _k+=MIN(last,signal->size-1)-MAX(first,0)+1;
    }
    else {        
      FSI_FOR_START2(fsiList);
      if (_f<xmin || _f > xmax) continue;
      if (field == NULL || !strcmp(field,"Y")) sigResult->Y[_k] = X2YSig(signal,_f,im,bt,flagIndex);    
      else if (flagIndex) sigResult->Y[_k] = XSig(signal,(int) _f);
      else sigResult->Y[_k] = _f;
      if (sigResult->type == XYSIG) {
        if (flagIndex) sigResult->X[_k] = signal->X[(int) _f];
        else sigResult->X[_k] = _f;
      }
      if (_k == 0) firstFlt = _f;
      FSI_FOR_END2;
    }
    FSI_FOR_END1;
  }

  /* The loop in the generic case */
  else {
    FSI_FOR_START1(fsiList); 
    if (fsi->type == FSIRange) {
      if (flagIndex) {
        first = (int) RangeFirst(fsi->val.r);
        last = (int) RangeLast(fsi->val.r);
        if (_k == 0) firstFlt = first;
      }
      else {
        first = (int) ((RangeFirst(fsi->val.r)-signal->x0)/signal->dx);
        last = (int) ((RangeLast(fsi->val.r)-signal->x0)/signal->dx);
        if (_k == 0) firstFlt = XSig(signal,first);
      }
    }
    if (fsi->type == FSIRange && INRANGE(0,first,signal->size-1) && INRANGE(0,last,signal->size-1) &&
        (flagIndex && fsi->val.r->step == 1 || 
         (field == NULL && signal->type == YSIG && fsi->val.r->step == signal->dx  &&
          (fsi->val.r->first-signal->x0)/signal->dx == (int) ((fsi->val.r->first-signal->x0)/signal->dx) ))) {
         
      if (field == NULL) {
        memcpy(sigResult->Y+_k,signal->Y+MAX(first,0),(MIN(last,signal->size-1)-MAX(first,0)+1)*sizeof(LWFLOAT));
        if (sigResult->type == XYSIG) 
          memcpy(sigResult->X+_k,signal->X+MAX(first,0),(MIN(last,signal->size-1)-MAX(first,0)+1)*sizeof(LWFLOAT));
      }
      else if (!strcmp(field,"Y"))
        memcpy(sigResult->Y+_k,signal->Y+MAX(first,0),(MIN(last,signal->size-1)-MAX(first,0)+1)*sizeof(LWFLOAT));
      else
        memcpy(sigResult->Y+_k,signal->X+MAX(first,0),(MIN(last,signal->size-1)-MAX(first,0)+1)*sizeof(LWFLOAT));

      _k+=MIN(last,signal->size-1)-MAX(first,0)+1;
    }
    else {        
      FSI_FOR_START2(fsiList); 
      if (field == NULL || !strcmp(field,"Y")) sigResult->Y[_k] = X2YSig(signal,_f,im,bt,flagIndex);    
      else if (flagIndex) sigResult->Y[_k] = XSig(signal,(int) _f);
      else sigResult->Y[_k] = _f;
      if (sigResult->type == XYSIG) {
        if (flagIndex) sigResult->X[_k] = signal->X[(int) _f];
        else sigResult->X[_k] = _f;
      }
      if (_k == 0) firstFlt = _f;
      FSI_FOR_END2;
    }
    FSI_FOR_END1;
  }

  /* Setting the fields of the Y-signal */
  if (field == NULL) {
    if (sigResult->type == YSIG) {
      if (flagIndex) {
        if (fsiList->fsi[0].type == FSIRange) {
          if (fsiList->fsi[0].val.r->step > 0) {
            sigResult->x0 = signal->dx*((int) firstFlt)+signal->x0;
            sigResult->dx = signal->dx*fsiList->fsi[0].val.r->step;
          }
          else {
            sigResult->x0 = 0;
            sigResult->dx = -signal->dx*fsiList->fsi[0].val.r->step;
          }
        }
        else {
          sigResult->dx = signal->dx;
          sigResult->x0 = XSig(signal,(int) FSIArray((&(fsiList->fsi[0])),0));
        }
      }
      else {
        if (fsiList->fsi[0].type == FSIRange) {
          if (fsiList->fsi[0].val.r->step > 0) {
            sigResult->x0 = firstFlt;
            sigResult->dx = fsiList->fsi[0].val.r->step;
          }
          else {
            sigResult->x0 = 0;
            sigResult->dx = -fsiList->fsi[0].val.r->step;
          }
        }
        else {
          sigResult->dx = 1;
          sigResult->x0 = FSIArray((&(fsiList->fsi[0])),0);
        }
      }
    }
  }
        
  *pValue = (VALUE) sigResult;
        
  return(signaliType);
}

void *GetSignalExtractField(SIGNAL sig, void **arg)
{
  char *field = ARG_G_GetField(arg);
  void *res;
  
  ARG_G_SetField(arg,NULL);
  
  res = GetSignalField_(sig, arg);
  
  ARG_G_SetField(arg,field);

  return(res);
}

static void *GetExtractSignalV(VALUE value, void **arg)
{
  char *field = ARG_G_GetField(arg);

  /* doc */
  if (value == NULL) {
    if (field == NULL || !strcmp(field,"")) return(doc);
    if (!strcmp(field,"index")) return(indexdoc);
    if (!strcmp(field,"X")) return(xdoc);
    if (!strcmp(field,"Y")) return(ydoc);
  }
  
  return(GetSignalField_((SIGNAL) value, arg));
}


/*
 * Get the options for extraction (called for field NULL, X or Y only)
 */


static char *optionDoc = "{{*nolimit,*b0,*bconst,*bmirror,*bmirror1,*bperiodic,*x,*xlin} \
{*nolimit : indexes can be out of range} \
{*b0 : border effect with 0 value} \
{*bconst : border effect with constant values (last signal value for right handside and first signal value for left handside)} \
{*bperiodic : periodic border effect)} \
{*bmirror1 : mirror+periodic border effect (first and last points are repeated)} \
{*bmirror : mirror+periodic border effect (first and last points are NOT repeated))} \
{*x : index values are replaced by x-values. Interpolation is piece-wise constant} \
{*xlin : index values are replaced by x-values. Interpolation piece-wise linear}\
}";
static char *xoptionDoc = "{{*nolimit,*b0,*bconst,*bmirror,*bmirror1,*bperiodic,*x,*xlin} \
{*nolimit : indexes can be out of range} \
{*b0 : border effect with 0 value} \
{*bconst : border effect with constant values (last signal value for right handside and first signal value for left handside)} \
{*bperiodic : periodic border effect)} \
{*bmirror1 : mirror+periodic border effect (first and last points are repeated)} \
{*bmirror : mirror+periodic border effect (first and last points are NOT repeated))} \
{*x : index values are replaced by x-values. Interplation is piece-wise constant} \
{*xlin : index values are replaced by x-values. Interplation piece-wise linear}\
}";
static char *yoptionDoc = "{{*nolimit,*b0,*bconst,*bmirror,*bmirror1,*bperiodic,*x,*xlin} \
{*nolimit : indexes can be out of range} \
{*b0 : border effect with 0 value} \
{*bconst : border effect with constant values (last signal value for right handside and first signal value for left handside)} \
{*bperiodic : periodic border effect)} \
{*bmirror1 : mirror+periodic border effect (first and last points are repeated)} \
{*bmirror : mirror+periodic border effect (first and last points are NOT repeated))} \
{*x : index values are replaced by x-values. Interplation is piece-wise constant} \
{*xlin : index values are replaced by x-values. Interplation piece-wise linear}\
}";
static char *indexoptionDoc = "{{*nolimit} {*nolimit : indexes can be out of range}}";

static void *GetExtractOptionsSignalV(VALUE value, void **arg)
{
  SIGNAL signal;
  char *field = ARG_EO_GetField(arg);

  
   /* doc */
  if (value == NULL) {