Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

feat: add support for Complex128 and native addon in cround API #1007

Merged
merged 7 commits into from
Jul 14, 2023
Merged

feat: add support for Complex128 and native addon in cround API #1007

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
fcbed0b
feat: add support for Complex128 and native addon in cround API
steff456 May 15, 2023
1f8538d
fix: add review changes
steff456 Jul 11, 2023
807c13d
docs: update description
steff456 Jul 11, 2023
98a3593
Apply suggestions from code review
kgryte Jul 14, 2023
cdbd6b3
fix: fix manifest json spacing
steff456 Jul 14, 2023
b00de1e
Merge branch 'cround-addon' of github.com:stdlib-js/stdlib into croun…
steff456 Jul 14, 2023
0736db6
fix: fix manifest.json
steff456 Jul 14, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
186 changes: 151 additions & 35 deletions lib/node_modules/@stdlib/math/base/special/cround/README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,9 +18,9 @@ limitations under the License.

-->

# Round
# cround

> Round a complex number to the nearest integer.
> Round each component of a double-precision complex floating-point number to the nearest integer.

<section class="usage">

Expand All @@ -30,36 +30,50 @@ limitations under the License.
var cround = require( '@stdlib/math/base/special/cround' );
```

#### cround( \[out,] re, im )
#### cround( z )

Rounds a `complex` number comprised of a **real** component `re` and an **imaginary** component `im` to the nearest integer.
Rounds each component of a double-precision complex floating-point number to the nearest integer.

```javascript
var v = cround( -4.2, 5.5 );
// returns [ -4.0, 6.0 ]
var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

v = cround( 9.99999, 0.1 );
// returns [ 10.0, 0.0 ]
var v = cround( new Complex128( -4.2, 5.5 ) );
// returns <Complex128>

v = cround( 0.0, 0.0 );
// returns [ 0.0, 0.0 ]
var re = real( v );
// returns -4.0

v = cround( NaN, NaN );
// returns [ NaN, NaN ]
```
var im = imag( v );
// returns 6.0

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.
v = cround( new Complex128( 9.99999, 0.1 ) );
// returns <Complex128>

```javascript
var Float64Array = require( '@stdlib/array/float64' );
re = real( v );
// returns 10.0

im = imag( v );
// returns 0.0

v = cround( new Complex128( 0.0, 0.0 ) );
// returns <Complex128>

re = real( v );
// returns 0.0

var out = new Float64Array( 2 );
im = imag( v );
// returns 0.0

var v = cround( out, -4.2, 5.5 );
// returns <Float64Array>[ -4.0, 6.0 ]
v = cround( new Complex128( NaN, NaN ) );
// returns <Complex128>

var bool = ( v === out );
// returns true
re = real( v );
// returns NaN

im = imag( v );
// returns NaN
```

</section>
Expand All @@ -73,33 +87,135 @@ var bool = ( v === out );
<!-- eslint no-undef: "error" -->

```javascript
var uniform = require( '@stdlib/random/base/uniform' ).factory;
var Complex128 = require( '@stdlib/complex/float64' );
var randu = require( '@stdlib/random/base/randu' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );
var cround = require( '@stdlib/math/base/special/cround' );

var re;
var im;
var rand = uniform( -50.0, 50.0 );

var z;
var o;
var w;
var i;

for ( i = 0; i < 100; i++ ) {
re = ( randu()*100.0 ) - 50.0;
im = ( randu()*100.0 ) - 50.0;
z = new Complex128( re, im );
o = cround( real(z), imag(z) );
w = new Complex128( o[ 0 ], o[ 1 ] );
console.log( 'round(%s) = %s', z.toString(), w.toString() );
z = new Complex128( rand(), rand() );
console.log( 'cround(%s) = %s', z, cround( z ) );
}
```

</section>

<!-- /.examples -->

<!-- C interface documentation. -->

* * *

<section class="c">

## C APIs

<!-- Section to include introductory text. Make sure to keep an empty line after the intro `section` element and another before the `/section` close. -->

<section class="intro">

</section>

<!-- /.intro -->

<!-- C usage documentation. -->

<section class="usage">

### Usage

```c
#include "stdlib/math/base/special/cround.h"
```

#### stdlib_base_cround( z )

Rounds each component of a double-precision complex floating-point number to the nearest integer.

```c
#include "stdlib/complex/float64.h"
#include "stdlib/complex/real.h"
#include "stdlib/complex/imag.h"

stdlib_complex128_t z = stdlib_complex128( -4.2, 5.5 );

