G:/ScriptBasic/source/commands/mathfunc.c

Go to the documentation of this file.

/*mathfunc.c

--GNU LGPL
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <math.h>
#include <limits.h>

#include "../command.h"

/* this function is defined in mathops.c */
long *RaiseError(pExecuteObject pEo);

#define GET_ONE_ARG USE_CALLER_MORTALS; nItem = PARAMETERLIST; Op1 = EVALUATEEXPRESSION(CAR(nItem)); NONULOP(Op1)


/*POD
=H Mathematical Functions

This file defines all the mathematical functions that are implemented in ScriptBasic.
CUT*/


COMMAND(POW)
#if NOTIMP_POW
NOTIMPLEMENTED;
#else


  NODE nItem;
  VARIABLE Op1;
  double dResult;

  GET_ONE_ARG

  RETURN_DOUBLE_VALUE_OR_LONG( pow(10.0,GETDOUBLEVALUE(Op1)) )

#endif
END


COMMAND(EXP)
#if NOTIMP_EXP
NOTIMPLEMENTED;
#else


  NODE nItem;
  VARIABLE Op1;
  double dResult;

  GET_ONE_ARG
  RETURN_DOUBLE_VALUE_OR_LONG( exp(GETDOUBLEVALUE(Op1)) )

#endif
END

COMMAND(LOG)
#if NOTIMP_LOG
NOTIMPLEMENTED;
#else

  NODE nItem;
  VARIABLE Op1;
  double dop1,dResult;

  GET_ONE_ARG

  dop1 = GETDOUBLEVALUE(Op1);
  if( dop1 <= 0.0 ){
    ERRORUNDEF
    }
  RETURN_DOUBLE_VALUE_OR_LONG( log(dop1) )

#endif
END

COMMAND(LOG10)
#if NOTIMP_LOG10
NOTIMPLEMENTED;
#else

  NODE nItem;
  VARIABLE Op1;
  double dop1,dResult;

  GET_ONE_ARG

  dop1 = GETDOUBLEVALUE(Op1);
  if( dop1 <= 0.0 ){
    ERRORUNDEF
    }
  RETURN_DOUBLE_VALUE_OR_LONG( log10(dop1) )

#endif
END

COMMAND(SIN)
#if NOTIMP_SIN
NOTIMPLEMENTED;
#else


  NODE nItem;
  VARIABLE Op1;
  double dResult;

  GET_ONE_ARG

  RETURN_DOUBLE_VALUE_OR_LONG( sin(GETDOUBLEVALUE(Op1)) )

#endif
END

COMMAND(ASIN)
#if NOTIMP_ASIN
NOTIMPLEMENTED;
#else


  NODE nItem;
  VARIABLE Op1;
  double dop1,dResult;

  GET_ONE_ARG

  dop1 = GETDOUBLEVALUE(Op1);
  if( dop1 < -1 || dop1 > +1 ){
    ERRORUNDEF
    }
  RETURN_DOUBLE_VALUE_OR_LONG( asin(dop1) )

#endif
END

COMMAND(ACOS)
#if NOTIMP_ACOS
NOTIMPLEMENTED;
#else

  NODE nItem;
  VARIABLE Op1;
  double dop1,dResult;

  GET_ONE_ARG

  dop1 = GETDOUBLEVALUE(Op1);
  if( dop1 < -1 || dop1 > +1 ){
    ERRORUNDEF
    }
  RETURN_DOUBLE_VALUE_OR_LONG( acos(dop1) )

#endif
END

COMMAND(COS)
#if NOTIMP_COS
NOTIMPLEMENTED;
#else


  NODE nItem;
  VARIABLE Op1;
  double dResult;

  GET_ONE_ARG

  RETURN_DOUBLE_VALUE_OR_LONG( cos(GETDOUBLEVALUE(Op1)) )

#endif
END

COMMAND(RND)
#if NOTIMP_RND
NOTIMPLEMENTED;
#else

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;
  RETURN_DOUBLE_VALUE( rand() )

