Quali sono alcuni buoni modi per rappresentare la relazione tra tre numeri

Ecco alcuni casi ed esempi di modi per descriverli e classificarli in modo che possano essere analizzati nel loro complesso.

1. A < B < C - Questo è un insieme ordinato distinto
2. A = B < C - Questo è un insieme ordinato indistinto
3. A > B < C - Questo è un insieme non ordinato
4. A < B = C - Questo è un insieme ordinato indistinto
5. A = B = C - Questo è un insieme ordinato indistinto
6. A > B = C - Questo è un insieme ordinato indistinto
7. A < B > C - Questo è un insieme non ordinato
8. A = B > C - Questo è un insieme ordinato indistinto
9. A > B > C - Questo è un insieme ordinato distinto

Afferra qualsiasi altra definizione terminologica che puoi pensare per insiemi e disponili su quei 9 casi e potresti trovare raggruppamenti più identificabili di quello che ho trovato usando solo 2 filtri (distinzione e ordine).

Sono sicuro che il lessico matematico è ricco di termini che potresti inserire su questi per descrivere gli insiemi.

Da Imposta teoria su Wikipedia (enfasi mia):

Equivalence and order relations are ubiquitous in mathematics, and the theory of mathematical relations can be described in set theory.

Considerando l'area che stai guardando, come ho detto, c'è molto in matematica per te da trovare qui. Ecco alcune cose che ti suggerirei di leggere su per darti una terminologia e un precedente precedente per lavorare da:

Rapporti transitivi :

For example, "is greater than," "is at least as great as," and "is equal to" (equality) are transitive relations:

whenever A > B and B > C, then also A > C

whenever A ≥ B and B ≥ C, then also A ≥ C

whenever A = B and B = C, then also A = C.

Proprietà commutativa (in relazione alle operazioni più grandi / meno / uguaglianze, la commutatività può aiutarti a derivare la transitività):

The term "commutative" is used in several related senses.[7][8]

1. A binary operation * on a set S is called commutative if:

   x * y = y * x\qquad\mbox{for all }x,y\in S

Proprietà associativa (in relazione alle tue operazioni, l'associatività può aiutarti a derivare anche la transitività):

Within an expression containing two or more occurrences in a row of the same associative operator, the order in which the operations are performed does not matter as long as the sequence of the operands is not changed. That is, rearranging the parentheses in such an expression will not change its value. Consider, for instance, the following equations:

(5 + 2) + 1 = 5 + (2 + 1)=8

5 x (5 x 3) = (5 x 5) x 3=75

Hai esattamente 13 relazioni.

6 di questi sono nella forma A > B > C, per vari ordini di A, B, C. Chiamiamoli A_B_C e simili.

6 di loro sono nella forma A > B = C o A = B > C, per vari ordini di A, B, C. Chiamiamoli A_BC e AB_C e simili.

L'ultimo 1 è A = B = C. Chiamiamolo ABC.

Questi 13 nomi formano un'enumerazione che identifica tutte le possibili relazioni. Puoi fornire sinonimi se ritieni che i tuoi utenti saranno più a loro agio con LT, LE, GE ecc. Ma non lo consiglierei. Lascia che trovino il membro giusto per descrivere ciò di cui hanno bisogno.

Usa quell'enumerazione come indice in una struttura dati per consegnare i vari flag necessari per guidare il tuo codice.

Ci sono tre possibili relazioni tra A e B :

1. A = B
2. A > B
3. A < B

Allo stesso modo, ci sono tre possibili relazioni tra A e C e tre relazioni tra B e C .

Penso che invece di memorizzare un valore che rappresenta la relazione tra tre valori (un enum con 21 valori dopo aver eliminato i casi degenerati), sarebbe meglio memorizzare tre relazioni tra ogni coppia di valori, ognuno dei quali è un enum con tre valori.

public enum XCompY
{
    LessThan = -1,
    Equals = 0,
    GreaterThan = 1
}

public class MyData
{
    private XCompY aToB;
    private XCompY aToC;
    private XCompY bToC;

    ...

    public bool IsValid(MyObject a, MyObject b, MyObject c)
    {
        int aCompB = a.CompareTo(b); // MyObject.CompareTo returns exactly -1, 0, or 1
        int aCompC = a.CompareTo(c);
        int bCompC = b.CompareTo(c);

        return (aCompB == (int)aToB) && (aCompC == (int)aToC) && (bCompC == (int)bToC);
    }
}

Ora abbiamo qualcosa di facile da leggere, non abbiamo un blocco switch gigante, e abbiamo aggiunto la possibilità di convalidare la relazione tra meno di 3 oggetti (o più di 3). (Sì, questo approccio è molto vicino alla tua idea iniziale.)

Mi sembra che potresti creare una tabella di ricerca per la gestione della spedizione.

Hai tre relazioni che a loro volta hanno tre valori.

Possiamo pensare a questo come tre indici:

1. Relazione b / n A e B
2. Relazione b / n A e C

3. Relazione b / w B e C

   enum Relation { less, equal, greater };

   public delegate void Handle(int a, int b, int c);
   
   class Handlers
   {
       public void handleLessLessLess(int a, int b, int c) { }
       public void handleLessLessEqual(int a, int b, int c) { }
       public void handleLessLessMore(int a, int b, int c) { }
   
   };
   public class Dispatcher
   {
       public Dispatcher()
       {
           table[Relation.less][Relation.less][Relation.less] = new Handle(h.handleLessLessLess);
           table[Relation.less][Relation.less][Relation.equal] = new Handle(h.handleLessLessEqual);
           table[Relation.less][Relation.less][Relation.greater] = new Handle(h.handleLessLessEqual);
           table[Relation.less][Relation.greater][Relation.less] = null; // cannot have a < b, a > c, b < c
       }
   
   public void handle(Relation ab, Relation ac, Relation bc, int a, int b, int c)
   {
       Handle h = table[ab][ac][bc];
       if (h != null)
           h(a, b, c);
       else
           // exception of what have you.
           ;
   }
   
   Handlers h = new Handlers();
   Dictionary<Relation, Dictionary<Relation, Dictionary<Relation, Handle>>> table =
       new Dictionary<Relation, Dictionary<Relation, Dictionary<Relation, Handle>>>();
   

   };