how to deal with multiple waveform families as input for the special functions defined for calculator

Hi Yi,

If the first argument is a family, and subsequent arguments are families, they should be expanded too at the same time - there's no need to use abUnwrapFamily() - I've had to use that in special cases only to solve specific issues - but not when I'm expecting to provide a consistent result in ADE. 

See the example below - this should work with two families passed in (provided the families are consistent - I've not tested how this works with heterogenous data):

/* abApplyToTwoWaves.il

Author     A.D.Beckett
Group      Custom IC (UK), Cadence Design Systems Ltd.
Language   SKILL
Date       May 28, 2014 
Modified   
By         

NOTE: Doesn't work that well yet... (mainly calculator bit,
function itself is fine)

Function to apply a binary function (i.e. two arguments) to
every element of a pair of waveforms. For example:

abApplyToTwoWaves(lambda((a b) if(abs(a)<abs(b) a-b 0.0)) wave1 wave2)

or

abApplyToTwoWaves('myFunc wave1 wave2)

(where myFunc takes two arguments and operates on numbers, say).

Can also add to the Skill User Defined Function using:

abRegApplyToTwoWavesSpecialFunction()

***************************************************

SCCS Info: @(#) abApplyToTwoWaves.il 05/28/14.16:30:05 1.1

*/

/***************************************************************
*                                                              *
*                (abCreateApplyToTwoWavesForm)                 *
*                                                              *
*      Create the form needed to enter the function name       *
*                                                              *
***************************************************************/
(defun abCreateApplyToTwoWavesForm ()
  (let (func)
    (setq func (ahiCreateStringField
                 ?name 'func
                 ?prompt "Function"
                 ?value "plus"
                 )
          )
    (calCreateSpecialFunctionsForm
      'abApplyToTwoWavesForm
      (list (list func 0:0 280:20 140))
      )
    )
  )

/***************************************************************
*                                                              *
*             (abApplyToTwoWavesSpecialFunctionCB)             *
*                                                              *
*            Callback for the registration function            *
*                                                              *
***************************************************************/
(defun abApplyToTwoWavesSpecialFunctionCB ()
  (calCreateSpecialFunction
    ?formSym 'abApplyToTwoWavesForm
    ?formInitProc 'abCreateApplyToTwoWavesForm
    ?formTitle "Apply to Wave"
    ?formCallback "abApplyToTwoWavesFormCB()"
    )
  )

/********************************************************************
*                                                                   *
*                     (abApplyToTwoWavesFormCB)                     *
*                                                                   *
* Callback for the form. Bit complicated because need the arguments *
* to be with the waveform not first, and with a single quote before *
*                        the function name.                         *
*                                                                   *
********************************************************************/
(defun abApplyToTwoWavesFormCB ()
  (let (form)
    (setq form (hiGetCurrentForm))
    ; messy - because can't build expression easily.
    (calCalcInput
      'expression
      (sprintf nil "' %s %s"
               (concat (getq (getq form func) value))
               (calGetBuffer))
      )
    (calSpecialFunctionInput 'abApplyToTwoWaves list('STACK))
    t
    )
  )

/******************************************************************
*                                                                 *
*              (abRegApplyToTwoWavesSpecialFunction)              *
*                                                                 *
* Function to actually register the user defined special function *
*                                                                 *
******************************************************************/
(defun abRegApplyToTwoWavesSpecialFunction ()
  (calRegisterSpecialFunction
    (list "abApplyToTwoWaves" 'abApplyToTwoWavesSpecialFunctionCB)
    )
  t
  )

/******************************************************************
*                                                                 *
*                 (abApplyToTwoWaves func arg)                    *
*                                                                 *
*  And finally, the function that does the work. You give it the  *
*  name of a binary function (takes two arguments) which works on *
*    numbers, and then this is applied to all members of the two  *
*                waveforms. Handles families too.                 *
*                                                                 *
******************************************************************/
(defun abApplyToTwoWaves (func arg1 arg2)
  (cond 
    ((numberp arg1) (funcall func arg1 arg2))
    ((drIsDataVector arg1) (vecMap 'abApplyToTwoWaves func arg1 arg2))
    ((drIsWaveform arg1) 
     ;-------------------------------------------------------------------
     ; Create new waveform, but transfer units if not set on 
     ; new waveform already. This ensures plotting on the same y-axis
     ;-------------------------------------------------------------------
     (let (new yVec)
       (setq new (wfMap 'abApplyToTwoWaves func arg1 arg2))
       (setq yVec (drGetWaveformYVec new))
       (unless (getq yVec units)
         (putpropq yVec (getq (drGetWaveformYVec arg1) units) units)
         )
       new
       )
     )
    ((famIsFamily arg1) (famMap 'abApplyToTwoWaves func arg1 arg2))
    (t
      (error "abApplyToTwoWaves: can't apply %L to %L and %L\n"
             func arg1 arg2)
      )
    )
  )

Regards,

Andrew.