Zeilenvektor sortieren [Matlab]

Neue Frage »

tigerbine Auf diesen Beitrag antworten »
Zeilenvektor sortieren [Matlab]
Hallo zusammen,

ich frage mich ob es möglich ist (eine Funktion schon gibt), zu gegebener Matrix A eine Matrix B zu erstellen, in denen die Einträge der Zeilenvektoren von A nach Größe sortiert werden.

Beispiel:





Gruß,

tigerbine Wink
sqrt(2) Auf diesen Beitrag antworten »

code:
1:
B=sort(A')'
 
 
tigerbine Auf diesen Beitrag antworten »

Würde der ursprüngliche sort die Spalten sortieren? Wegen den zwei " ' "?
sqrt(2) Auf diesen Beitrag antworten »

Ja.

code:
1:
help sort
tigerbine Auf diesen Beitrag antworten »

Danke Dir Wink
tigerbine Auf diesen Beitrag antworten »

Noch eine Frage, gibt es auch für dieses Sortierverhalten einen Befehl. Wieder Zeilenweise, jedoch müssen die Nachbarschaftsbeziehungen eingehalten werden. Also in der Art:






Danke,
tigerbine Wink
sqrt(2) Auf diesen Beitrag antworten »

Also daraus werde ich nun gar nicht schlau.
tigerbine Auf diesen Beitrag antworten »

Also dein Tipp von gestern hat mir schon stark geholfen. Die drei Einträge pro Zeile stehen nun für die Seitenlängen in einem Dreieck. Es werden insgesamt ziemlich viele Dreiecke. Ich möchte aus der Matrix auslesen, wie viele kongruente Dreiecke entstehen.

Variante 1:
so wie gesten. Das liefert mir aber "nur" die anzahl der Dreiecke mit gleichen Seitenlängen. Dann kann aber immer noch eine Achsensymmetrie vorliegen.

Beispiel:
Ein Dreieck habe die Seitenlängen 1,2 und 3. In der ersten Spalte soll dann die kleinste Seitenlänge stehen, also 1. Nun sind aber die Dreiecke
a=1 b=2c=3 und a=1 b=3 und c=2
nicht kongruent.

Variante 2:
Man beläßt die Nachbarschaftsbeziehungen der Zahlen, nur bringt eben den kleinsten Eintrag in die erste Spalte. Dann gibt eine Doppelgängerabfrage die genaue Anzahl der kongruentem Dreiecke aus.

Verstehst Du mich nun etwas besser? smile
AD Auf diesen Beitrag antworten »

Zitat:
Original von tigerbine
Die drei Einträge pro Zeile stehen nun für die Seitenlängen in einem Dreieck. Es werden insgesamt ziemlich viele Dreiecke. Ich möchte aus der Matrix auslesen, wie viele kongruente Dreiecke entstehen.

Es geht um die Kugeldreiecke, ja? Und du rechnest mit Floating Point? Da sind = Vergleiche immer numerisch gefährlich, das ist dir hoffentlich bewusst...

Wenn du jetzt sagst "selbstverständlich ist mir das bewusst", dann entschuldige ich mich für die Störung. Augenzwinkern
tigerbine Auf diesen Beitrag antworten »

Ja es geht um die Dreiecke. Und du störst nicht. Augenzwinkern

Wie müsste ich es denn einstellen? Oder vorgehen? Ich hab jetzt erstmal mit der Holzhammer Methode versucht einen Algorithmus zur Berechnung aufzustellen, so dass ich nachher weiß, welcher Eintrag in der Matrix für was steht. Meine Programmiererfahrung ist eher gering, so dass da sicherlich ne Menge Verbesserungspotenzial ist.

Grundidee war die, dass die Maschinen ja auch nur eine best. Produktionsgenauigkeit haben. Ich wollte nun mit dem Programm schauen, ob ich bzgl. versch. Genauigkeiten dann eine Konvergenz /Parkettierung gegen max 3 bis 4 Dreiecke eintritt.

Ich habe die Berechnungen jetzt für a=1 (Kantenlänge des Ikosaeder) gemacht. Und unter preferences das so eingestellt. Wahrscheinlich schlägst du die Hände über Kopf zusammen. also, wir würde es denn richtig gehen?

Gruß

code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
ikosaeder
n: 1
Dreiecke (Ho Ve Di) erst V dann A

T =

   0.51949610958608   0.51949610958608   0.58713228931240
   0.51949610958608   0.58713228931240   0.51949610958608
   0.58713228931240   0.51949610958608   0.51949610958608
   0.58713228931240   0.58713228931240   0.58713228931240

SORT: innherhalb Zeile nach größe sortiert

ST =

   0.51949610958608   0.51949610958608   0.58713228931240
   0.51949610958608   0.51949610958608   0.58713228931240
   0.51949610958608   0.51949610958608   0.58713228931240
   0.58713228931240   0.58713228931240   0.58713228931240

SORTROWS: Zeilen nach erstem Eintrag sortiert

S =

   0.51949610958608   0.51949610958608   0.58713228931240
   0.51949610958608   0.51949610958608   0.58713228931240
   0.51949610958608   0.51949610958608   0.58713228931240
   0.58713228931240   0.58713228931240   0.58713228931240

>> 
sqrt(2) Auf diesen Beitrag antworten »

Das, was du willst, ist offenbar das:

code:
1:
2:
3:
4:
5:
[s i]=sort(A');
B=[];
for j=1:size(A)(1)
	B=[B; shift(A(j,:), 1-i(1,j))];
end


Zitat:
Original von tigerbine
Grundidee war die, dass die Maschinen ja auch nur eine best. Produktionsgenauigkeit haben. Ich wollte nun mit dem Programm schauen, ob ich bzgl. versch. Genauigkeiten dann eine Konvergenz /Parkettierung gegen max 3 bis 4 Dreiecke eintritt.

Was du genau willst, bleibt wir verborgen (ich habe deine Kugelproblem-Threads nicht gelesen); wenn du mit Fließkommazahlen umgehst, solltest du nur eben wissen, dass zwei Ergebnisse, die mathematisch gleich sein sollten, nicht unbedingt gleich sein müssen, denn triviale Dinge wie die Kommutativität der Addition sind nicht erfüllt. Wenn du vergleiche machst, solltest du ein gewisses Epsilon als Toleranz zulassen.
tigerbine Auf diesen Beitrag antworten »

Danke, ich werde das gleich mal ausprobieren.
tigerbine Auf diesen Beitrag antworten »

Was bedeutet denn (1) in Zeile 3?

Desweiteren bekomme ich bei shift eine Fehlermeldung

Zitat:
?? Undefined function or variable 'shift'.


Gruß
sqrt(2) Auf diesen Beitrag antworten »

Zitat:
Original von tigerbine
Was bedeutet denn (1) in Zeile 3?

Das erste Element im Zeilenvektor size(A).

Zitat:
Original von tigerbine
Desweiteren bekomme ich bei shift eine Fehlermeldung

Zitat:
?? Undefined function or variable 'shift'.

Ach, grml. Nimm einfach Octave.
tigerbine Auf diesen Beitrag antworten »

Zitat:
Original von sqrt(2)
Ach, grml. Nimm einfach Octave.


Einfach sah bei mir so aus http://www.my-smileys.de/smileys3/crash_2.gif. Aber nun scheine ich es doch geschafft zu haben die Programme zu installieren und der erst Probelauf war auch erfolgreich. Tanzen

Vielleicht findest Du ja mal die Zeit mir deinen Sortieralgorithmus ine einer Sprache "für Dummies" zu erklären. Ich freue mich jetzt erstmal dass er funktioniert.
sqrt(2) Auf diesen Beitrag antworten »

Eigentlich ist es ganz einfach, denn der sort-Befehl macht die ganze Arbeit: In der Matrix i steht nun, welches Element an welcher Stelle steht; interessant ist, wo das kleinste Element steht, also jeweils der erste Eintrag in einer Spalte. Ich gehe dann A einfach zeilenweise durch, verschiebe die Zahlen entsprechend (das macht shift) und schreibe das Ergebnis Zeile für Zeile nach B.
tigerbine Auf diesen Beitrag antworten »

Zitat:
Original von Arthur Dent

Es geht um die Kugeldreiecke, ja? Und du rechnest mit Floating Point? Da sind = Vergleiche immer numerisch gefährlich, das ist dir hoffentlich bewusst...


Dass Du nicht störst, habe ich dir ja schon gesagt. Vielleicht könnten wir dann ja mal die

Zitat:
...lockere Diskussion über diverse Aspekte


fortsetzen. Augenzwinkern Ich hatte dazu ja schonmal eine Maple Ausgabe gepostet. Nehmen wir nun mal an, dass die sortierte matrix nun so aussieht:


code:
1:
2:
3:
4:
5:
6:
7:
S =

   0.51949610958608   0.51949610958608   0.58713228931240
   0.51949610958608   0.51949610958608   0.58713228931240
   0.51949610958608   0.51949610958608   0.58713228931240
   0.58713228931240   0.58713228931240   0.58713228931240


Wie würde man beurteilen, ob 2 Zeilen (und damit 2 Dreiecke) kongruent sind? Kannst Du mir in Zahlen hier mal die Problematik mit floating point verdeutlichen?

Ich habe diese Matrix ="Tabelle" nun einfach mal nach Access importiert und eine Doppelgänger Abfrage gemacht.

Ich bin mir nun nicht ganz sicher, was sqrt(2) mit der Epsilon-Tolenranz meinte. Vielleicht dachte er, dass ich im Programm 2 Zeilen subtrahiere und dann mehr als das Ergebnis 0 als Gleichheit zulassen muss?

Ich hatte jetzt für mich erstmal die Annahme gemacht, 2 Einträge sind gleich, wenn sie bzgl. der eingestellten Genauigkeit in Matlab gleich sind, also in obiger Matrix gleich sind.

Gruß,
tigerbine
AD Auf diesen Beitrag antworten »

Zitat:
Original von tigerbine
Wie würde man beurteilen, ob 2 Zeilen (und damit 2 Dreiecke) kongruent sind? Kannst Du mir in Zahlen hier mal die Problematik mit floating point verdeutlichen?

Oje, du solltest mal eine Grundvorlesung Numerik hören...

Ok, in Kurzform: Zwei solche "numerisch" ermittelten Floatingpont-Vektoren und sollte man dann als gleich ansehen, wenn

mit k=0 oder k=1

ist. sollte nicht kleiner als gewählt werden, bei vielen Zwischenschritten zur Ermittlung von eher erheblich größer. Was du als Norm nimmst, ob nun die euklidische, die Maximum, oder die L1-Norm ... ist eigentlich wurst.



Dummerweise lauert aber noch eine ganz andere Gefahr, auf die ich eigentlich anspielen wollte:

Angenommen du hast drei Dreiecke: Zwei mit den Seitenlängen (3,4,5), eins mit (3,4,6).

Durch die genannten Rundungsungenauigkeiten ergeben sich beispielsweise aber die Werte

( 3.000001 , 4.000000 , 5.000000 )
( 2.999999 , 4.000000 , 5.000000 )
( 3.000000 , 4.000000 , 6.000000 )


Das sort würde die Dreiecke gemäß lexikographischer Ordnung - in der Reihenfolge 1., dann 2. und letzlich 3.Komponente - nun so sortieren:

( 2.999999 , 4.000000 , 5.000000 )
( 3.000000 , 4.000000 , 6.000000 )
( 3.000001 , 4.000000 , 5.000000 )

Wenn du jetzt zwecks Feststellung, ob ein Dreieck mehrfach vorkommt, nur benachbarte Elemente im derart sortierten Feld unter die Lupe nimmst, dann wirst du dein blaues Wunder erleben...

Oder wie anders willst du deine "Doppelgängerabfrage" anstellen? verwirrt
tigerbine Auf diesen Beitrag antworten »

Zitat:
Oje, du solltest mal eine Grundvorlesung Numerik hören...


Die hab ich wohl gehört, aber wir haben uns eben mehr mit Fragen in der Form "Existenz und Eindeutigkeit des Interpolationspolynoms" beschäftigt, als mit solchen Dingen. Sei also nachsichtig mit mir, wenn für dich offensichtliche Dinge für mich noch nicht klar sind. Ich werde mir den nächsten Absatz heute gegen Abend zu Gemüte führen (Soll ich bei Svensson ein paar Haare für Dich zum ausraufen bestellen, rein aus Vorbeugung? Augenzwinkern )

Zitat:
Dummerweise lauert aber noch eine ganz andere Gefahr, auf die ich eigentlich anspielen wollte:


Mmh, da verstehe ich das mit den Nachbarn jetzt nicht. Ich habe die Tabelle unter 2 Gesichtspunkten sortieren wollen. Bleiben wir beim Dreieck (3,5,4). Nun kann es vorkommen, dass im Programm die Ausgabe (5,4,3) herauskommt. Die beiden Dreiecke wären aber aufgrund der Lage ihrer Seiten zueinander kongruent.

1. Deswegen wollte ich, dass das Programm so umsortiert, dass erst die kleinen Seiten, dann die großen (aber ohne Zerstörung ihrer Beziehung untereinander) aufgelistet werden. [also (3,4,5) darf nicht rauskommen).

2. Die Sortierung der Sortierten Zeilen war nur für mich als optisches Hilfsmittel gedacht, wenn ich mir den Ausdruck mal anschaue.

3. Doppelgängersuche war eben bislang über Access. Das hat dann aber nichts mit Nachbarn zu tun. Nun würde ich hier ja kein Epsilon (wie oben) berücksichtigen, sondern nur danach gehen, ob die Ziffern gleich sind.

4. Warum wollte ich das so machen? Ich dachte nun, dass die Maschine am Ende ja eine gewisse Produktionsgenauigkeit hat, auf Grund derer die Form hergestellt wird. Nehmen wir nun mal an, wir haben 2 Dreiecke gegeben und auch die exakten reellen Zahlen ihrer Seitenlängen. Wann würde die Maschine 2 gleiche Dreiecke herstellen, obwohl die im analytischen Sinne verschieden sind? Und so wollte ich Matlab eben runden lassen.

Verstehst Du was ich meine?


EDIT:

Ichmeinte mit "gleich", gleich bezgl. der Rundung im Programm. Deswegen ist mir unklar, warum ich nochmal das "Epsilon" berücksichtigen soll.
AD Auf diesen Beitrag antworten »

Zitat:
Original von tigerbine
4. Warum wollte ich das so machen?

Hab ich nicht gesagt, dass du das so machen sollst. Ok, vergiss es ... du vergleichst bei n Dreiecken also jedes mit jedem anderen, macht Paarvergleiche.
tigerbine Auf diesen Beitrag antworten »

Zitat:
du vergleichst bei n Dreiecken also jedes mit jedem anderen, macht Paarvergleiche.


Ja, das war erstmal mein "Plan". Sollte mich das n² in der Anzahl der Vergleiche beunruhigen ? verwirrt Augenzwinkern
Und keine Ahnung wie das im "Duplikate suchen " Algorithmus von Access umgesetzt wird. verwirrt

Zitat:
Hab ich nicht gesagt, dass du das so machen sollst.

Jetzt bin ich didaktisch überfragt worauf sich der Satz bezieht. verwirrt (Sieht schon wieder nach einem "geschlagen mit den eigenen Mitteln" aus Augenzwinkern )

Wäre schön, wenn Du dich des Edits des vorherigen Posts noch annehmen könntest. Ich verbschiede mich erstmal, muss auf's Amt.

Gruß,
tigerbine Wink
AD Auf diesen Beitrag antworten »

Zitat:
Original von tigerbine
Ich meinte mit "gleich", gleich bezgl. der Rundung im Programm. Deswegen ist mir unklar, warum ich nochmal das "Epsilon" berücksichtigen soll.

Versteh ich nun wieder nicht: Du meinst also, bei gleichem theoretischem Resultat muss auch bei verschiedenen Rechenabläufen auf dem Weg dahin zumindest gerundet dasselbe herauskommen? Bei Fließkommaoperationen stimmt das i.a. nicht, da bin ich nicht der erste hier im Thread, der darauf hinweist:

Zitat:
Original von sqrt(2)
wenn du mit Fließkommazahlen umgehst, solltest du nur eben wissen, dass zwei Ergebnisse, die mathematisch gleich sein sollten, nicht unbedingt gleich sein müssen, denn triviale Dinge wie die Kommutativität der Addition sind nicht erfüllt.

Bei Kommutativität bin ich mir nicht so ganz sicher, bei Assoziativiät stimmt das aber ganz sicher:

Sei die Fließkommaaddition, sagen wir double (64 Bit, darunter 53 Bit Mantisse). Dann rechne mal

einerseits, und

andererseits...
tigerbine Auf diesen Beitrag antworten »

Zitat:
Original von Arthur Dent

Versteh ich nun wieder nicht: Du meinst also, bei gleichem theoretischem Resultat muss auch bei verschiedenen Rechenabläufen auf dem Weg dahin zumindest gerundet dasselbe herauskommen?


Nein, das meine ich nicht. Da scheinen wir aneinander vorbei zu reden. Ich meinte:

Theoretisch wären die Resultate verschieden. Bei gleichem Rechenablauf am Ende erhält man aber am Ende gleiche gerundete Ergebnisse.

Brechen wir es mal nur auf eine Rechnung runter. Die theoretischen Längen wären z.B.:





Nun könnte die Maschine aber nur mm genau produzieren. Also müßte man doch jetzt Runden, oder? Dann stellt sich die Frage, wie. Da ich meine Beispielzahlen bzgl. der kaufmännischen Rundung gewählt habe, würde man dann doch erhalten verwirrt





Damit wären dei gerundeten Dreiecke gleich.

EDIT: Mene Hausaufgabe rechne ich dann mal nach dem Abendessen... Augenzwinkern
sqrt(2) Auf diesen Beitrag antworten »

Zitat:
Original von tigerbine
Theoretisch wären die Resultate verschieden. Bei gleichem Rechenablauf am Ende erhält man aber am Ende gleiche gerundete Ergebnisse.

Das kann dir passieren, ja. Da die hier problematische Rundung intern geschieht, liegt das auch nicht in deiner Macht zu ändern.

Du musst eben wissen, wie viele signifikante Stellen du brauchst und wie viele dir der Datentyp bietet (Fehlerfortpflanzung beachten).
tigerbine Auf diesen Beitrag antworten »

Jetzt verstehen wir uns. Freude Wie müsste der Plan also lauten?

1. Ich frage nach, welche Angaben der Maschinenkonstrukteur braucht.

(hab ich schon, aber noch keine Antwort)

2. Das bisherige Programm beurteilen

3. Das Programm muss dann (sicher) unter numerischen Aspekten geändert werden.

Zu 2 und 3fehlt mir (noch) der Blick. Ich habe es jetzt erst mal so geschrieben, dass ich als Laie noch verstehe, was die jeweilige Schleife ausrechnet. Wäre dann lieb, wenn ihr mir helfen würdet. Ich würde das auch gerne besser verstehen.

Gruß,
tigerbine Wink
sqrt(2) Auf diesen Beitrag antworten »

Die Frage, wie genau es sein muss, muss auf jeden Fall als erstes geklärt und in Zahlen beantwortet werden.
tigerbine Auf diesen Beitrag antworten »

Oki, ich warte da wie gesagt noch auf auf eine mail. Sobald ich die habe melde ich mich.
tigerbine Auf diesen Beitrag antworten »
Habe Antwort
Als Produktionsgenauigkeit und Rechengenauigkeit für Koordinaten oder ähnliches reicht ± 0,5mm aus.

Die Teile werden voraussichtlich aufgeklebt und untereinander verklebt. Kleine Spalte werden dann einfach vom Kleber ausgefüllt. Die produzierbaren Seitenlängen liegen zwischen 0 und mm
sqrt(2) Auf diesen Beitrag antworten »

Wenn du double als Datentyp nimmst (und MATLAB tut das standardmäßig), brauchst du dir dann in diesem Fall kaum einen Gedanken um die Fehlerfortpflanzung zu machen, wenn du deine Längen in Millimetern darstellst. Beim Vergleichen solltest du nur vorher immer auf Zehntelmillimeter runden.
tigerbine Auf diesen Beitrag antworten »

Und schon steh ich vor dem nächsten Problem. Ich muss das ganze ja für verschiedene Kugelradien betrachten. Daraus ergeben sich dann ja auch verschiedene Kantenlängen a des der Rechnung zugrunde liegenden Ikosaeders. (Modlink: Weißes Dreieck). Nun bin ich mir nicht sicher, ob es besser ist

  • erst mit a=1 zu rechnen und die Seitenlängen nachher auf den Radius der Kugel anzupassen, oder
  • den gewünschten Radius vor der Rechnung einzugeben.


Nächste Rückfrage bezieht sich auf
Zitat:
sqrt(2)
Beim Vergleichen solltest du nur vorher immer auf Zehntelmillimeter runden.


Welche Art der Rundung sollte man denn hier nehmen? Die Bauteile werden ja verklebt. Ich hätte jetzt intuitiv gedacht, dass es besser ist immer abzurunden, da man Zwischenräume einfacher ausgleichen kann. Wenn es im Worst-Case-Fall passiert, dass alle Werte aufgerundet werden, müsste man ja in der Praxis Teile verkleinern. Das Stelle ich mir bei Styropor eher schwierig vor.

Um die Fragen zu klären, schauen wir an besten in den Algorithmus, oder? Zum Programm. Erläuterungen folgen hier.

Speichern von Punktkoordinaten


Diese werden wie folgt in der Block-Matrix M gespeichert:




Speichern von Längen nach der Projektion


Erfolgt in den 3 Dreiecksmatrizen Horizontal, Vertikal, Diagonal:








Speichern von Dreiecken - 2 Typen




B: Blau





O: Orange

Danach kommen sie in eine Matrix T



Sortiert werden sie bislang noch nicht. Da der Befehlt ja in Matlab nicht klappen wollte. Für die Frage ob a=1 dann R oder R eingeben sollte dies keine Rolle spielen.
tigerbine Auf diesen Beitrag antworten »
Programm
Umschalten zweischen a und R in Zeile 14 bzw 20,21

code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
%Projektion am Ikosaeder 
%a:  Kantenlänge des Ikosaeders
%R:  Radius der zu produzierenden Kugel
%RU: Umkugelradius für a=1
%Zusammenhang: R=RU*a <=> a = R/RU 

%Ikosaedermittelpunkt
M=[0;0;0];

%Radius Umkugel Ikosaeder a=1
RU=0.25*sqrt(10+2*sqrt(5));

%Radius der zu produzierenden Kugel
%R=input('Kugelradius R: ');

%Berechnung der Kantenlänge a
%a= R/RU;

%Festlegung der Kantenlänge a
a=1
R=RU

%Radius Umkreis gleichseitiges Dreieck (weiß)
ru=(sqrt(3)/3)*a;

%Radius Inkreis gleichseitiges Dreieck (weiß)
ri=(sqrt(3)/6)*a;

%Abstand "weißes Ikosaeder-Dreieck" und M (Höhe der Pyramide) 1/16=0.0625
hp=(sqrt(0.0625*(10+2*sqrt(5))-1/3))*a;

%Schwerpunkt/Umkreismittelpunkt des "weißen Ikosaeder-Dreiecks"
S=[0;hp;0];

%Eckpunkte eines "weißen Iskosaeder-Dreiecks "(liegen auf Umkugel)
E1=[(-0.5)*a;hp;ri];
E2=[(0.5)*a;hp;ri];
E3=[0;hp;-ru];

E1E2=[1*a;0;0];
E1E3=[(0.5)*a;0;-ru-ri];

%*******************************************************************************************************************
%Berechnung der inneren Punkte für n=Frequenz (Anzahl der Teilstrecken). Zeilenweise im Dreieck von Links nach Rechts. 
n=input('n: ');

%Blockmatrix erstellen 3*(n+1) x (n+1), M: Koordinaten im "weißen Ikosaeder-Dreieck"
k=-1;

for i=1:(n+1)
    %Erezugt den Dreierblock xyz
    d=3*(i-1)+1;
    
    %Sorgt für die Dreieckgestalt
    k=k+1;
    
    for j=1:[(n+1)-k]
        M(d:d+2,j)=E1+((j-1)/n)*E1E2+((i-1)/n)*E1E3;
    end
end
M
%*******************************************************************************************************************

%*******************************************************************************************************************
%Projektion der neuen (roten) Punkte auf die Umkugel. Wegen M=[0;0;0] ist für jeden Punkt W im "weißen Ikosaeder-Dreieck" 
%seine Projektion WP: WP=R*(1/norm(W))*W;

%Projektionsmatrix erstellen, P: Koordinaten 
i=1;
d=1; %für die Dreieckblöcke der Koordinaten
k=0;

%Erste Dreieckszeile
P(d:d+2,1)=M(d:d+2,1); %Eckpunkt E1 bleibt
    for j=2:[(n+1)-(k+1)]
        P(d:d+2,j)=R*(1/(norm(M(d:d+2,j))))*M(d:d+2,j);
    end 
P(d:d+2,n+1)=M(d:d+2,n+1); %Eckpunkt E2 bleibt

%innere Dreieckszeilen
if n>1
    for i=2:n
        d=3*(i-1)+1;
        k=k+1;
        
        for j=1:[(n+1)-k]
            P(d:d+2,j)=RU*(1/(norm(M(d:d+2,j))))*M(d:d+2,j);
        end
    end
end

%Eckpunkt E3 bleibt
d=3*n+1;
P(d:d+2,1)=M(d:d+2,1);
        
P
%********************************************************************************************************************

%********************************************************************************************************************
%Kontrollmatrix (Ob E1E2E3 unverändert geblieben sind)
K=P-M
%********************************************************************************************************************

%********************************************************************************************************************
%Längenmatrizen erstellen V:Vertikal, H: Horizontal, D Diagonal

%Horizontale Längen-Matrix
k=-1;
for i=1:n
    d=3*(i-1)+1;
    k=k+1;
    for j=1:[n-k]
        H(i,j)=norm(P(d:d+2,j)-P(d:d+2,j+1));
    end
end
H;

%Vertikale Längen-Matrix
k=-1;
for i=1:n
    d=3*(i-1)+1;
    k=k+1;
    for j=1:[n-k]
        V(i,j)=norm(P(d:d+2,j)-P(d+3:d+5,j));
    end
end
V;

%Diagonale Längen-Matrix
k=-1;
for i=1:n
    d=3*(i-1)+1;
    k=k+1;
    for j=1:[n-k]
        D(i,j)=norm(P(d:d+2,j+1)-P(d+3:d+5,j));
    end
end
D;
%********************************************************************************************************************

%********************************************************************************************************************
%Matrix1 mit den Dreiecksangaben [Ho-Ve-Di] (2 oben - 1 unten)
k=0;
for i=1:n
    for j=1:((n+1)-i)
        k=k+1;
        T1(k,1)=H(i,j);
        T1(k,2)=V(i,j);
        T1(k,3)=D(i,j);
    end
end
T1

%Matrix2 mit den Dreiecksangaben [Ho-Ve-Di] (1 oben - 2 unten)
k=0;

if n==1
   T2=[0 0 0];
   
if n>1
    for i=2:n
        for j=1:((n+1)-i)
        k=k+1;
        T2(k,1)=H(i,j);
        T2(k,2)=V(i-1,j+1);
        T2(k,3)=D(i-1,j);
        end
    end
end
T2;

%Alles in eine Matrix schreiben
disp('Dreiecke (Ho Ve Di) erst v dann ^');
T=[T1;T2]
%********************************************************************************************************************

%********************************************************************************************************************


%*********************************************************************************************************************
%Kontrollzahl der Dreiecke:
d1=0;
d2=0;
for i=1:n
    d1=d1+i;
end
for j=1:(n-1)
    d2=d2+j;  
end
disp('Kontrolzahl der Dreiecke');
d=d1+d2
%*********************************************************************************************************************

clear all
end
tigerbine Auf diesen Beitrag antworten »
Ausgabe Matlab
KURZE AUSGABE

code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
>> ikosaeder_a

a =

     1


R =

   0.95105651629515

n: 2

M =

  -0.50000000000000                  0   0.50000000000000
   0.75576131407617   0.75576131407617   0.75576131407617
   0.28867513459481   0.28867513459481   0.28867513459481
  -0.25000000000000   0.25000000000000                  0
   0.75576131407617   0.75576131407617                  0
  -0.14433756729741  -0.14433756729741                  0
                  0                  0                  0
   0.75576131407617                  0                  0
  -0.57735026918963                  0                  0


P =

  -0.50000000000000                  0   0.50000000000000
   0.75576131407617   0.88845070933431   0.75576131407617
   0.28867513459481   0.33935797363675   0.28867513459481
  -0.29389262614624   0.29389262614624                  0
   0.88845070933431   0.88845070933431                  0
  -0.16967898681838  -0.16967898681838                  0
                  0                  0                  0
   0.75576131407617                  0                  0
  -0.57735026918963                  0                  0

Dreiecke (Hor Ver Dia) erst v dann ^

T =

   0.51978382601551   0.51978382601551   0.58778525229247
   0.51978382601551   0.58778525229247   0.51978382601551
   0.58778525229247   0.51978382601551   0.51978382601551
   0.58778525229247   0.58778525229247   0.58778525229247

Kontrolzahl der Dreiecke

d =

     4

>> 


LANGE AUSGABE

code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
>> ikosaeder_a

a =

     1


R =

   0.95105651629515

n: 2

M =

  -0.50000000000000                  0   0.50000000000000
   0.75576131407617   0.75576131407617   0.75576131407617
   0.28867513459481   0.28867513459481   0.28867513459481
  -0.25000000000000   0.25000000000000                  0
   0.75576131407617   0.75576131407617                  0
  -0.14433756729741  -0.14433756729741                  0
                  0                  0                  0
   0.75576131407617                  0                  0
  -0.57735026918963                  0                  0


P =

  -0.50000000000000                  0   0.50000000000000
   0.75576131407617   0.88845070933431   0.75576131407617
   0.28867513459481   0.33935797363675   0.28867513459481
  -0.29389262614624   0.29389262614624                  0
   0.88845070933431   0.88845070933431                  0
  -0.16967898681838  -0.16967898681838                  0
                  0                  0                  0
   0.75576131407617                  0                  0
  -0.57735026918963                  0                  0


K =

                  0                  0                  0
                  0   0.13268939525814                  0
                  0   0.05068283904194                  0
  -0.04389262614624   0.04389262614624                  0
   0.13268939525814   0.13268939525814                  0
  -0.02534141952097  -0.02534141952097                  0
                  0                  0                  0
                  0                  0                  0
                  0                  0                  0


H =

   0.51978382601551   0.51978382601551
   0.58778525229247                  0


V =

   0.51978382601551   0.58778525229247
   0.51978382601551                  0


D =

   0.58778525229247   0.51978382601551
   0.51978382601551                  0


T1 =

   0.51978382601551   0.51978382601551   0.58778525229247
   0.51978382601551   0.58778525229247   0.51978382601551
   0.58778525229247   0.51978382601551   0.51978382601551


T2 =

   0.58778525229247   0.58778525229247   0.58778525229247

Dreiecke (Hor Ver Dia) erst v dann ^

T =

   0.51978382601551   0.51978382601551   0.58778525229247
   0.51978382601551   0.58778525229247   0.51978382601551
   0.58778525229247   0.51978382601551   0.51978382601551
   0.58778525229247   0.58778525229247   0.58778525229247

Kontrolzahl der Dreiecke

d =

     4

>> 
tigerbine Auf diesen Beitrag antworten »
Augabe Octave
Warum läuft das hier nicht durch? verwirrt

code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
>> ikosaeder_a_octave
a = 1
R = 0.95106
n: 2










M =

  -0.50000   0.00000   0.50000
   0.75576   0.75576   0.75576
   0.28868   0.28868   0.28868
  -0.25000   0.25000   0.00000
   0.75576   0.75576   0.00000
  -0.14434  -0.14434   0.00000
   0.00000   0.00000   0.00000
   0.75576   0.00000   0.00000
  -0.57735   0.00000   0.00000

P =

  -0.50000   0.00000   0.50000
   0.75576   0.88845   0.75576
   0.28868   0.33936   0.28868
  -0.29389   0.29389   0.00000
   0.88845   0.88845   0.00000
  -0.16968  -0.16968   0.00000
   0.00000   0.00000   0.00000
   0.75576   0.00000   0.00000
  -0.57735   0.00000   0.00000

Dreiecke (Hor Ver Dia) erst v dann ^
-- less -- (f)orward, (b)ack, (q)uit
sqrt(2) Auf diesen Beitrag antworten »

Zitat:
Original von tigerbine
Nun bin ich mir nicht sicher, ob es besser ist
  • erst mit a=1 zu rechnen und die Seitenlängen nachher auf den Radius der Kugel anzupassen, oder
  • den gewünschten Radius vor der Rechnung einzugeben.

Du befindest dich mit deinen Rechnungen in einem Zahlenbereich, in dem du keine Angst haben musst, durch fehlende Mantissenlänge massiv an Genauigkeit zu verlieren. In dieser Hinsicht darfst du das hier machen, wie du willst.

Zitat:
Original von tigerbine
Welche Art der Rundung sollte man denn hier nehmen?

Egal. Du rundest unterhalb der geforderten Genauigkeit und arbeitest mit den gerundeten Werten auch nicht weiter.

Zitat:
Original von tigerbine
Warum läuft das hier nicht durch? verwirrt

Octave gibt dir lange Ausgaben in einem Modus aus, in dem du vor- und zurückblättern kannst (mit f und b, die Pfeiltasten sollten auch funktionieren).
tigerbine Auf diesen Beitrag antworten »

Punkt 1: Tanzen
Punkt 3: Ja die Funktionieren. Dachte nur das bedeutet Fehler im Programm Tanzen

********************************************************
Punkt 2: Mmh, hier hab es wieder geschafft auf der Leitung zu stehen.

Gehen wir mal in das Beispiel. Da kam ja nun als unsortierte Matrix raus:

code:
1:
2:
3:
4:
5:
6:
7:
8:
T =

   0.51978382601551   0.51978382601551   0.58778525229247
   0.51978382601551   0.58778525229247   0.51978382601551
   0.58778525229247   0.51978382601551   0.51978382601551
   0.58778525229247   0.58778525229247   0.58778525229247


Das sind 3 kongruente Dreiecke und 1. Die Dreiergruppe taucht in allen möglichen Vektordarstellungen auf. Jetzt nehmen wir mal an, wir hätten einen SortierAlgorithmus Sorty (Bei der Kombi Sort/Shift von dir wird ein Fall nicht erfaßt. Leider.) Es käme dann raus:

code:
1:
2:
3:
4:
5:
6:
7:
8:
S=sorty(T)
S=

   0.58778525229247   0.51978382601551   0.51978382601551   
   0.58778525229247   0.51978382601551   0.51978382601551
   0.58778525229247   0.51978382601551   0.51978382601551
   0.58778525229247   0.58778525229247   0.58778525229247


Dabei wurden hier die Seitenlängen auf a=1 bezogen. Wenn man nun eine Kugel vom Radius R=20m=2 000cm=200 000mm hat, dann ist




Wie sollte man nun vorgehen, um 2 Dreiecke für die Produktion als kongruent zu kennzeichnen.

Variante A:
  1. Man nimmt die Matrix S und prüft auf gleiche Zeilen.

  2. Nun braucht man ja die Längenängaben für die Produktion. Das würde man dann zunächst in Matlab Genauigkeit rechnen. Wie sollte man R eingeben? So (nicht) verwirrt

    code:
    1:
    2:
    3:
    4:
    5:
    6:
    7:
    8:
    9:
    10:
    11:
    12:
    13:
    14:
    15:
    16:
    17:
    18:
    19:
    20:
    21:
    22:
    23:
    24:
    25:
    26:
    27:
    28:
    29:
    30:
    31:
    32:
    33:
    34:
    35:
    
    >> S
    
    S =
    
       0.58778525229247   0.51978382601551   0.51978382601551
       0.58778525229247   0.51978382601551   0.51978382601551
       0.58778525229247   0.51978382601551   0.51978382601551
       0.58778525229247   0.58778525229247   0.58778525229247
    
    >> R
    
    R =
    
          200000
    
    >> a=R/(0.25*sqrt(10+2*sqrt(5)))
    
    a =
    
        2.102924448476535e+005
    
    >> a*S
    
    ans =
    
      1.0e+005 *
    
       1.23606797749978   1.09306611565069   1.09306611565069
       1.23606797749978   1.09306611565069   1.09306611565069
       1.23606797749978   1.09306611565069   1.09306611565069
       1.23606797749978   1.23606797749978   1.23606797749978
    
    >> 
    


  3. Nun muss doch gerundet werden. Auf 0.5mm genau. Aber wie? Ich hätte gesagt, immer abrunden, dann sind die Bauteile kleiner und die Lücke wird "verspachtelt". Denn es könnte doch passieren, dass man alle Teile aufrunden müßte. Dann wären die ja in der Summe zu goß und man müßte was wegnehmen. Das stelle ich mir bei Styropor eben problematisch vor.

  4. Wie würden denn jetzt die Längen in Produktionsgenauigkeit heißen?




Variante B:

Hier bin ich noch nicht ganz schlüssig. Wieviel genauer ist denn Matlab als das was ich am Ende brauche. D.h. müßte /könnte ich vielleicht die Matrix S schon einmal runden, um mehr kongruente Flächen zu bekommen?

Die Variante sollten wir vielleicht insoweit verschieben, als das man erstmal den Fall A auswertet, ob produzierbare Dreiecke mit maximal 3 Formen rauskommen.

EDIT:

Es muss wohl doch irgendwie T vor dem Sortieren gerundet werden. Dazu müsste man wie gesagt festlegen, auf wie vieleie Stellen. Fallbeispiel:

code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
T =

   0.51978382601551   0.51978382601551   0.58778525229247
   0.51978382601551   0.58778525229247   0.51978382601551
   0.58778525229247   0.51978382601551   0.51978382601551
   0.58778525229247   0.58778525229247   0.58778525229247

Sorty 1. Zeile

ans =

   0.51978382601551   0.58778525229247   0.51978382601551

Prüfung Eintrag 1 - Eintrag 3 ist nicht 0.





Danke für die Mühe, die Posts hier sind ja was aufwinder zu lesen. Wink
tigerbine Auf diesen Beitrag antworten »
Sorty-Versuch
Hiermit sollte der Fall, dass z.B. der Vektor [1 2 1] nicht zu [1 1 2] umsortiert wird umgangen sein. Laufzeiten und sonstigen Optimierungen habe ich keine Ahnung. Konstruktive Kritik willkommen.

code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
Sortierfunktion für 1x3 Matrix
function [z]=sorty(v)

%Minimales Element unter Erhaltung der Reihenfolge nach vorne sortieren
if v(1,1)>v(1,2)
   w=[v(1,2), v(1,3), v(1,1)];
   if w(1,1)>w(1,2)
      z=[w(1,2),w(1,3),w(1,1)];
   end
   if w(1,1)<=w(1,2)
       z=w;
   end
end

if v(1,1)<=v(1,2)
   if v(1,1)>= v(1,3)
   z=[v(1,3),v(1,1),v(1,2)];
else
   z=v;
   end
end
Neue Frage »
Antworten »



Verwandte Themen

Die Beliebtesten »
Die Größten »
Die Neuesten »