#endif
END

COMMAND(RANDOMIZA)
#if NOTIMP_RANDOMIZA
NOTIMPLEMENTED;
#else
  time_t timer;
  srand(time(&timer));

#endif
END

COMMAND(RANDOMIZE)
#if NOTIMP_RANDOMIZE
NOTIMPLEMENTED;
#else
  time_t timer;
  NODE nItem;
  VARIABLE ItemResult;

  nItem = PARAMETERNODE;
  if( nItem ){
    ItemResult = _EVALUATEEXPRESSION_A(nItem);
    ASSERTOKE;
    if( ItemResult )
      srand(GETLONGVALUE(ItemResult));
    else
      srand(time(&timer));
    }else{
    srand(time(&timer));
    }

#endif
END

/*SGN
=display SGN()
=section math

Calculates the signum of the argument. This is -1 for negative numbers, +1 for positive numbers and 0 for zero. The return value is always long except that  T<SGN(undef)> may return T<undef>. If the argument is a string it is converted to long or double.

T<SGN(undef)> is T<undef> or raises an error if the option T<RaiseMatherror> is set in bit T<sbMathErrUndef>.
*/
COMMAND(SGN)
#if NOTIMP_SGN
NOTIMPLEMENTED;
#else


  NODE nItem;
  VARIABLE Op1;
  double dop1;
  long lop1,result;

  GET_ONE_ARG

  if( ISINTEGER(Op1) ){
    lop1 = GETLONGVALUE(Op1);
    if( lop1 == 0 )result = 0;
    else if( lop1 > 0 )result = 1;
    else result = -1;
    }else{
    dop1 = GETDOUBLEVALUE(Op1);
    if( dop1 == 0.0 )result = 0;
    else if( dop1 > 0 )result = 1;
    else result = -1;
    }

  RETURN_LONG_VALUE( result );

#endif
END

COMMAND(SQR)
#if NOTIMP_SQR
NOTIMPLEMENTED;
#else


  NODE nItem;
  VARIABLE Op1;
  double dResult;
  long lSquare,lop1;
  double dop1;

  GET_ONE_ARG

  if( ISINTEGER(Op1) ){
    lop1 = GETLONGVALUE(Op1);
    /* we return undef or raise error based on OPTION setting */
    if( lop1 < 0 ){
      ERRORUNDEF
      }
    /* calculate the square root of the argument */
    dResult = sqrt((double)lop1);
    /* round the result and convert to long to check if it can be handles as a long*/
    lSquare = (long) floor(dResult + 0.5);
    /* if the square of the rounded result is the same as the argument then it can be returned as a long */
    if( lSquare * lSquare == lop1 ){
      RETURN_LONG_VALUE(lSquare)
      }
    /* if it can not be converted to long w/o loosing precision then return the 'double' value */
    RETURN_DOUBLE_VALUE(dResult)
    }

  /* if the argument is double */
  dop1 = GETDOUBLEVALUE(Op1);
  /* we return undef or raise error based on OPTION setting */
  if( dop1 < 0 ){
    ERRORUNDEF
    }
  /* if the argument was double then the result is double */
  RETURN_DOUBLE_VALUE( sqrt(dop1) )
#endif
END

COMMAND(ABS)
#if NOTIMP_ABS
NOTIMPLEMENTED;
#else


  NODE nItem;
  VARIABLE Op1;
  long lop1;
  double dop1;

  GET_ONE_ARG

  if( ISINTEGER(Op1) ){
    /* if the argument is long then the ABS value of it is also long*/
    lop1 = GETLONGVALUE(Op1);
    /* ... with the only exception of LONG_MAX because ABS(LONG_MIN) is LONG_MAX-1 usually (two's complement) */
    /* if ever you implement ScriptBasic on a machine that uses different signed integer not two's complement then you have to rewrite it */
    if( lop1 < LONG_MAX ){
      RETURN_LONG_VALUE( lop1 > 0 ? lop1 : -lop1 );
      }else{
      RETURN_DOUBLE_VALUE( -(double)lop1 );
      }
    }
  /* if the argument is double then the result will also be double */
  dop1 = GETDOUBLEVALUE(Op1);
  RETURN_DOUBLE_VALUE( dop1 > 0.0 ? dop1 : -dop1 );
