Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://reference.wolfram.com/language/ref/NumericalOrder.html below:

NumericalOrder—Wolfram Language Documentation

We deliver solutions for the AI era—combining symbolic computation, data-driven insights and deep technology expertise.

• Data & Computational Intelligence
• Model-Based Design
• Algorithm Development
• Wolfram|Alpha for Business
• Blockchain Technology
• Education Technology
• Quantum Computation

WolframConsulting.com

• See Also
  • NumericalSort
  • TakeSmallest
  • TakeLargest
  • Sort
  • Order
  • LexicographicOrder
  • AlphabeticOrder
  • Less
  • Greater
  • Equal
• Related Guides
  • Numerical Functions
  • Testing Expressions

NumericalOrder[e₁,e₂]

gives 1 if e₁<e₂, -1 if e₁>e₂, 0 if e₁ and e₂ are numerically the same, and orders by type or using canonical order if e₁ and e₂ are not numerically comparable.

• NumericalOrder provides a general alternative to canonical order in which numeric expressions, dates and Quantity objects are treated by value.
• Numeric expressions are sorted by real part first, and by absolute value of the imaginary part if the real parts coincide.
• Quantity expressions with compatible units are compared to each other by magnitude after converting them to a common unit.
• DateObject expressions are compared to each other by AbsoluteTime.
• TimeObject expressions are compared to each other by AbsoluteTime.
• If e₁ and e₂ are both numerical but cannot be compared, they will be sorted in the order numeric expressions, quantities, dates and times.
• Numerical expressions always precede non-numerical ones.
• If neither e₁ nor e₂ has a numerical value, NumericalOrder[e₁,e₂] is the same as Order[e₁,e₂].
• NumericalOrder compares inexact numbers using all available significant digits. Unlike Equal, it does not allow any extra tolerance.
• NumericalOrder can be used as an ordering function in functions like Sort, OrderedQ or Ordering.

These two numbers are not ordered:

These two are numerically the same:

Compare numeric expressions:

This is not always the same as the canonical order of expressions:

Compare quantities:

Compare dates:

Compare any two numeric expressions:

-∞ comes before any real-valued expression:

∞ comes after any real-valued expression:

Complex valued expressions are ordered first by the real part:

When the real part is numerically the same, they are ordered by the absolute value of the imaginary part:

Compare quantities of compatible units:

The comparison is performed by converting into a common unit:

DateObject expressions are ordered by AbsoluteTime:

Use NumericalOrder as ordering function:

Sort using the ordering permutation:

The resulting list is not ordered in canonical order, but it is ordered in numerical order:

Get the numerical ordering for a list:

For numeric expressions of different value, NumericalOrder compares them using those values:

Order always compares expressions structurally and may give different results:

Like Order, NumericalOrder is an antisymmetric function of expressions: NumericalOrder[e₁,e₂]==-NumericalOrder[e₂,e₁]:

Unlike Order, NumericalOrder[e₁,e₂] may return zero for non-identical e₁, e₂:

For comparable expressions e₁, e₂ a result NumericalOrder[e₁,e₂]0 implies e₁-e₂==0:

NumericalOrder compares inexact numbers using all available significant digits:

For machine-precision numbers, Less, Equal, Greater, etc. use 7 bits of tolerance:

Inexact numbers with any other precision are compared up to that precision:

NumericalOrder compares complex values by the real part and then by absolute value of the imaginary part:

This is consistent with Order for numbers:

Less, LessEqual and related functions cannot compare complex numbers:

Equivalent quantities have a NumericalOrder of 0:

The canonical order distinguishes between the two representations:

Use Equal to show that they are indeed equivalent quantities:

For non-numerical expressions e₁, e₂, NumericalOrder coincides with Order:

Sorting with NumericalOrder will not guarantee a particular ordering for different representations of the same number:

This does not give the same result for a permutation of the list:

The canonical order will rearrange in a definite way:

A stricter order can be defined by using Order to resolve cases where NumericalOrder gives 0:

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4