External module "complex/base/wrap-function/docs/types/index.d"

Export assignment wrap

• wrap(fcn: Nullary, nargs: 0, ctor: Constructor): Nullary
• wrap(fcn: Unary, nargs: 1, ctor: Constructor): WrappedUnary
• wrap(fcn: Binary, nargs: 2, ctor: Constructor): WrappedBinary
• wrap(fcn: Ternary, nargs: 3, ctor: Constructor): WrappedTernary
• wrap(fcn: Quaternary, nargs: 4, ctor: Constructor): WrappedQuaternary
• wrap(fcn: Quinary, nargs: 5, ctor: Constructor): WrappedQuinary
• wrap(fcn: Nary, nargs: number, ctor: Constructor): WrappedNary

• Wraps a nullary function accepting complex number arguments to support providing both real and complex numbers.

  throws

  second argument must be a nonnegative integer

  Parameters

  • fcn: Nullary

    nullary function to wrap

  • nargs: 0

    number of arguments

  • ctor: Constructor

    complex number constructor

  Returns Nullary

  wrapped function

  Example

  var Complex64 = require( `@stdlib/complex/float32` );
  var realf = require( `@stdlib/complex/realf` );
  var imagf = require( `@stdlib/complex/imagf` );
  var randu = require( `@stdlib/random/base/randu` );
  
  function randComplex() {
      return new Complex64( randu(), randu() );
  }
  
  var f = wrap( randComplex, 0, Complex64 );
  
  // ...
  
  var z = f();
  // returns <Complex64>
  
  var re = realf( z );
  // returns <number>
  
  var im = imagf( z );
  // returns <number>

• Wraps a unary function accepting complex number arguments to support providing both real and complex numbers.

  Notes

  • The returned function assumes that the wrapped function accepts only complex number input arguments (i.e., every argument must be a complex number).
  • The returned function assumes that, if an input argument is non-numeric (i.e., not of type number), then the input argument is a complex number. The returned function does not verify that non-numeric input arguments are, in fact, complex number objects. The returned function passes non-numeric input arguments to the wrapped function without modification.

  throws

  second argument must be a nonnegative integer

  Parameters

  • fcn: Unary

    function to wrap

  • nargs: 1

    number of arguments

  • ctor: Constructor

    complex number constructor

  Returns WrappedUnary

  wrapped function

  Example

  var Complex64 = require( `@stdlib/complex/float32` );
  var cidentityf = require( `@stdlib/math/base/special/cidentityf` );
  var realf = require( `@stdlib/complex/realf` );
  var imagf = require( `@stdlib/complex/imagf` );
  
  var f = wrap( cidentityf, 1, Complex64 );
  
  // ...
  
  var z = f( 3.0 );
  // returns <Complex64>
  
  var re = realf( z );
  // returns 3.0
  
  var im = imagf( z );
  // returns 0.0

• Wraps a binary function accepting complex number arguments to support providing both real and complex numbers.

  Notes

  • The returned function assumes that the wrapped function accepts only complex number input arguments (i.e., every argument must be a complex number).
  • The returned function assumes that, if an input argument is non-numeric (i.e., not of type number), then the input argument is a complex number. The returned function does not verify that non-numeric input arguments are, in fact, complex number objects. The returned function passes non-numeric input arguments to the wrapped function without modification.

  throws

  second argument must be a nonnegative integer

  Parameters

  • fcn: Binary

    function to wrap

  • nargs: 2

    number of arguments

  • ctor: Constructor

    complex number constructor

  Returns WrappedBinary

  wrapped function

  Example

  var Complex64 = require( `@stdlib/complex/float32` );
  var cadd = require( `@stdlib/math/base/ops/cadd` );
  var realf = require( `@stdlib/complex/realf` );
  var imagf = require( `@stdlib/complex/imagf` );
  
  var f = wrap( cadd, 2, Complex64 );
  
  // ...
  
  var z = f( 3.0, 4.0 );
  // returns <Complex64>
  
  var re = realf( z );
  // returns 7.0
  
  var im = imagf( z );
  // returns 0.0

• Wraps a ternary function accepting complex number arguments to support providing both real and complex numbers.

  Notes

  • The returned function assumes that the wrapped function accepts only complex number input arguments (i.e., every argument must be a complex number).
  • The returned function assumes that, if an input argument is non-numeric (i.e., not of type number), then the input argument is a complex number. The returned function does not verify that non-numeric input arguments are, in fact, complex number objects. The returned function passes non-numeric input arguments to the wrapped function without modification.

  throws

  second argument must be a nonnegative integer

  Parameters

  • fcn: Ternary

    function to wrap

  • nargs: 3

    number of arguments

  • ctor: Constructor

    complex number constructor

  Returns WrappedTernary

  wrapped function

  Example

  var Complex64 = require( `@stdlib/complex/float32` );
  var realf = require( `@stdlib/complex/realf` );
  var imagf = require( `@stdlib/complex/imagf` );
  
  function add( x, y, z ) {
      var re = realf( x ) + realf( y ) + realf( z );
      var im = imagf( x ) + imagf( y ) + imagf( z );
      return new Complex64( re, im );
  }
  
  var f = wrap( add, 3, Complex64 );
  
  // ...
  
  var z = f( 3.0, 4.0, 5.0 );
  // returns <Complex64>
  
  var re = realf( z );
  // returns 12.0
  
  var im = imagf( z );
  // returns 0.0

