## `solvelib::conditionalSort` -- possible sortings of a list depending on parameters

#### Introduction

`solvelib::conditionalSort``(l)` sorts the list `l` in ascending order. Unlike for `sort`, only the usual order on the real numbers and not the internal order (see `sysorder`) is used. `solvelib::conditionalSort` does a case analysis if list elements contain indeterminates.

#### Call(s)

`solvelib::conditionalSort(l)`

#### Parameters

`l` | - | list of arithmetical expressions

#### Returns

A list if the sorting is the same for all possible parameter values; or an object of type `piecewise` if some case analysis is necessary.

#### Side Effects

`solvelib::conditionalSort` takes into account the assumptions on all occurring identifiers.

#### Related Functions

`sort`, `piecewise`

#### Details

- `solvelib::conditionalSort` invokes the inequality solver to get simple conditions in the case analysis. The ability of `solvelib::conditionalSort` to recognize sortings as impossible is thus limited by the ability of the inequality solver to recognize an inequality as unsolvable. See Example 2.
- Only expressions representing real numbers can be sorted. It is an error if non-real numbers occur in the list; it is implicitly assumed that all parameters take on only such values that cause all list elements to be real.
- Sorting is unstable, i.e. equal elements may be placed in any order in the resulting list; these cases may be listed separately in the case analysis.
- The usual simplifications for piecewise defined objects are applied, e.g., equalities that can be derived from a condition are applied (by substitution) to the list.

#### Example 1

In the simplest case, sorting a two-element list `[a,b]` just amounts to solving the inequation `a<=b` w.r.t. all occuring parameters.

    >> solvelib::conditionalSort([x,x^2])

                      2
          piecewise([x , x] if 0 <= x and x <= 1,

                  2
             [x, x ] if (x < 0 or 1 < x))

#### Example 2

Sometimes cases are not recognized as impossible.

    >> assume(x>5): solvelib::conditionalSort([x,exp(x)])

          piecewise([exp(x), x] if - x + exp(x) <= 0,

             [x, exp(x)] if x - exp(x) < 0)

#### Background

- The complexity of sorting a list of n elements is up to n!.

#### Changes

- new function

Do you have questions or comments?
Copyright © SciFace Software GmbH & Co. KG 2000