Abbruchkondition einer Schleife mit single-Variablen

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    Aufgrund technischer Veränderungen ist der Mailverkehr innerhalb des Forums (Private Nachrichten) nur noch eingeschränkt möglich. Die Einschränkung ist notwendig, um zusätzliche Betriebskosten für das Forum zu vermeiden. Näheres zu den Hintergründen im Thread "Aktuelles zum Forum".Wir bitten um Verständnis.

    Hinweis kann nach Kenntnisnahme deaktiviert werden!

    • Abbruchkondition einer Schleife mit single-Variablen

      Hallo Gemeinde,
      bei meinem derzeitige Projekt arbeite ich zwangsläufig mit single-Variablen. Jetzt kommen in meinem code auch solche Teile vor

      BASCOM-Quellcode

      1. Do
      2. Xx = Xx + Sdx : Xs = Xx
      3. Ys = Yy
      4. Winkel = Atn2(ys , Xs) : If Ys < 0 Then Winkel = 2pi + Winkel
      5. Xs = Xs ^ 2 : Ys = Ys ^ 2 : H = Xs + Ys
      6. Rs = Sqr(h)
      7. Fahre_zu_punkt Winkel , Rs
      8. Loop Until Xx = X1
      Xx, Sdx und X1 sind dabei integer, sodass ein Xx=X1 ohne Probleme eintreffen kann (Sdx kann nur den Wert 1, 0 und -1 einnehmen). Um aber den Winkel mit Atn2 auszurechnen, brauche ich single. Dazu wird mit Xs=Xx aus einer integer eine single gemacht.
      Wenn ich diesen Umweg umgehen will und nur mit single rechnen will, muss ich auch die Until-Abfrage mit single gestalten. Da ist es mit dem 'gleich' ja nicht so einfach und eine Funktion, die ein 'ähnlich' ausgibt, kenn ich nicht. Wie könnte ich jetzt am geschicktesten diese Abfrage gestalten a_27_b277ca12 Es kann Xx sowohl negativ als auch positiv sein.
      Ein abs(Xx-X1)<0,1 wäre eine Abfrage 'Xx hinreichend gleich groß wie X1', erfordert aber viele Zwischenschritte, bis man diesen Vergleich hat.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Ich hab' single nicht weiter formatiert.
      Meine Problembeschreibung war jetzt leider auch recht unscharf formuliert.
      Ich will in der do..loop vom Anfangswert XX zum Endwert X1 mit der Schrittweite sdx kommen. Im oben gezeigte Beispiel ist sdx vom Vorzeichen schon so gewählt, dass ich durch mehrmaliges Addieren auf den Wert von X1 komme, zumal sdx die 'Größe' 1 hat und Xx und X1 ganzzahlige integerwerte sind.
      Wenn jetzt XX ein single ist, zB Xx=1.345, der Endwert X1= 2.4 ist und meine Schrittweite sdx=0.1 ist, dann wird sich Xx eben nur an X1 annähern, aber nie gleich sein. Die Abweichung untereinander ist dann halt <sdx.
      Was mir aber jetzt beim Gassigehen eingefallen ist, wäre das Ganze mit einer for n= Xx to X1 step sdx zu machen. Das müsste auch mit single gehen und auch abbrechen, wenn Xx und X1 eben 'ähnlich', nur um <sdx unterschiedlich, sind.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • stefanhamburg schrieb:

      Endebedingung befüllen
      Da muss ich aber auch vorher ausrechnen, wie oft sdx in die Differenz von X1-Xx rein passt. Das wäre dann auch schon die Lösung.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Die Zielvariable X1 kann größer als die Startvariable Xx sein, dann ist sdx positiv. X1 kann aber auch kleiner als Xx sein, dann wäre sdx negativ. Da müsste man wieder differenzieren ob >= oder <= die richtige Wahl wäre. Das sollte bei einer for..next doch automatisch gehen, oder?
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Hm, Beispiel:
      Startwert Xx < Zielwert X1, sdx ist somit positiv. Xx=Xx+sdx wird wiederholt ausgeführt, Ziel erreicht, wenn Xx >= X1.
      nächster Fall, der genauso abgedeckt werden soll
      Startwert Xx > Zielwert X1, sdx somit negativ. Xx=Xx+sdx wird wiederholt ausgeführt, Ziel erreicht, wenn Xx <= X1.
      Wie lautet dann die für beide Fälle gültige Abfrage? Differenz der beiden absoluten Beträge (abs(Xx) - abs(X1)) <= abs(sdx)?
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Hallo Meister Hora,

      ABS als Variable ohne Vorzeichen hattest Du ja schon erwähnt und wieder verworfen da die Nachkommastellen mit entscheidend sind
      Somit mein Hinweis auf Single –Format:
      Die 2. Stelle nach dem Komma abfragen egal was für ein Vorzeichen die Variablen haben.
      Mal so beschrieben, den richtigen Syntax für Bascom, habe ich momentan nicht im Kopf.
      IfX1, Digit(2) = Xx , Digit(2) Then mach was.

      Zwei Single- Variablen ohne Eingrenzung (Digit x )der Nachkommastellen zu vergleichen ist wie Topfschlagen.
      Nicht mit Runden verwechseln.

      Gruß
    • @fredred moment mal, wieso kann ich nicht zwei single vergleichen? Ich kann doch unabhängig von der Genauigkeit sagen A>B, A=B bzw A<B. Die 2. Stelle nach dem Komma sagt doch gar nix über die Größe der Zahl. -1,34 ist doch nicht größer als 12,12.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • #9


      Zu spät gelesen und somit Thema verfehlt.

      Ein „Richtungsvergleich“ der Variablen macht man natürlich nur in Abhängigkeit des Vorzeichen.

      Entschuldigung.

      Realisieren nur mit zeitgleichen Vergleich. Wer ist Größer der bestimmt die weitere Berechnungen oder so.
      Wenn es die Single nicht vorgibt selber Entscheidung treffen.
    • tschoeatsch schrieb:

      eine Funktion, die ein 'ähnlich' ausgibt, kenn ich nicht. Wie könnte ich jetzt am geschicktesten diese Abfrage gestalten
      Hier war mein Anlass „ähnlich ausgibt“ ein Tipp zu geben.
      Vorzeichen mit ABS erledigt. Vergleich mit der Vorkommastelle zu grob(ist aber die Mastervorgabe) aber sind die zweiten Kommastellen ungleich dann mach was.
      Heißt die Entscheidung wird erst hier getroffen. Also die Genauigkeit soll nur ähnlich sein.
      Wo habe ich dies behauptet.
      Zahl. -1,34 ist doch nicht größer als 12,12.

      Nein-1,34 ist auch gleich +1,34 aber erst wenn X1 = 1,34 und Xx = 1, 33 dann mach was.
      Also Wert nicht gleich aber fast.

      Mit freundlichen Grüßen
    • @fredred ok, so langsam versteh' ich das jetzt auch. Aber iste es nicht geschickter, gleich die kompletten Zahlen zu vergleichen, als erst drauf zu warten, bis 'vorne' es gleich ist, und dann auf die Nachkommastellen zu achten? Oder hab' ich's noch immer nicht kapiert?
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Hallo tschoeatsch,
      wie Bekannt habe ich immer Problemen, dass was ich im Kopf habe auch schriftlich zu vermitteln. Versuch es noch mal.
      Wenn ich die Frage richtig verstanden habe, machst Du Winkelberechnungen mit Single um eine höhere Genauigkeit zu bekommen.
      Deshalb auch meine Frage nach Format.
      Solche Berechnungen haben x viele Kommastellen die ja auch in der Single- Variable abgelegt werden.
      Möchtest Du 2 Variablen vergleichen und eine Entscheidung treffen wenn beide =. Müssen auch alle Kommastellen gleich sein. Macht wohl in deinem Projekt keinen Sinn eine Genauigkeit bis z.B. 0,0000000001 zu berechnen(Rechenleistung) und wenn die Mechanik 1/100 schafft ist dies schon gut.
      Somit mein Vorschlag die Single auf Digits = 2 zu setzen. Also nur bis zur 2. Nachkommastelle auswerden. Nun muss auch nur noch die 2. Stelle stimmen bis = erreicht wird.
      Auch ein Nachteil meinerseits ich habe immer noch Assembler im Kopf und denke auch bei Bascom immer noch „was machen die Register“. Deshalb noch ein Tipp setze mal Digits auf 3 und schon muss der CPU ein vielfaches mehr an Rechenleistung bringen. Wozu?
      Bin eigentlich immer mit Optimum und nicht mit Maximum gut ans Ziel gekommen.
      Naja sind schon andere Zeiten.

      Schalom
    • Ok, jetzt ist für mich klar, was du meinst.
      Einen Abbruch er Schleife bei gleichen singlevariablen, war von mir aber nicht geplant. Eine Gleichheit war bei ganzen Zahlen (integer) kein Problem und hat auch gut funktioniert. Jetzt will ich aber single verwenden und da nähern sich meine Start- und Zielvariable nur an, eine Gleichheit wäre ein seltener Zufall. Da ich mich in meinem Beispiel mal von einer kleineren Zahl zu einer größeren hin angleiche, aber es genauso sein kann, dass ich mich von einer größeren zu einer kleineren Zahl hin bewege, war für die Formulierung für das 'wann bin ich fertig' ein großer Rechenaufwand zu treiben (aus meiner Sicht) und da suchte ich eine elegantere Lösung (was ihr so für Ideen habt).
      Ich hab' das jetzt mit einer for..next-Schleife gelöst. Die wird dann beendet, wenn ich mich der Zielvariable auf einen Abstand nähere, der kleiner als der step ist. Das scheint zu funktionieren, egal von welcher Richtung ich mich nähere.

      Das Einkürzen der Nachkommastellen ist sicherlich sinnvoll, da hast du mir einen guten Denkanstoß verpasst. Das werde ich weiter verfolgen.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Hi

      Kenne deine Schleife nicht.
      Nur mal so, war als Ansatz schon erwähnt.
      Ja „annähern“ mit Stellenabfrage. Ist auch effektiver, nur den Inhalt zu zerlegen.
      Spart wieder Rechenleistung.

      Beispiel 1: Sehr genau.
      W1 = Mid (X1, 1, 4)‚ nun stehen in W1 die ersten 4 Zeichen
      W2 = Mid (Xx, 1, 4)‚ nun stehen in W2 die ersten 4 Zeichen
      If W1 = W2 Then mach was.

      Beispiel 2: Sehr ungenau.
      W1 = Mid (X1, 1 , 1)‚ nun steht in W1 das erstenZeichen
      W2 = Mid (Xx, 1 ,1 )‚ nun steht in W2 das erstenZeichen
      If W1 = W2 Then mach was.
      oder
      If W1 > W2 Then W2 = W1 usw.

      Vorteil kannst ab jeder Stelle eine Zeichenfolge ansprechen.
      ABC = Mid (X1, 3, 2) ‚also ab dritte Stelle 2 Zeichen.
      Oder nur jede Stelle einzeln betrachten/auswerten.
      ;(
      Gruß
    • Interessanter Ansatz, aber mal abgesehen, dass man in strings umwandeln muss, ist die 'Unschärfe' relativ. Wenn mein Ziel 122,567 ist, werden 122,5 betrachtet, auf zehntel genau, wenn mein Ziel 1,22567 ist, wird 1,225 betrachtet, auf tausendstel genau. Wobei ich mir jetzt nicht sicher bin, ob das Kommazeichen mit zählt.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Na dann nimm das Kommazeichen gleich noch als Trennzeichen. Na viel effektiver geht es wohl nicht.
      Scount= Split(X1 , W1",“)
      Bitte nicht gleich alles als Endgültig betrachten. Sind nur Übersetzungen.

      Doch ja noch ein Ecount einzubinden ist wohl das gelbe vom Ei.

      Gruß
    • Hm, jetzt läppern sich aber die Schritte, um zur Abfrage zu kommen. Ich würde mal sagen/schreiben, das war mal ein netter Ausflug in die Theorie.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------