#endif
END

COMMAND(VAL)
#if NOTIMP_VAL
NOTIMPLEMENTED;
#else


  NODE nItem;
  VARIABLE Op1;

  GET_ONE_ARG

  if( TYPE(Op1) == VTYPE_STRING ){
    if( ISSTRINGINTEGER(Op1) )
      RESULT = CONVERT2LONG(Op1);
    else
      RESULT = CONVERT2DOUBLE(Op1);
    }else{
    RESULT = Op1;
    }

#endif
END

COMMAND(MAXINT)
#if NOTIMP_MAXINT
NOTIMPLEMENTED;
#else

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  RETURN_LONG_VALUE(LONG_MAX)

#endif
END

COMMAND(MININT)
#if NOTIMP_MININT
NOTIMPLEMENTED;
#else

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  RETURN_LONG_VALUE(LONG_MIN)

#endif
END

COMMAND(PI)
#if NOTIMP_PI
NOTIMPLEMENTED;
#else

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  RETURN_DOUBLE_VALUE(3.1415926)

#endif
END

COMMAND(UNDEF)
#if NOTIMP_UNDEF
NOTIMPLEMENTED;
#else


  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  RESULT = NULL;

#endif
END

COMMAND(TRUE)
#if NOTIMP_TRUE
NOTIMPLEMENTED;
#else


  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;
  RETURN_LONG_VALUE( -1L )

#endif
END

COMMAND(FALSE)
#if NOTIMP_FALSE
NOTIMPLEMENTED;
#else


  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  RETURN_LONG_VALUE( 0L )

#endif
END

COMMAND(FIX)
#if NOTIMP_FIX
NOTIMPLEMENTED;
#else


  NODE nItem;
  VARIABLE Op1;
  double dop1;
  long   lop1;
  int isneg;

  GET_ONE_ARG

  if( ISINTEGER(Op1) ){
    RETURN_LONG_VALUE( GETLONGVALUE(Op1) )
    }
  dop1 = GETDOUBLEVALUE(Op1);
  if( isneg = dop1 < 0 )dop1 =  -dop1;
  dop1 = floor(dop1);
  if( isneg )dop1 = - dop1;
  lop1 = (long)dop1;
  if( dop1 == (double)lop1 ){
    RETURN_LONG_VALUE( lop1 );
    }

  RETURN_DOUBLE_VALUE( dop1 );

#endif
END

COMMAND(INT)
#if NOTIMP_INT
NOTIMPLEMENTED;
#else


  NODE nItem;
  VARIABLE Op1;
  double dop1;
  long   lop1;

  GET_ONE_ARG

  if( ISINTEGER(Op1) ){
    RETURN_LONG_VALUE( GETLONGVALUE(Op1) )
    }

  dop1 = floor(GETDOUBLEVALUE(Op1));
  lop1 = (long)dop1;
  if( dop1 == (double)lop1 ){
    RETURN_LONG_VALUE( lop1 );
    }

  RETURN_DOUBLE_VALUE( dop1 );

#endif
END


COMMAND(FRAC)
#if NOTIMP_FRAC
NOTIMPLEMENTED;
#else


  NODE nItem;
  VARIABLE Op1;
  double dop1;

  GET_ONE_ARG

  if( ISINTEGER(Op1) ){
    RETURN_DOUBLE_VALUE( 0.0 )
    }

  dop1 = GETDOUBLEVALUE(Op1);
  if( dop1 < 0 ){
    RETURN_DOUBLE_VALUE( dop1 - floor(dop1) -1 )
    }else{
    RETURN_DOUBLE_VALUE( dop1 - floor(dop1) )
    }