• Wraps a quaternary function accepting complex number arguments to support providing both real and complex numbers.

  Notes

  • The returned function assumes that the wrapped function accepts only complex number input arguments (i.e., every argument must be a complex number).
  • The returned function assumes that, if an input argument is non-numeric (i.e., not of type number), then the input argument is a complex number. The returned function does not verify that non-numeric input arguments are, in fact, complex number objects. The returned function passes non-numeric input arguments to the wrapped function without modification.

  throws

  second argument must be a nonnegative integer

  Parameters

  • fcn: Quaternary

    function to wrap

  • nargs: 4

    number of arguments

  • ctor: Constructor

    complex number constructor

  Returns WrappedQuaternary

  wrapped function

  Example

  var Complex64 = require( `@stdlib/complex/float32` );
  var realf = require( `@stdlib/complex/realf` );
  var imagf = require( `@stdlib/complex/imagf` );
  
  function add( x, y, z, w ) {
      var re = realf( x ) + realf( y ) + realf( z ) + realf( w );
      var im = imagf( x ) + imagf( y ) + imagf( z ) + imagf( w );
      return new Complex64( re, im );
  }
  
  var f = wrap( add, 4, Complex64 );
  
  // ...
  
  var z = f( 3.0, 4.0, 5.0, 6.0 );
  // returns <Complex64>
  
  var re = realf( z );
  // returns 18.0
  
  var im = imagf( z );
  // returns 0.0

• Wraps a quinary function accepting complex number arguments to support providing both real and complex numbers.

  Notes

  • The returned function assumes that the wrapped function accepts only complex number input arguments (i.e., every argument must be a complex number).
  • The returned function assumes that, if an input argument is non-numeric (i.e., not of type number), then the input argument is a complex number. The returned function does not verify that non-numeric input arguments are, in fact, complex number objects. The returned function passes non-numeric input arguments to the wrapped function without modification.

  throws

  second argument must be a nonnegative integer

  Parameters

  • fcn: Quinary

    function to wrap

  • nargs: 5

    number of arguments

  • ctor: Constructor

    complex number constructor

  Returns WrappedQuinary

  wrapped function

  Example

  var Complex64 = require( `@stdlib/complex/float32` );
  var realf = require( `@stdlib/complex/realf` );
  var imagf = require( `@stdlib/complex/imagf` );
  
  function add( x, y, z, w, v ) {
      var re = realf( x ) + realf( y ) + realf( z ) + realf( w ) + realf( v );
      var im = imagf( x ) + imagf( y ) + imagf( z ) + imagf( w ) + imagf( v );
      return new Complex64( re, im );
  }
  
  var f = wrap( add, 5, Complex64 );
  
  // ...
  
  var z = f( 3.0, 4.0, 5.0, 6.0, 7.0 );
  // returns <Complex64>
  
  var re = realf( z );
  // returns 25.0
  
  var im = imagf( z );
  // returns 0.0

• Wraps an n-ary function accepting complex number arguments to support providing both real and complex numbers.

  Notes

  • The returned function assumes that the wrapped function accepts only complex number input arguments (i.e., every argument must be a complex number).
  • The returned function assumes that, if an input argument is non-numeric (i.e., not of type number), then the input argument is a complex number. The returned function does not verify that non-numeric input arguments are, in fact, complex number objects. The returned function passes non-numeric input arguments to the wrapped function without modification.

  throws

  second argument must be a nonnegative integer

  Parameters

  • fcn: Nary

    function to wrap

  • nargs: number

    number of arguments

  • ctor: Constructor

    complex number constructor

  Returns WrappedNary

  wrapped function

  Example

  var Complex64 = require( `@stdlib/complex/float32` );
  var realf = require( `@stdlib/complex/realf` );
  var imagf = require( `@stdlib/complex/imagf` );
  
  function add( x, y, z, w, v, t ) {
      var re = realf( x ) + realf( y ) + realf( z ) + realf( w ) + realf( v ) + realf( t );
      var im = imagf( x ) + imagf( y ) + imagf( z ) + imagf( w ) + imagf( v ) + imagf( t );
      return new Complex64( re, im );
  }
  
  var f = wrap( add, 6, Complex64 );
  
  // ...
  
  var z = f( 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 );
  // returns <Complex64>
  
  var re = realf( z );
  // returns 33.0
  
  var im = imagf( z );
  // returns 0.0