C'è qualche motivo per cui la maggior parte dei linguaggi di programmazione non ha operatori '!>' (Non maggiore di) e '! <' (Non inferiore a)?

Mi chiedo se c'è qualche motivo - o se è solo un incidente della storia - che non ci sono !>e !<operatori nella maggior parte dei linguaggi di programmazione?

a >= b (un OR maggiore è uguale a b) potrebbe essere scritto come !(a < b) (a NON minore b) , che è uguale a !< b.

Questa domanda mi ha colpito quando ero nel mezzo della codifica del mio generatore di alberi di espressioni. La maggior parte dei linguaggi di programmazione ha a != boperatore per !(a=b), quindi perché no !>e !<?

AGGIORNARE:

• !<(non minore) è più facile da pronunciare di >=(maggiore o uguale)
• !<(non inferiore) è più breve da digitare di >=(maggiore o uguale)
• !<(non inferiore) è più facile da capire * di >=(maggiore o uguale)

* poiché ORè un operatore binario di cui il cervello ha bisogno per operare due operandi (grattugia, uguale), mentre NOTè un operatore unario e il cervello deve operare solo con un operando (minore).

Il linguaggio di programmazione D e l'estensione di DMC a C e C ++ hanno supportato questi operatori (tutte e 14 le combinazioni), ma interessante, D sta per deprecare questi operatori , principalmente perché

1. che cosa è esattamente a !< b? Lo è a>=b || isNaN(a) || isNaN(b). non!< è lo stesso di , perché è vero mentre è falso. IEEE 754 è difficile da padroneggiare, quindi usare to causerà solo confusione sulla gestione di NaN: puoi cercare tali operatori in Phobos (la libreria standard di D) e un certo numero di usi ha commenti accanto per ricordare ai lettori che NaN è coinvolto,>=NaN !< NaNNaN >= NaNa !< b
2. pertanto, poche persone lo useranno, anche se tali operatori esistono come in D,
3. e uno deve definire altri 8 token per questi operatori usati di rado, il che complica il compilatore per pochi vantaggi,
4. e senza quegli operatori, si potrebbe ancora usare l'equivalente !(a < b), o se si vuole essere espliciti a >= b || isNaN(a) || isNaN(b), e sono più facili da leggere.

Inoltre, le relazioni (≮, ≯, ≰, ≱) sono raramente viste in matematica di base, a differenza di !=(≠) o >=(≥), quindi è difficile da capire per molte persone.

Questi sono probabilmente anche i motivi per cui la maggior parte delle lingue non li supporta.

Perché non ha molto senso avere due operatori diversi con lo stesso significato.

• "Non maggiore" ( !>) è esattamente uguale a "minore o uguale" ( <=)
• “Not lesser” ( !<) è esattamente uguale a “maggiore o uguale” ( >=)

Questo non si applica a "non uguale" ( !=), non esiste un operatore con lo stesso significato.

Quindi, la tua modifica renderebbe la lingua più complicata senza alcun beneficio.

!<è sinonimo di >=. Più tardi è solo un modo per digitare un simbolo matematico ben definito ≥. Hai ragione nel dire che "non meno di" è usato nella lingua parlata, tuttavia è colloquiale e può essere ambiguo (può essere interpretato ≥o interpretato erroneamente come >). D'altra parte, la programmazione e la matematica usano una terminologia chiaramente definita e inequivocabile.

Anche nella logica a 3 valori, come ANSI SQL, not x < yè equivalente x >= y, dato che entrambi danno NULLse uno xo lo yè NULL. Tuttavia, ci sono dialetti SQL non conformi ANSI, dove non è equivalente, e hanno!< .

Transact-SQL ha operatori !> (Non maggiore di) e ! <(Non inferiore a) .

Quindi, oltre a te, anche qualcuno di Sybase Microsoft ha pensato che sarebbe stata una buona idea. Proprio come Microsoft Bob! :)

Penso che la risposta sia semplicemente che non c'è bisogno di un !<operatore. Come hai sottolineato nella tua domanda, esiste già >=e <=insieme la possibilità di negare un'espressione esistente, quindi perché aggiungere un altro operatore?

Dal RFC 1925

la perfezione non è stata raggiunta quando non c'è più niente da aggiungere, ma quando non c'è più niente da togliere.

L'aggiunta di operatori aggiuntivi che duplicano le funzionalità esistenti non fa altro che aggiungere complessità (non necessaria) al linguaggio (e quindi tokenizer e parser).

Considerare anche nelle lingue in cui è possibile il sovraccarico dell'operatore, si avrebbe ancora un altro operatore da sovraccaricare. Considera la confusione quando bool operator<=e bool operator!>potrebbe restituire cose diverse (sì, so che si possono già fare confronti incoerenti).

Infine, pensare a lingue in cui i metodi o gli operatori sono definiti moltiplicano (Rubino - sto guardando voi ) e si dispone di un programmatore che usi <= mentre un'altra il!> E si dispone di più stili di codice per la stessa espressione.

! <equivale a> = Ora perché non ne abbiamo una seconda perché tutte le lingue implementano prima l'operatore positivo e poi ci avviciniamo all'operatore negativo, poiché l'implementazione> = copre anche! <e <= copertine!>. Quindi il creatore del linguaggio va a questi e ho pensato che sarebbero stati ridondanti e li avrebbero saltati.

Cerca sempre di implementare prima il caso positivo, quindi vai al caso negativo (:) pensiero positivo, solo vista personale)

La ragione è che gli operatori dei linguaggi di programmazione prendono in prestito dalla tradizione matematica e in matematica nessuno usa realmente "non maggiore" e "non minore" poiché "più piccolo o uguale" e "maggiore o uguale" fanno altrettanto bene di un lavoro.

Quindi nei linguaggi di programmazione di solito otteniamo un simbolo che assomiglia a ≠ per non uguale ( !=o /=, a meno che qualcuno se non abbia fantasia <>o un operatore testuale)

e cose che sembrano ≤ e ≥ ( <=e >=)

A proposito, non sono d'accordo con la tua affermazione che NOT è più semplice da capire e ragionare su allora OR. In matematica, le prove che implicano molte negazioni (come la riduzione ad assurdo) sono generalmente disapprovate se esiste un'alternativa più diretta disponibile. Inoltre, nel caso degli ordini, la conoscenza di base che abbiamo (e che viene utilizzata quando si pensa o si prova qualcosa) è la tricotomia tra <, = e> quindi qualsiasi istruzione! <Probabilmente deve essere convertita in> = se si desidera fare qualcosa di utile con esso.

Incolperei parzialmente il set di istruzioni di montaggio. Hai istruzioni come jge"salta se maggiore o uguale". Al contrario di "saltare se non meno di".

Gli autori di compilatori potrebbero essere usciti da ciò che gli scrittori di assemblaggio hanno escogitato, presumibilmente basato su come è stato etichettato quando è stato progettato sul chip.

...possibilmente.

Penso di aver visto alcune lingue qualche anno fa in cui, al posto !=dell'operatore (non uguale), <>veniva usato qualcosa di simile . Non ricordo i loro nomi, però ...

Penso che sia più difficile da leggere !(a < b)o di a !< bquello a >= b. Probabilmente questo è il motivo per cui !<non viene utilizzato (secondo me sembra brutto).