ne, ~=

Determine whether real-world values of two arrays are not equal

Syntax

A ~= B

ne(A,B)

Description

A ~= B returns a logical array with elements set to logical 1 (true) where the real-world values of A and B are not equal, when A or B is a fi object. Otherwise, the element is logical 0 (false). The test compares both real and imaginary parts of numeric arrays.

In relational operations comparing a floating-point value to a fixed-point value, the floating-point value is cast to a fixed-point type that preserves the relative order of the value with respect to the value in the fixed-point fi object.

ne(A,B) is an alternate way to execute A ~= B, but is rarely used.

Examples

Compare Two fi Objects

Use the ne function to determine whether the real-world values of two fi objects are not equal.

a = fi(pi);
b = fi(pi, 1, 32);
a ~= b

ans = logical
   1

Input a has a 16-bit word length, while input b has a 32-bit word length. The ne function returns 1 because after quantization, the value of a is greater than that of b.

Compare a Double to a fi Object

When comparing a double to a fi object, the floating-point double is cast to a type that preserves the relative order of the value with respect to the value in the fixed-point fi object. This behavior allows relational operations to work between fi objects and floating-point constants without introducing floating-point values in generated code.

a = fi(pi);
b = pi;
ne(a,b)

ans = logical
   1

Input Arguments

A,B — Operands

scalars | vectors | matrices | multidimensional arrays

Operands, specified as scalars, vectors, matrices, or multidimensional arrays. Inputs A and B must either be the same size or have sizes that are compatible. For more information, see Compatible Array Sizes for Basic Operations.

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | fi
Complex Number Support: Yes

Extended Capabilities

C/C++ Code Generation

Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

• Fixed-point signals with different biases are not supported.

HDL Code Generation
Generate VHDL, Verilog and SystemVerilog code for FPGA and ASIC designs using HDL Coder™.

Version History

Introduced before R2006a

R2022a: Implicit expansion change affects arguments for operators

Starting in R2022a with the addition of implicit expansion for fi ne, some combinations of arguments for basic operations that previously returned errors now produce results.

If your code uses element-wise operators and relies on the errors that MATLAB^® previously returned for mismatched sizes, particularly within a try/catch block, then your code might no longer catch those errors.

For more information on the required input sizes for basic array operations, see Compatible Array Sizes for Basic Operations.

R2022a: Improved accuracy in comparing fi objects and floating-point numbers using relational operators

In previous releases, when comparing a single or double to a fi object, the floating-point value was cast to the same word length and signedness of the fi object. This could lead to incorrect results. For example,

fi(0,0,8) > [-1,10]

ans =

  1×2 logical array

   0   0

fi(65534)
fi(65534.25) == 65534.25

ans = 

       65534

          DataTypeMode: Fixed-point: binary point scaling
            Signedness: Signed
            WordLength: 16
        FractionLength: -1

ans =

  logical

   1

Starting in R2022a, relational operators comparing fi objects to floating-point numbers will always return the mathematically correct behavior. The previous examples now gives these results:

fi(0,0,8) > [-1,10]

ans =

  1×2 logical array

   1   0

Note that the updated algorithm may produce subtle, but accurate, results. For example:

fi(pi) == pi

ans =

  logical

   0

Simulation results for relational operations between fi objects and floating-point singles or doubles may be more accurate than in previous releases. The updated algorithm requires a modest wordlength growth of 3 bits or fewer, which may lead to slight changes in efficiency in simulation.