#endif
END


COMMAND(ROUND)
#if NOTIMP_ROUND
NOTIMPLEMENTED;
#else


  NODE nItem;
  VARIABLE Op1;
  long iNumberOfDigits,lop1;
  double Multiplier,dop1;

  GET_ONE_ARG

  nItem = CDR(nItem);

  iNumberOfDigits = 0;
  if( nItem ){
    iNumberOfDigits = GETLONGVALUE(EVALUATEEXPRESSION(CAR(nItem)));
    ASSERTOKE;
    }
  if( iNumberOfDigits < 0 )iNumberOfDigits = 0;
  if( iNumberOfDigits > 100 )iNumberOfDigits = 100;

  if( ISINTEGER(Op1) ){
    RETURN_LONG_VALUE( GETLONGVALUE(Op1) )
    }

  dop1 = GETDOUBLEVALUE(Op1);
  if( iNumberOfDigits == 0 ){
    dop1 = floor( dop1 + 0.5);
    lop1 = (long)dop1;
    if( dop1 == (double)lop1 ){
      RETURN_LONG_VALUE( lop1 )
      }else{
      RETURN_DOUBLE_VALUE( dop1 )
      }
    }
  Multiplier = 1.0;
  while( iNumberOfDigits -- )Multiplier *= 10.0;
  dop1 *= Multiplier;
  dop1 += 0.5;
  dop1 = floor(dop1);

  dop1 /= Multiplier;
  lop1 = (long)dop1;
  if( dop1 == (double)lop1 ){
    RETURN_LONG_VALUE( lop1 )
    }else{
     RETURN_DOUBLE_VALUE( dop1 )
   }
#endif
END

COMMAND(GCD)
#if NOTIMP_GCD
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END

COMMAND(LCM)
#if NOTIMP_LCM
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END

COMMAND(ODD)
#if NOTIMP_ODD
NOTIMPLEMENTED;
#else


  NODE nItem;
  VARIABLE Op1;

  GET_ONE_ARG

  RESULT = NEWMORTALLONG;

  if( GETLONGVALUE(Op1) & 1 )
    LONGVALUE(RESULT) = -1;
  else
    LONGVALUE(RESULT) = 0;

#endif
END

COMMAND(EVEN)
#if NOTIMP_EVEN
NOTIMPLEMENTED;
#else


  NODE nItem;
  VARIABLE Op1;

  GET_ONE_ARG

  RESULT = NEWMORTALLONG;
  ASSERTNULL(RESULT)

  if( GETLONGVALUE(Op1) & 1 )
    LONGVALUE(RESULT) = 0;
  else
    LONGVALUE(RESULT) = -1;

#endif
END

COMMAND(LBOUND)
#if NOTIMP_LBOUND
NOTIMPLEMENTED;
#else

  VARIABLE ItemResult;
  NODE nItem;

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  nItem = PARAMETERLIST;
  ItemResult = _EVALUATEEXPRESSION_A(CAR(nItem));
  NONULOP(ItemResult)

  switch( TYPE(ItemResult) ){
    case VTYPE_LONG:
    case VTYPE_DOUBLE:
    case VTYPE_STRING:
      RESULT = NULL;
      RETURN;
    case VTYPE_ARRAY:
      RESULT = NEWMORTALLONG;
      ASSERTNULL(RESULT)
      LONGVALUE(RESULT) = ItemResult->ArrayLowLimit;
      RETURN;
    }

#endif
END

COMMAND(UBOUND)
#if NOTIMP_UBOUND
NOTIMPLEMENTED;
#else

  VARIABLE ItemResult;
  NODE nItem;

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  nItem = PARAMETERLIST;
  ItemResult = _EVALUATEEXPRESSION_A(CAR(nItem));
  NONULOP(ItemResult)

  switch( TYPE(ItemResult) ){
    case VTYPE_LONG:
    case VTYPE_DOUBLE:
    case VTYPE_STRING:
      RESULT = NULL;
      RETURN;
    case VTYPE_ARRAY:
      RESULT = NEWMORTALLONG;
      ASSERTNULL(RESULT)
      LONGVALUE(RESULT) = ItemResult->ArrayHighLimit;
      RETURN;
    }

