1+1=0 definieren?

[Ari]

Das Ganze mod 2 zu rechnen ist eine gute Idee - nur komischerweise bekomme ich auch den Wert "-1" angezeigt und generell scheint mein Gleichungssystem überhaupt nicht zu funktionieren. Die Integer-Werte meines GLS sind auch sehr ungewöhnlich, mal 6, mal 21, mal -45600 oder sowas :gruebel:
Also, ich möchte aus dem Array arr je neun Elemente aufsummieren und den Wert 1 erhalten, also quasi
arr[1,1,1]+...+arr[1,1,9]=1
haben.

Delphi-Quellcode:

var arr: array [1..9, 1..9, 1..9] of integer; a:integer;

      a:=(arr[1,1,1]+arr[1,1,2]+arr[1,1,3]+arr[1,1,4]) mod 2;
      a:=1;
      Label2.Caption:=IntToStr(arr[1,1,1] mod 2);
      Label3.Caption:=IntToStr(arr[1,1,2] mod 2);
      Label4.Caption:=IntToStr(arr[1,1,3] mod 2);
      Label5.Caption:=IntToStr(arr[1,1,4] mod 2);

Das GLS muss so wohl komplett falsch konstruiert sein, oder?

[inherited]

Du könntest dir auch einen typ-Record basteln und die Additions, Subtraktions,... Operatoren überladen.

[grenzgaenger]

Zitat:

Zitat von Ari

Möchte gerne ein Gleichungssystem mit sehr vielen Gleichungen und Unbekannten lösen lassen, verwende dazu allerdings den endlichen Körper F2, also nur die Elemente 0 und 1. Daher ist dort auch 1+1=0 was die Lösung im Vergleich zum Variablentyp integer mit 1+2=2 beeinflusst.

mit welchen operationen möchtest du das eigentlich machen? hast du da schon eine ergebnistabelle, wie die verknüpfungen funktionieren sollen?

komm da leider nicht ganz mit was 10 + 01 = 10 sein sollen insbesondere, wie es da weiter gehen soll ...

btw: häng doch mal 'ne wahrheitstabelle dran ... :-)

[himitsu]

es klang so, als wenn er nur mit einem Bit rechnen möchte :gruebel:

also reicht es doch die Operationen auf dieses eine Bit zu beschränken?
> siehe #8

[grenzgaenger]

bist du dir sicher? und kannst du ausschliessen, dass sie nicht was ganz anderes möchte?

denke, das sinnvollste wir sein, wenn sie das kurz erklärt (unabhängig von der sprache) :-)

das wird dann auch die halbe lösung sein ;-)

schöne grüsse
GG

[oldmax]

Hi
Löst euch mal vom Integer und nehmt den Typ Word
Word ist eine Binäre Zahl, integerdagegen eine Ganzzahl von - irgendwas bis + irgendwas, wobei das höchstwertige Bit das Vorzeichen ist.
Eine Binäre Addition ist xOr, und was ist daran so kompliziert ?
Mathematisch gesehen ist die Subtraktion lediglich die Addition einer negativen Zahl, und um das hinzukriegen muß von der 2. Zahl das 2er Komplement gebildet werden. Ist schon lange her, das ich auf diesem Weg gerechnet habe, daher schaut selbst, wie's gemacht wird.
Nun der Weg:
wird nur mit Bit- Wert gerechnet reicht es 2 Boolean mit xOr zu verknüpfen, ansonsten geht xOr auch mit Byte, Word oder Doppelword.

z. B.
Wert 1 = 00011010 // Byte
Wert 2 = 00011001 // Byte

Addition
Wert 1 xOr Wert 2 (Binär, also Byte, Word oder Doppelword !)
(00011010 xOr 00011001 = 00110011 50 +49 = 99
Subtraktion
Wert2 invertieren // jedes Bit drehen -> 1er Komplement aus 00011001 wird 11100110
1 addieren // bin mir nicht 100% sicher, aber ich glaub, das ist die 2er Komplementbildung
Wert 2 xOr 1 // also 11100110 xOr 0000001 = 11100111
dann Wert 1 xOr Wert 2 //
00011010 xOr 11100111 = 00000001 50 +(-49) = 1

Der beschriebene Fehler, das da plötzlich negative Werte erscheinen liegt m.E. in der Verwendung von Interger !
Gruß oldmax

[QuickAndDirty]

@Ari: nimm doch einen Derive Interpreter.
Dann löst sich das Problem von alleine.

Und ob du jetzt zehnadische werte oder dyadische für den gauss verwendest das ist einerlei.
Brauchst du alle zwischenschritte mit Binärdarstellung für HA,
dann wandle einfach die Ausgabe in Binärdarstellung um.


Ansonsten könntest du noch in Prolog deine eigene Algebra definieren.

[Ari]

Derive selbst geht nicht, weil es mehr als 300 Gleichungen sind. Ein Interpreter von Derive ist was genau..?

Also ich denke ich beschreibe erstmal, was ich genau machen will..die binäre Darstellung

Zitat:

Wert 1 = 00011010 // Byte
Wert 2 = 00011001 // Byte

benötige ich glaube ich nicht *vorsichtig*
Also ich habe ein derartiges Gleichungssystem:

Delphi-Quellcode:

1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 ... =1
0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 ... =1
1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 ... =1
0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 ... =1

Wenn ich dann zwei Koeffizienten, die zu einer Unbekannten gehören, erhalte ich den Wert 0 (also 1+1=0) woraufhin ich dann irgendwann auf eine Lösung komme. Insgesamt sinds 320 Gleichungen und 730 Unbekannte *hust*..
Ziel ist es, die Trapezform des Gleichungssystems betrachten zu können. Ich möchte nämlich wissen, ob während des Gauss'schen Eliminationsverfahrens Gleichungen durch die Addition entfallen (also doppelt auftauchen).

Sorry, die bisherigen Informationen kann ich leider grad nicht anwenden, da ich "Wert 1 = 00011010 // Byte " leider nicht ganz verstehe :oops:
und was macht "#8" eigentlich? In einem Beispiel für das Gauß-Verfahren in Object Pascal taucht auch sowas wie #8#8 auf.. :gruebel:

[grenzgaenger]

weiss zwar noch nicht genau auf was es hinauslaufen soll :gruebel: , vermute mal, dass es sich um die lösung eines Simplex handelt.

hier könntest, du bei den paar gleichungen/variablen die lösung auch mit dem excel-solver leicht ermitteln.

[Ari]

Ja so ein Ganzzahligkeitsproblem ist es auch. Arbeite mit SCIP, was aber dem Simplex-Verfahren entsprechen müsste..nur da bekomme ich eben leider nur die Lösungen der Unbekannten angezeigt und nicht das ganze Gleichungssystem (oder ich weiß einfach nicht wie), deshalb wollte ich das in Delphi nachprogrammieren