# isSameValuef
> Test whether two single-precision complex floating-point numbers are the same value.
## Usage
```javascript
var isSameValuef = require( '@stdlib/complex/float32/base/assert/is-same-value' );
```
#### isSameValuef( z1, z2 )
Tests whether two single-precision complex floating-point numbers are the same value.
```javascript
var Complex64 = require( '@stdlib/complex/float32/ctor' );
var z1 = new Complex64( 5.0, 3.0 );
var z2 = new Complex64( 5.0, 3.0 );
var out = isSameValuef( z1, z2 );
// returns true
```
In contrast to the strict equality operator `===`, the function distinguishes between `+0` and `-0` and treats `NaNs` as the same value.
```javascript
var Complex64 = require( '@stdlib/complex/float32/ctor' );
var z1 = new Complex64( NaN, NaN );
var z2 = new Complex64( NaN, NaN );
var out = isSameValuef( z1, z2 );
// returns true
z1 = new Complex64( -0.0, 0.0 );
z2 = new Complex64( 0.0, -0.0 );
out = isSameValuef( z1, z2 );
// returns false
```
## Notes
- The function implements the [SameValue Algorithm][ecma-262-same-value-algorithm] as specified in ECMAScript 5.
## Examples
```javascript
var Complex64 = require( '@stdlib/complex/float32/ctor' );
var isSameValuef = require( '@stdlib/complex/float32/base/assert/is-same-value' );
var z1 = new Complex64( 5.0, 3.0 );
var z2 = new Complex64( 5.0, 3.0 );
var out = isSameValuef( z1, z2 );
// returns true
z1 = new Complex64( -5.0, -3.0 );
z2 = new Complex64( 5.0, 3.0 );
out = isSameValuef( z1, z2 );
// returns false
z1 = new Complex64( NaN, 3.0 );
z2 = new Complex64( NaN, 3.0 );
out = isSameValuef( z1, z2 );
// returns true
```
* * *
## C APIs
### Usage
```c
#include "stdlib/complex/float32/base/assert/is_same_value.h"
```
#### stdlib_base_complex64_is_same_value( z1, z2 )
Tests whether two single-precision complex floating-point numbers are the same value.
```c
#include "stdlib/complex/float32/ctor.h"
#include
stdlib_complex64_t z1 = stdlib_complex64( 5.0f, 2.0f );
stdlib_complex64_t z2 = stdlib_complex64( 5.0f, 2.0f );
bool v = stdlib_base_complex64_is_same_value( z1, z2 );
```
The function accepts the following arguments:
- **z1**: `[in] stdlib_complex64_t` first single-precision complex floating-point number.
- **z2**: `[in] stdlib_complex64_t` second single-precision complex floating-point number.
```c
bool stdlib_base_complex64_is_same_value( const stdlib_complex64_t z1, const stdlib_complex64_t z2 );
```
### Examples
```c
#include "stdlib/complex/float32/base/assert/is_same_value.h"
#include "stdlib/complex/float32/ctor.h"
#include
#include
int main( void ) {
const stdlib_complex64_t z[] = {
stdlib_complex64( 5.0f, 2.0f ),
stdlib_complex64( -2.0f, 1.0f ),
stdlib_complex64( 0.0f, -0.0f ),
stdlib_complex64( 0.0f/0.0f, 0.0f/0.0f )
};
bool v;
int i;
for ( i = 0; i < 4; i++ ) {
v = stdlib_base_complex64_is_same_value( z[ i ], z[ i ] );
printf( "Same value? %s\n", ( v ) ? "True" : "False" );
}
}
```
[ecma-262-same-value-algorithm]: http://ecma-international.org/ecma-262/5.1/#sec-9.12