Ordinamento

Esistono diverse varianti ORDER disponibili:
Ascendente - ORDER, ORDERSTRICT - ORDERINDEX, ORDERINDEXSTRICT
Discendente - ORDERDESC, ORDERDESCSTRICT - ORDERINDEXDESC, ORDERINDEXDESCSTRICT

ORDER#

La funzione ORDER ordina i valori di input forniti in ordine crescente e li restituisce in una nuova collezione. Accetta n valori (fino a 100 argomenti) o una singola collezione. I valori non devono necessariamente essere numerici, ma devono essere confrontabili (ad es. numeri, TIMESPAN, DATETIME, stringhe). Tipi misti (ad es. numeri e stringhe) non sono consentiti. NaN e NULL sono ignorati ed esclusi dalla collezione restituita.

ORDER( n1, n2, n3 , … )
ORDER( collection )

Esempi:

ORDER(3, 1, 2)				= {1, 2, 3}
ORDER(1)					= {1}
ORDER(3, NaN, 2, NaN)		= {2, 3}
ORDER(NaN)					= {}
ORDER('Z', 'a', 'X')				= {'X', 'Z', 'a'}
ORDER(“str1”, “STR2”, “stR1”} 		= {"STR2", "stR1", "str1"}
ORDER(“str1”, NULL, “STR2”, “stR1”} = {"STR2", "stR1", "str1"}

