diff --git a/lib/node_modules/@stdlib/math/base/special/cceiln/README.md b/lib/node_modules/@stdlib/math/base/special/cceiln/README.md
index bd000c6d34f4..15a94db42b67 100644
--- a/lib/node_modules/@stdlib/math/base/special/cceiln/README.md
+++ b/lib/node_modules/@stdlib/math/base/special/cceiln/README.md
@@ -18,9 +18,9 @@ limitations under the License.
-->
-# ceiln
+# cceiln
-> Round a complex number to the nearest multiple of `10^n` toward positive infinity.
+> Round each component of a double-precision complex floating-point number to the nearest multiple of `10^n` toward positive infinity.
@@ -30,39 +30,56 @@ limitations under the License.
var cceiln = require( '@stdlib/math/base/special/cceiln' );
```
-#### cceiln( \[out,] re, im, n )
+#### cceiln( z, n )
-Rounds a `complex` number comprised of a **real** component `re` and an **imaginary** component `im` to the nearest multiple of `10^n` toward positive infinity.
+Rounds each component of a double-precision complex floating-point number to the nearest multiple of `10^n` toward positive infinity.
```javascript
+var Complex128 = require( '@stdlib/complex/float64' );
+var real = require( '@stdlib/complex/real' );
+var imag = require( '@stdlib/complex/imag' );
+
// Round components to 2 decimal places:
-var v = cceiln( -3.141592653589793, 3.141592653589793, -2 );
-// returns [ -3.14, 3.15 ]
+var z = new Complex128( -3.141592653589793, 3.141592653589793 );
+var v = cceiln( z, -2 );
+// returns
+
+var re = real( v );
+// returns -3.14
+
+var im = imag( v );
+// returns 3.15
// If n = 0, `cceiln` behaves like `cceil`:
-v = cceiln( -3.141592653589793, 3.141592653589793, 0 );
-// returns [ -3.0, 4.0 ]
+z = new Complex128( 9.99999, 0.1 );
+v = cceiln( z, 0 );
+// returns
-// Round components to the nearest thousand:
-v = cceiln( -12368.0, 12368.0, 3 );
-// returns [ -12000.0, 13000.0 ]
+re = real( v );
+// returns 10.0
-v = cceiln( NaN, NaN, 0 );
-// returns [ NaN, NaN ]
-```
+im = imag( v );
+// returns 1.0
+
+// Round components to the nearest thousand:
+z = new Complex128( 12368.0, -12368.0 );
+v = cceiln( z, 3 );
+// returns
-By default, the function returns real and imaginary components as a two-element `array`. To avoid unnecessary memory allocation, the function supports providing an output (destination) object.
+re = real( v );
+// returns 13000.0
-```javascript
-var Float32Array = require( '@stdlib/array/float32' );
+im = imag( v );
+// returns -12000.0
-var out = new Float32Array( 2 );
+v = cceiln( new Complex128( NaN, NaN ), 2 );
+// returns
-var v = cceiln( out, -4.2, 5.5, 0 );
-// returns [ -4.0, 6.0 ]
+re = real( v );
+// returns NaN
-var bool = ( v === out );
-// returns true
+im = imag( v );
+// returns NaN
```
@@ -76,12 +93,22 @@ var bool = ( v === out );
- When operating on [floating-point numbers][ieee754] in bases other than `2`, rounding to specified digits can be **inexact**. For example,
```javascript
+ var Complex128 = require( '@stdlib/complex/float64' );
+ var real = require( '@stdlib/complex/real' );
+ var imag = require( '@stdlib/complex/imag' );
+
var x = 0.2 + 0.1;
// returns 0.30000000000000004
// Should round components to 0.3:
- var v = cceiln( x, x, -16 );
- // returns [ 0.3000000000000001, 0.3000000000000001 ]
+ var v = cceiln( new Complex128( x, x ), -16 );
+ // returns
+
+ var re = real( v );
+ // returns 0.3000000000000001
+
+ var im = imag( v );
+ // returns 0.3000000000000001
```
@@ -95,31 +122,130 @@ var bool = ( v === out );
```javascript
+var uniform = require( '@stdlib/random/base/uniform' ).factory;
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ).factory;
var Complex128 = require( '@stdlib/complex/float64' );
-var randu = require( '@stdlib/random/base/randu' );
var ceil = require( '@stdlib/math/base/special/ceil' );
-var real = require( '@stdlib/complex/real' );
-var imag = require( '@stdlib/complex/imag' );
var cceiln = require( '@stdlib/math/base/special/cceiln' );
-var re;
-var im;
+var rand1 = uniform( -50.0, 50.0 );
+var rand2 = discreteUniform( -5.0, 0.0 );
+
var z;
-var o;
-var w;
-var n;
var i;
-
+var n;
for ( i = 0; i < 100; i++ ) {
- re = ( randu()*100.0 ) - 50.0;
- im = ( randu()*100.0 ) - 50.0;
- z = new Complex128( re, im );
+ n = rand2();
+ z = new Complex128( rand1(), rand1() );
+ console.log( 'cceiln(%s, %s) = %s', z, n, cceiln( z, n ) );
+}
+```
+
+
+
+
+
+
+
+* * *
+
+
+
+## C APIs
+
+
+
+
- n = ceil( randu()*5.0 );
- o = cceiln( real(z), imag(z), -n );
- w = new Complex128( o[ 0 ], o[ 1 ] );
+
- console.log( 'ceiln(%s,%s) = %s', z.toString(), n.toString(), w.toString() );
+
+
+
+
+### Usage
+
+```c
+#include "stdlib/math/base/special/cceiln.h"
+```
+
+#### stdlib_base_cceiln( z, n )
+
+Rounds each component of a double-precision complex floating-point number to the nearest multiple of `10^n` toward positive infinity.
+
+```c
+#include "stdlib/complex/float64.h"
+#include "stdlib/complex/real.h"
+#include "stdlib/complex/imag.h"
+
+stdlib_complex128_t z = stdlib_complex128( -3.141592653589793, 3.141592653589793 );
+
+stdlib_complex128_t out = stdlib_base_cceiln( z, -2 );
+
+double re = stdlib_real( out );
+// returns -3.14
+
+double im = stdlib_imag( out );
+// returns 3.15
+```
+
+The function accepts the following arguments:
+
+- **z**: `[in] stdlib_complex128_t` input value.
+- **n**: `[in] int32_t` integer power of 10.
+
+```c
+stdlib_complex128_t stdlib_base_cceiln( const stdlib_complex128_t z, int32_t n );
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```c
+#include "stdlib/math/base/special/cceiln.h"
+#include "stdlib/complex/float64.h"
+#include "stdlib/complex/reim.h"
+#include
+
+int main() {
+ const stdlib_complex128_t x[] = {
+ stdlib_complex128( 3.14, 1.5 ),
+ stdlib_complex128( -3.14, -1.5 ),
+ stdlib_complex128( 0.0, 0.0 ),
+ stdlib_complex128( 0.0/0.0, 0.0/0.0 )
+ };
+
+ stdlib_complex128_t v;
+ stdlib_complex128_t y;
+ double re1;
+ double im1;
+ double re2;
+ double im2;
+ int i;
+ for ( i = 0; i < 4; i++ ) {
+ v = x[ i ];
+ y = stdlib_base_cceiln( v, -2 );
+ stdlib_reim( v, &re1, &im1 );
+ stdlib_reim( y, &re2, &im2 );
+ printf( "cceiln(%lf + %lfi, -2) = %lf + %lfi\n", re1, im1, re2, im2 );
+ }
}
```
@@ -127,6 +253,10 @@ for ( i = 0; i < 100; i++ ) {
+
+
+
+