Frage der Bezeichnung

Wie könnte man folgendes nennen (oder vlt gibs da schon ne Bezeichnung für und ich kenn sie nicht ^^)

Ne zahl, die nur werte zwischen x und y annehmen kann und y + 1 ergibt wieder x ... wäre da zyklischer wert "mathematisch" korrekt oder wie nenn ich das am sinnvollsten ? Ich hoffe ihr versteht was ich mein.

Heinzelotto

Eine "Zahl"? Eine Zahl ist eine Konstante, die kann nur genau einen Wert anlegen. Meinst du vielleicht eine Funktion? was sind y und x? Auch Zahlen? Oder Intervallgrenzen?
Versuche, deine Frage nochmal genauer zu stellen

Ok, vlt hab ich die Frage blöd gestellt ... ich versuchs nochmal

x,y Element Z

[x,y] := {v Element Z | x <= v <= y}

Beispiele:
x = 1
y = 10

mit v = 10 ergäbe Inc(v) 1
mit v = 1 ergäbe Dec(v) 10

Mein Wert liegt also immer zwischen einer oberen und unteren Grenze in einem abgeschlossenen Intervall. Sollte nun durch eine Inkrementation ein Überlauf entstehen, soll der Wert auf die untere Grenze gesetz werden. Die Dekrementation verhält sich äquivalent nur eben andersrum.

Ich hoffe ihr wisst was ich mein...

Maxi

Du meinst vielleicht die Modulo-Rechnung?
Siehe Modulo und Kongruenz bei Wikipedia

Restklassengruppen

http://de.wikipedia.org/wiki/Kongruenz_(Zahlentheorie)
http://de.wikipedia.org/wiki/Restklassengruppe

Mhmm offensichtlich bin ich bei weitem nicht so mathematisch bewandert wie ihr, denn so richtig steig ich durch die Artikel nicht durch. Zumindest kann ich nicht wirklich eine Beziehung zu meinem "Problem" herstellen. Im Grunde geht es mir nur darum, meinen Funktionen zum Umgang mit einem solchen Wert einen sinnvollen Namen zu geben. Operationen, die ich brauche, wären Addition, Subtraktion, Inkrement und Dekrement.

Hier einfach mal der Code, vieleicht wird es dadurch deutlicher:

long add(long min, long max, long val, long sum) {

	if((min <= val) && (max => val)) {
		if(sum >= 0) {
			if((val + sum) > max) {
				return (val + sum) % (max - min);
			}
			else {
				return val + sum;
			}
		}
		else {
			throw std::out_of_range("sum");
		}
	}
	else {
		throw std::out_of_range("val");
	}
}

long sub(long min, long max, long val, long sub) {

	if((min <= val) && (max => val)) {
		if(sub >= 0) {
			if((val - sub) < min) {
				return (val - sub) % (max - min);
			}
			else {
				return val - sub;
			}
		}
		else {
			throw std::out_of_range("sub");
		}
	}
	else {
		throw std::out_of_range("val");
	}
}

Korrektur

long add(long min, long max, long val, long sum) {

    if((min <= val) && (max => val)) {
        if(sum >= 0) {
            if((val + sum) > max) {
                return (val + sum) % (max - min - 1);
            }
            else {
                return val + sum;
            }
        }
        else {
            throw std::out_of_range("sum");
        }
    }
    else {
        throw std::out_of_range("val");
    }
}

long sub(long min, long max, long val, long sub) {

    if((min <= val) && (max => val)) {
        if(sub >= 0) {
            if((val - sub) < min) {
                return (val - sub) % (max - min - 1);
            }
            else {
                return val - sub;
            }
        }
        else {
            throw std::out_of_range("sub");
        }
    }
    else {
        throw std::out_of_range("val");
    }
}

Borschtsch

Ich würde diese Variable als raw_range_elem bezeichnen. Zyklisch ist etwas, was sich nach einem Muster wiederholt; hier nicht zutreffend.

Gruß

Ok Danke, da keine Beanstandungen geäußert hat, werde ich das so übernehmen.