#endif
END

COMMAND(ISARRAY)
#if NOTIMP_ISARRAY
NOTIMPLEMENTED;
#else

  VARIABLE ItemResult;
  NODE nItem;

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  nItem = PARAMETERLIST;
  ItemResult = _EVALUATEEXPRESSION_A(CAR(nItem));
  ASSERTOKE;

  if( memory_IsUndef(ItemResult) ){
    RETURN_FALSE
    }
  switch( TYPE(ItemResult) ){
    case VTYPE_LONG:
    case VTYPE_DOUBLE:
    case VTYPE_STRING:
      RETURN_FALSE
    case VTYPE_ARRAY:
      RETURN_TRUE
    }

#endif
END

COMMAND(ISSTRING)
#if NOTIMP_ISSTRING
NOTIMPLEMENTED;
#else

  VARIABLE ItemResult;
  NODE nItem;

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  nItem = PARAMETERLIST;
  ItemResult = _EVALUATEEXPRESSION_A(CAR(nItem));
  ASSERTOKE;

  if( memory_IsUndef(ItemResult) ){
    RETURN_FALSE
    }
  switch( TYPE(ItemResult) ){
    case VTYPE_LONG:
    case VTYPE_DOUBLE:
    case VTYPE_ARRAY:
      RETURN_FALSE
    case VTYPE_STRING:
      RETURN_TRUE
    }

#endif
END

COMMAND(ISLONG)
#if NOTIMP_ISLONG
NOTIMPLEMENTED;
#else

  VARIABLE ItemResult;
  NODE nItem;

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  nItem = PARAMETERLIST;
  ItemResult = _EVALUATEEXPRESSION_A(CAR(nItem));
  ASSERTOKE;

  if( memory_IsUndef(ItemResult) ){
    RETURN_FALSE
    }
  switch( TYPE(ItemResult) ){
    case VTYPE_DOUBLE:
    case VTYPE_ARRAY:
    case VTYPE_STRING:
      RETURN_FALSE
    case VTYPE_LONG:
      RETURN_TRUE
    }

#endif
END

COMMAND(ISDOUBLE)
#if NOTIMP_ISDOUBLE
NOTIMPLEMENTED;
#else

  VARIABLE ItemResult;
  NODE nItem;

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  nItem = PARAMETERLIST;
  ItemResult = _EVALUATEEXPRESSION_A(CAR(nItem));
  ASSERTOKE;

  if( memory_IsUndef(ItemResult) ){
    RETURN_FALSE
    }
  switch( TYPE(ItemResult) ){
    case VTYPE_ARRAY:
    case VTYPE_STRING:
    case VTYPE_LONG:
      RETURN_FALSE
    case VTYPE_DOUBLE:
      RETURN_TRUE
    }

#endif
END

COMMAND(ISNUMERIC)
#if NOTIMP_ISNUMERIC
NOTIMPLEMENTED;
#else

  VARIABLE ItemResult;
  NODE nItem;

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  nItem = PARAMETERLIST;
  ItemResult = _EVALUATEEXPRESSION_A(CAR(nItem));
  ASSERTOKE;

  if( memory_IsUndef(ItemResult) ){
    RETURN_FALSE
    }
  switch( TYPE(ItemResult) ){
    case VTYPE_ARRAY:
    case VTYPE_STRING:
      RETURN_FALSE
    case VTYPE_LONG:
    case VTYPE_DOUBLE:
      RETURN_TRUE
    }
#endif
END

