***Mathematische Operatoren**

Gerade jetzt bei der if-Anweisung habe ich bemerkt, dass es nötig ist einen genaueren Blick auf mathematische Operatoren zu werfen. Sonst ist es schwierig irgendwelche Vergleiche zu ziehen, oder vernünftige Bedingungen zu stellen. Alles was möglich ist, werde ich nicht durchmachen, da fehlt mir zT selbst noch die Erfahrung. Aber die Bekannten und Wichtigen auf alle Fälle!

Die Grundrechnungsarte +,-,/,* können wir uns wohl sparen. Dann gibt es den

<u>Modulo Operator</u>

Der wird mit einem Prozentzeichen geschrieben. Wozu ist der gut?
Er gibt immer den ersten Rest einer Division aus. 

Bsp.5/2=2 geht in 5 2 mal, Rest 1. Also Modulo 1. Momentan kenne ich den Nutzen nur in zwei Punkten. Dadurch lässt sich prüfen, ob es eine Ganze oder gerade Zahl ist und ob die Zahl ohne Rest teilbar ist.
Es gibt aber noch einiges mehr, das von mir noch nicht genutzt wird. 

Dann gibt es die
<u>Vergleichsoperatoren</u>

```
>	größer als
>=	größer gleich
<	kleiner als
<=	kleiner gleich
==	ident, gleich
!=	nicht gleich, ungleich

```

<u>Logische Operatoren</u>

```
&& logisches UND
Abfrage ist gültig, wenn alle Werte den Anforderungen entsprechen.

|| logisches ODER
Abfrage ist gültig, wenn ein Wert den Anforderungen entspricht.

!logische NEGATION
Wandelt den Wahrheitswert

```
und

<u>Bereichsoperatoren</u>

```
.. von bis
..= von bis gleich

```

Damit diese auch zur Geltung kommen, wie angekündigt ein paar Beispiele mit if-Anweisungen. Im vorherigen Abschnitt hatten wir einen *ident* Vergleich.
Die Unterscheidung liegt im zweiten Istgleichzeichen daneben, zu einer normalen Wertzuweisung.

```
fn main (){
    let x=7;
    if x == 5{
    println! ("Ja,das war die richtige Zahl");
    }
    else {
        println! ("Nein, die Zahl war falsch");
        
    }  
}
```
Ausgabe

![image.png](https://files.peakd.com/file/peakd-hive/jeyf123/23tSL58oZ12uDkRgU9yxAsz15MGVc15rAaXFJBdqw7MHD1Y6hoQExcWkkycQd9GfDgTLQ.png)

weiter zu den Vergleichsoperatoren

```
let x =5;
    if x<5{
        println!("x ist kleiner als erwartet."); //nicht gültig
    }
    else if x>5{
        ("x ist größer als erwartet.");//nicht gültig
    }
    else if x !=6 {
        println!("Wenn x nicht 6 ist, muss es wohl etwas anderes sein. 5 vielleicht?");//richtig! wird ausgeben
    }
    else {
        println!("keine Ahnung!"); // wird nicht ausgegeben, weil !=6 bereits richtig war.
    }

```

logische Operatoren
```
logisches ODER

let mut x = 20;
    if x == 10 || x == 15 ||x == 20 || x == 25{
        println!("x war innerhalb der Werte und wird nun um 5 erhöht.");
        x = x+3;
        println!("x ist nun {}",x);
    }

```

 ```
logisches UND. Alle Werte müssen richtig sein.

    let mut x = 20;
    if x == 10 && x == 20{//x ist nur eine einzige Zahl, also vom Prinzip her falsch.
        println!("Ja, x besteht aus 10 und 20");
    }
    else{
        println!("x ist eine andere Zahl"); //das hier wird ausgegeben.
    }

```


```
//Wahrheitswert wandeln
    let a=false;
    let b=!a;

    if b == true {
        println!("b ist nicht a und deshalb stimmt es "); //das wird ausgebeben
    }
    else if b == false{
        println!("b ist falsch");
    }


```

Ich hoffe, dass ich diesen Bereich einigermaßen erklären konnte. Zum Schluss wieder die Zusammenfassung.

```
fn main (){
    //Modulo
    let x=5;
    if x%2==0{
        println!("{} ist eine gerade Zahl",x);
    }
    else{
        println!("{} ist eine ungerade Zahl",x); //Das hier wird augegeben.
    }

    //ident
    let x=7;
    if x == 5{
    println! ("Ja,das war die richtige Zahl");
    }
    else {
        println! ("Nein, die Zahl war falsch");

    }

    //Bereichsoperatoren

    let x =5;
    if x<5{
        println!("x ist kleiner als erwartet."); //nicht gültig
    }
    else if x>5{
        ("x ist größer als erwartet.");//nicht gültig
    }
    else if x !=6 {
        println!("Wenn x nicht 6 ist, muss es wohl etwas anderes sein. 5 vielleicht?");//richtig! wird ausgeben
    }
    else {
        println!("keine Ahnung!"); // wird nicht ausgegeben, weil !=6 bereits richtig war.
    }

    //logisches ODER. Nur 1 Wert muss richtig sein. Mehrere möglich.

    let mut x = 20;
    if x == 10 || x == 15 ||x == 20 || x == 25{//hier werten einige Werte auf einmal geprüft
        println!("x war innerhalb der Werte und wird nun um 5 erhöht.");
        x = x+3;
        println!("x ist nun {}",x);
    }

    //logisches UND. Alle Werte müssen richtig sein.
    let mut x = 20;
    if x == 10 && x == 20{//x ist nur eine einzige Zahl, also vom Prinzip her falsch.
        println!("Ja, x besteht aus 10 und 20");
    }
    else{
        println!("x ist eine andere Zahl"); //das hier wird ausgegeben.
    }

    //Wahrheitswert wandeln
    let a=false;
    let b=!a;

    if b == true {
        println!("b ist nicht a und deshalb stimmt es "); //das wird ausgebeben
    }
    else if b == false{
        println!("b ist falsch");
    }


}

```
Ausgabe

![image.png](https://files.peakd.com/file/peakd-hive/jeyf123/23tv8fNmtVTaHrFuryUvaRh1oaGFJneTahzCKvGbvXiKAx6F2iTw6NJyUuHToWNZ4aYpV.png)


![10.png](https://files.peakd.com/file/peakd-hive/jeyf123/23t8DBnQDWfyYUp846LjyAswHJSiiGNvSiu6FdXhd3eMHokUU3dWzGeEasacW4Rz3X5JC.png)