ORDER(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {TIMESPAN(0,0,0,0,99), TIMESPAN(0,0,0,0,100)}
ORDER(NULL, TIMESPAN(0,0,0,0,99)					= {TIMESPAN(0,0,0,0,99)}

ORDERINDEX#

La funzione ORDERINDEX ordina i valori di input in modo crescente, ma invece di restituire i valori ordinati, restituisce una collezione di indici che indicano le posizioni dei valori originali nell’ordine ordinato. Accetta n valori (fino a 100 argomenti) o una singola collezione. I valori non devono necessariamente essere numerici, ma devono essere confrontabili (ad es. numeri, TIMESPAN, DATETIME, stringhe). Tipi misti non sono consentiti. NaN e NULL sono ignorati ed esclusi dalla collezione restituita.

ORDERINDEX( n1, n2, n3 , … )
ORDERINDEX( collection )

Esempi:

ORDERINDEX(3, 1, 2)				= {1, 2, 0}
ORDERINDEX(1)					= {0}
ORDERINDEX(3, NaN, 2, NaN)		= {2, 0}
ORDERINDEX(NaN)					= {}
ORDERINDEX('Z', 'a', 'X')				= {2, 0, 1}
ORDERINDEX(“str1”, “STR2”, “stR1”} 		= {1, 2, 0}
ORDERINDEX(“str1”, NULL, “STR2”, “stR1”} = {2, 3, 0}

ORDERINDEX(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {1, 0}
ORDERINDEX(NULL, TIMESPAN(0,0,0,0,99)					= {1}

ORDERSTRICT#

La funzione ORDERSTRICT ordina i valori di input in modo crescente e li restituisce in una nuova collezione. Può accettare n valori (fino a 100 argomenti) o una singola collezione. I valori non devono necessariamente essere numerici, ma devono essere confrontabili (ad es. numeri, TIMESPAN, DATETIME, stringhe). Tipi misti non sono consentiti. NaN e NULL sono inclusi e sempre ordinati per primi nel risultato.

ORDERSTRICT( n1, n2, n3 , … )
ORDERSTRICT( collection )

Esempi:

ORDERSTRICT(3, 1, 2)			= {1, 2, 3}
ORDERSTRICT(1)					= {1}
ORDERSTRICT(3, NaN, 2, NaN)		= {NaN, NaN, 2, 3}
ORDERSTRICT(NaN)				= {NaN}
ORDERSTRICT('Z', 'a', 'X')		= {'X', 'Z', 'a'}
ORDERSTRICT(“str1”, “STR2”, “stR1”} 		= {"STR2", "stR1", "str1"}
ORDERSTRICT(“str1”, NULL, “STR2”, “stR1”}	= {NULL, "STR2", "stR1", "str1"}

ORDERSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {TIMESPAN(0,0,0,0,99), TIMESPAN(0,0,0,0,100)}
ORDERSTRICT(NULL, TIMESPAN(0,0,0,0,99)					= {NULL, TIMESPAN(0,0,0,0,99)}

ORDERINDEXSTRICT#

La funzione ORDERINDEXSTRICT ordina i valori di input in modo crescente, simile a ORDERSTRICT. Tuttavia, invece di restituire i valori ordinati, restituisce una collezione di indici che indicano le posizioni dei valori originali nell’ordine ordinato. Accetta n valori (fino a 100 argomenti) o una singola collezione. I valori non devono necessariamente essere numerici, ma devono essere confrontabili (ad es. numeri, TIMESPAN, DATETIME, stringhe). Tipi misti non sono consentiti. NaN e NULL sono inclusi e sempre ordinati per primi nel risultato.

ORDERINDEXSTRICT( n1, n2, n3 , … )
ORDERINDEXSTRICT( collection )

Esempi:

ORDERINDEXSTRICT(3, 1, 2)				= {1, 2, 0}
ORDERINDEXSTRICT(1)						= {0}
ORDERINDEXSTRICT(3, NaN, 2, NaN)		= {1, 3, 2, 0}
ORDERINDEXSTRICT(NaN)					= {0}
ORDERINDEXSTRICT('Z', 'a', 'X')			= {2, 0, 1}
ORDERINDEXSTRICT(“str1”, “STR2”, “stR1”}		= {1, 2, 0}
ORDERINDEXSTRICT(“str1”, NULL, “STR2”, “stR1”}	= {1, 2, 3, 0}

ORDERINDEXSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {1, 0}
ORDERINDEXSTRICT(NULL, TIMESPAN(0,0,0,0,99)					= {0, 1}

ORDERDESC#

La funzione ORDERDESC ordina i valori di input forniti in ordine decrescente e li restituisce in una nuova collezione. Accetta n valori (fino a 100 argomenti) o una singola collezione. I valori non devono necessariamente essere numerici, ma devono essere confrontabili (ad es. numeri, TIMESPAN, DATETIME, stringhe). Tipi misti non sono consentiti. NaN e NULL sono ignorati ed esclusi dalla collezione restituita.

ORDERDESC( n1, n2, n3 , … )
ORDERDESC( collection )

Esempi:

ORDERDESC(3, 1, 2)					= {3, 2, 1}
ORDERDESC(1)						= {1}
ORDERDESC(3, NaN, 2, NaN)			= {3, 2}
ORDERDESC(NaN)						= {}
ORDERDESC('Z', 'a', 'X')			= {'a', 'Z', 'X'}
ORDERDESC(“str1”, “STR2”, “stR1”} 	= {"str1", "stR1", "STR2"}
ORDERDESC(“str1”, NULL, “STR2”, “stR1”} 	= {"str1", "stR1", "STR2"}

ORDERDESC(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)}
ORDERDESC(NULL, TIMESPAN(0,0,0,0,99)					= {TIMESPAN(0,0,0,0,99)}

ORDERINDEXDESC#

La funzione ORDERINDEXDESC ordina i valori di input in modo decrescente, simile a ORDERDESC. Tuttavia, invece di restituire i valori ordinati, restituisce una collezione di indici che indicano le posizioni dei valori originali nell’ordine ordinato. Accetta n valori (fino a 100 argomenti) o una singola collezione. I valori non devono necessariamente essere numerici, ma devono essere confrontabili (ad es. numeri, TIMESPAN, DATETIME, stringhe). Tipi misti non sono consentiti. NaN e NULL sono ignorati ed esclusi dalla collezione restituita.

ORDERINDEXDESC( n1, n2, n3 , … )
ORDERINDEXDESC( collection )

Esempi:

ORDERINDEXDESC(3, 1, 2)				= {0, 2, 1}
ORDERINDEXDESC(1)					= {0}
ORDERINDEXDESC(3, NaN, 2)			= {0, 2}
ORDERINDEXDESC(NaN)					= {}
ORDERINDEXDESC('Z', 'a', 'X')					= {1, 0, 2}
ORDERINDEXDESC(“str1”, “STR2”, “stR1”} 			= {0, 2, 1}
ORDERINDEXDESC(“str1”, NULL, “STR2”, “stR1”} 	= {0, 3, 2}

ORDERINDEXDESC(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {0, 1}
ORDERINDEXDESC(NULL, TIMESPAN(0,0,0,0,99)					= {1}

ORDERDESCSTRICT#

La funzione ORDERDESCSTRICT ordina i valori di input in modo decrescente e li restituisce in una nuova collezione. Può accettare n valori (fino a 100 argomenti) o una singola collezione. I valori non devono necessariamente essere numerici, ma devono essere confrontabili (ad es. numeri, TIMESPAN, DATETIME, stringhe). Tipi misti non sono consentiti. NaN e NULL sono inclusi e sempre ordinati per primi nel risultato.

ORDERDESCSTRICT( n1, n2, n3 , … )
ORDERDESCSTRICT( collection )

Esempi:

ORDERDESCSTRICT(3, 1, 2)			= {3, 2, 1}
ORDERDESCSTRICT(1)					= {1}
ORDERDESCSTRICT(3, NaN, 2, NaN)		= {NaN, NaN, 3, 2}
ORDERDESCSTRICT(NaN)				= {NaN}
ORDERDESCSTRICT('Z', 'a', 'X')					= {'a', 'Z', 'X'}
ORDERDESCSTRICT(“str1”, “STR2”, “stR1”} 		= {"str1", "stR1", "STR2"}
ORDERDESCSTRICT(“str1”, NULL, “STR2”, “stR1”} 	= {NULL, "str1", "stR1", "STR2"}

ORDERDESCSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)}
ORDERDESCSTRICT(NULL, TIMESPAN(0,0,0,0,99)					= {NULL, TIMESPAN(0,0,0,0,99)}

ORDERINDEXDESCSTRICT#

La funzione ORDERINDEXDESCSTRICT ordina i valori di input in modo decrescente, simile a ORDERDESC. Tuttavia, invece di restituire i valori ordinati, restituisce una collezione di indici che indicano le posizioni dei valori originali nell’ordine ordinato. Accetta n valori (fino a 100 argomenti) o una singola collezione. I valori non devono necessariamente essere numerici, ma devono essere confrontabili (ad es. numeri, TIMESPAN, DATETIME, stringhe). Tipi misti non sono consentiti. NaN e NULL sono inclusi e sempre ordinati per primi nel risultato.

ORDERINDEXDESCSTRICT( n1, n2, n3 , … )
ORDERINDEXDESCSTRICT( collection )

Esempi:

ORDERINDEXDESCSTRICT(3, 1, 2)				= {0, 2, 1}
ORDERINDEXDESCSTRICT(1)						= {0}
ORDERINDEXDESCSTRICT(3, NaN, 2, NaN)		= {1, 3, 0, 2}
ORDERINDEXDESCSTRICT(NaN)					= {0}
ORDERINDEXDESCSTRICT('Z', 'a', 'X')			= {1, 0, 2}
ORDERINDEXDESCSTRICT(“str1”, “STR2”, “stR1”}		= {0, 2, 1}
ORDERINDEXDESCSTRICT(“str1”, NULL, “STR2”, “stR1”} 	= {1, 0, 3, 2}

ORDERINDEXDESCSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)	= {0, 1}
ORDERINDEXDESCSTRICT(NULL, TIMESPAN(0,0,0,0,99)						= {0, 1}