COMMAND(ISDEF)
#if NOTIMP_ISDEF
NOTIMPLEMENTED;
#else

  VARIABLE ItemResult;
  NODE nItem;

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  nItem = PARAMETERLIST;
  ItemResult = _EVALUATEEXPRESSION_A(CAR(nItem));
  ASSERTOKE;

  if( memory_IsUndef(ItemResult) ){
    RETURN_FALSE
    }
  RETURN_TRUE
#endif
END

COMMAND(ISUNDEF)
#if NOTIMP_ISUNDEF
NOTIMPLEMENTED;
#else

  VARIABLE ItemResult;
  NODE nItem;

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  nItem = PARAMETERLIST;
  ItemResult = _EVALUATEEXPRESSION_A(CAR(nItem));
  ASSERTOKE;

  if( memory_IsUndef(ItemResult) ){
    RETURN_TRUE
    }
  RETURN_FALSE
#endif
END

COMMAND(ISEMPTY)
#if NOTIMP_ISEMPTY
NOTIMPLEMENTED;
#else

  VARIABLE ItemResult;
  NODE nItem;

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  nItem = PARAMETERLIST;
  ItemResult = _EVALUATEEXPRESSION_A(CAR(nItem));
  ASSERTOKE;

  if( memory_IsUndef(ItemResult) ||
     ( TYPE(ItemResult) == VTYPE_STRING && STRLEN(ItemResult) == 0 ) ){
    RETURN_TRUE
    }
  RETURN_FALSE
#endif
END

COMMAND(TYPE)
#if NOTIMP_TYPE
NOTIMPLEMENTED;
#else

  VARIABLE ItemResult;
  NODE nItem;

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  nItem = PARAMETERLIST;
  ItemResult = _EVALUATEEXPRESSION_A(CAR(nItem));
  ASSERTOKE;

  RESULT = NEWMORTALLONG;
  ASSERTNULL(RESULT)

  if( memory_IsUndef(ItemResult) ){
    LONGVALUE(RESULT) = 0;
    RETURN;
    }
  switch( TYPE(ItemResult) ){
    case VTYPE_LONG:
      LONGVALUE(RESULT) = 3;
      break;
    case VTYPE_DOUBLE:
      LONGVALUE(RESULT) = 2;
      break;
    case VTYPE_STRING:
      LONGVALUE(RESULT) = 1;
      break;
    case VTYPE_ARRAY:
      LONGVALUE(RESULT) = 4;
      break;
    }
#endif
END

COMMAND(ATN)
#if NOTIMP_ATN
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END

COMMAND(ATAN)
#if NOTIMP_ATAN 
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END

COMMAND(TAN)
#if NOTIMP_TAN 
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END


COMMAND(TAN2)
#if NOTIMP_TAN2
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END


COMMAND(COTAN)
#if NOTIMP_COTAN 
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END


COMMAND(COTAN2)
#if NOTIMP_COTAN2
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END


COMMAND(ACTAN)
#if NOTIMP_ACTAN 
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END


COMMAND(SECANT)
#if NOTIMP_SECANT 
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END


COMMAND(COSECANT)
#if NOTIMP_COSECANT 
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END


COMMAND(ASECANT)
#if NOTIMP_ASECANT 
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END


COMMAND(ACOSECANT)
#if NOTIMP_ACOSECANT 
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END


COMMAND(HSIN)
#if NOTIMP_HSIN 
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END


COMMAND(HCOS)
#if NOTIMP_HCOS 
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END


COMMAND(HTAN)
#if NOTIMP_HTAN 
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END


COMMAND(HCTAN)
#if NOTIMP_HCTAN 
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END


COMMAND(HSECANT)
#if NOTIMP_HSECANT 
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END


COMMAND(HCOSECANT)
#if NOTIMP_HCOSECANT 
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END

COMMAND(MAX)
#if NOTIMP_MAX
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END

COMMAND(MIN)
#if NOTIMP_MIN
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END

COMMAND(IMAX)
#if NOTIMP_IMAX
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END

COMMAND(IMIN)
#if NOTIMP_IMIN
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END

---