stdlib_complex128_t out = stdlib_base_cround( z );

double re = stdlib_real( out );
// returns -4.0

double im = stdlib_imag( out );
// returns 6.0
```

The function accepts the following arguments:

- **z**: `[in] stdlib_complex128_t` input value.

```c
stdlib_complex128_t stdlib_base_cround( const stdlib_complex128_t z );
```

</section>

<!-- /.usage -->

<!-- C API usage notes. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->

<section class="notes">

</section>

<!-- /.notes -->

<!-- C API usage examples. -->

<section class="examples">

### Examples

```c
#include "stdlib/math/base/special/cround.h"
#include "stdlib/complex/float64.h"
#include "stdlib/complex/reim.h"
#include <stdio.h>

int main( void ) {
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_cround( v );
stdlib_reim( v, &re1, &im1 );
stdlib_reim( y, &re2, &im2 );
printf( "cround(%lf + %lfi) = %lf + %lfi\n", re1, im1, re2, im2 );
}
}
```

</section>

<!-- /.examples -->

</section>

<!-- /.c -->

<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->

<section class="related">
Expand Down
101 changes: 15 additions & 86 deletions lib/node_modules/@stdlib/math/base/special/cround/benchmark/benchmark.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,108 +21,37 @@
// MODULES //

var bench = require( '@stdlib/bench' );
var randu = require( '@stdlib/random/base/randu' );
var isArray = require( '@stdlib/assert/is-array' );
var round = require( '@stdlib/math/base/special/round' );
var uniform = require( '@stdlib/random/base/uniform' );
var isnan = require( '@stdlib/math/base/assert/is-nan' );
var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );
var pkg = require( './../package.json' ).name;
var cround = require( './../lib' );


// MAIN //

bench( pkg, function benchmark( b ) {
var re;
var im;
var values;
var y;
var i;

b.tic();
for ( i = 0; i < b.iterations; i++ ) {
re = ( randu()*1000.0 ) - 500.0;
im = ( randu()*1000.0 ) - 500.0;
y = cround( re, im );
if ( y.length === 0 ) {
b.fail( 'should not be empty' );
}
}
b.toc();
if ( !isArray( y ) ) {
b.fail( 'should return an array' );
}
b.pass( 'benchmark finished' );
b.end();
});

bench( pkg+'::memory_reuse', function benchmark( b ) {
var out;
var re;
var im;
var y;
var i;

out = new Array( 2 );

b.tic();
for ( i = 0; i < b.iterations; i++ ) {
re = ( randu()*1000.0 ) - 500.0;
im = ( randu()*1000.0 ) - 500.0;
y = cround( out, re, im );
if ( y.length === 0 ) {
b.fail( 'should not be empty' );
}
}
b.toc();
if ( !isArray( y ) ) {
b.fail( 'should return an array' );
}
b.pass( 'benchmark finished' );
b.end();
});

bench( pkg+'::manual', function benchmark( b ) {
var re;
var im;
var y;
var i;

b.tic();
for ( i = 0; i < b.iterations; i++ ) {
re = ( randu()*1000.0 ) - 500.0;
im = ( randu()*1000.0 ) - 500.0;
y = [ round( re ), round( im ) ];
if ( y.length === 0 ) {
b.fail( 'should not be empty' );
}
}
b.toc();
if ( !isArray( y ) ) {
b.fail( 'should return an array' );
}
b.pass( 'benchmark finished' );
b.end();
});

bench( pkg+'::manual,memory_reuse', function benchmark( b ) {
var re;
var im;
var y;
var i;

y = new Array( 2 );
values = [
new Complex128( uniform( -500.0, 500.0 ), uniform( -500.0, 500.0 ) ),
new Complex128( uniform( -500.0, 500.0 ), uniform( -500.0, 500.0 ) )
];

b.tic();
for ( i = 0; i < b.iterations; i++ ) {
re = ( randu()*1000.0 ) - 500.0;
im = ( randu()*1000.0 ) - 500.0;
y[ 0 ] = round( re );
y[ 1 ] = round( im );
if ( y.length === 0 ) {
b.fail( 'should not be empty' );
y = cround( values[ i%values.length ] );
if ( isnan( real( y ) ) ) {
b.fail( 'should not return NaN' );
}
}
b.toc();
if ( !isArray( y ) ) {
b.fail( 'should return an array' );
if ( isnan( imag( y ) ) ) {
b.fail( 'should not return not NaN' );
}
b.pass( 'benchmark finished' );
b.end();
Expand Down
Loading
Loading