C Felder: Unterschied zwischen den Versionen

Aus ITP
Zur Navigation springen Zur Suche springen
 
(8 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
== Grundlagen ==
prog template urs:1
kopf Felder
!*!Label Feld 1  - ein Feld mit 10 Einträger
let#f_1 1,2,3,4,5,6,7,8,9,10
        loop#anz    def(f_1)  $ Anzahl der Feldelemente in der Variable anz speichern
        endloop
txa
txa Das Feld f_1 hat #(#anz,5.0) Einträge.
txa
loop#1  #anz  $ Ausgabe des Feldes
    txa    index  = #(#1,2.0)  f_1 = #(#f_1(#1),6.3)
endloop
!*!Label Feld 2
let#f_2 #f_1(:)  $ Feld 2 wird komplett aus dem Feld 1 erzeugt
let#f_2(0) #f_2(0)*100    $ der 1. Eintrag wird mit 100 multipliziert
let#f_2(5) #f_2(5)*100    $ der mit dem Index 5 (das ist das 6. Element) ebenfalls
txa Feld 2
txa
loop#2  #anz
    txa    index  = #(#2,2.0)  f_2 = #(#f_2(#2),8.3)
endloop
!*!Label Feld 3
txa Feld 3
txa
txa statt dem Komma geht auch ein Leerzeichen
txa
let#f_3 10 11 12 13 14 15 16 17 18 19 20 21 22
        loop#anz    def(f_3)  $ Anzahl der Feldelemente in der Variable anz speichern
        endloop
txa
txa Das Feld f_3 hat #(#anz,5.0) Einträge.
txa
loop#1  #anz
    txa    index  = #(#1,2.0)  f_3 = #(#f_3(#1),6.3)
endloop
!*!Label Feld 4
txa
txa Das Feld f_4 wird über eine Funktion gefüllt
txa
sto#fun_1  '=FUN(i,sqr(5*#i))' $ FUN muß groß geschrieben werden
loop#1 5
        let#i  #1+1
        let#f_4(#i) #fun_1(#i)
        txa    index  = #(#i,2.0)  f_4 = #(#f_4(#i),6.3)
endloop
ende
ende
== mächtiges Werkzeug ==
== mächtiges Werkzeug ==
'''Loop über ein Feld''' ist ein sehr mächtiges Werkzeug. Es gibt viele sinnvolle Anwendungen.
'''Loop über ein Feld''' ist ein sehr mächtiges Werkzeug. Es gibt viele sinnvolle Anwendungen.
Zeile 57: Zeile 136:
endloop
endloop
== Beispiel 2 - vier verschiedene Laststellungen ==
== Beispiel 2 - vier verschiedene Laststellungen ==
Im Feld pos werden die vier unterschiedlichen X-Werte der Laststellungen gespeichert. Der Block area2 beinhaltet die Definition der kleinen Flächenlasten.
Im Feld pos werden die vier unterschiedlichen X-Werte der Laststellungen gespeichert. Der includierte Block area2 beinhaltet die Definition der kleinen Flächenlasten.


Die Schleife erzeugt die einzelnen Lastfälle FAT:
Die Schleife erzeugt die einzelnen Lastfälle FAT:
Zeile 82: Zeile 161:
         let#lf #lf+1
         let#lf #lf+1
endloop
endloop
== Anzahl der Elemente ==
Es gibt eine spezielle "Schleife", mit welcher man die '''Anzahl''' der Elemente eines Feldes ermitteln und in einer Variablen ablegen kann.
let#grp 4
let#nr  #grpdiv*#grp
$ QT 1. Feld
let#nrwv    2,3,6,8,9,10,11,12,13,16
'''loop#anz    def(nrwv)'''  $ Anzahl der Feldelemente des Feldes nrwv in der Variable anz speichern
'''endloop'''
loop#3  #anz-1
    sln    nr              npa                    npe            grp=#grp styp='B' qnr=3
            #nr+(#3*10+1)  #nrwv(#3)*100+12        #nrwv(#3+1)*100+51
            #nr+(#3*10+2)  #nrwv(#3+1)*100+51      #nrwv(#3)*100+62
endloop




[[Kategorie:Allgemeines zu CADINP]]
[[Kategorie:Allgemeines zu CADINP]]

Aktuelle Version vom 5. Juli 2020, 11:07 Uhr

Grundlagen

prog template urs:1

kopf Felder

!*!Label Feld 1 - ein Feld mit 10 Einträger

let#f_1 1,2,3,4,5,6,7,8,9,10

       loop#anz    def(f_1)  $ Anzahl der Feldelemente in der Variable anz speichern
       endloop

txa

txa Das Feld f_1 hat #(#anz,5.0) Einträge.

txa

loop#1 #anz $ Ausgabe des Feldes

   txa     index  = #(#1,2.0)   f_1 = #(#f_1(#1),6.3)

endloop

!*!Label Feld 2

let#f_2 #f_1(:) $ Feld 2 wird komplett aus dem Feld 1 erzeugt

let#f_2(0) #f_2(0)*100 $ der 1. Eintrag wird mit 100 multipliziert

let#f_2(5) #f_2(5)*100 $ der mit dem Index 5 (das ist das 6. Element) ebenfalls

txa Feld 2

txa

loop#2 #anz

   txa     index  = #(#2,2.0)   f_2 = #(#f_2(#2),8.3)

endloop

!*!Label Feld 3

txa Feld 3

txa

txa statt dem Komma geht auch ein Leerzeichen

txa

let#f_3 10 11 12 13 14 15 16 17 18 19 20 21 22

       loop#anz    def(f_3)  $ Anzahl der Feldelemente in der Variable anz speichern
       endloop

txa

txa Das Feld f_3 hat #(#anz,5.0) Einträge.

txa

loop#1 #anz

   txa     index  = #(#1,2.0)   f_3 = #(#f_3(#1),6.3)

endloop

!*!Label Feld 4

txa

txa Das Feld f_4 wird über eine Funktion gefüllt

txa

sto#fun_1 '=FUN(i,sqr(5*#i))' $ FUN muß groß geschrieben werden

loop#1 5

       let#i  #1+1
       let#f_4(#i) #fun_1(#i)
       txa     index  = #(#i,2.0)   f_4 = #(#f_4(#i),6.3)

endloop

ende

ende

mächtiges Werkzeug

Loop über ein Feld ist ein sehr mächtiges Werkzeug. Es gibt viele sinnvolle Anwendungen.

Wesentlich ist die Definition des Feldes und der anschließende Aufruf des Feldnames (ohne #) im LOOP - Befehl. Die Schleife wird sooft durchlaufen, wie das Feld Elemente hat.

Falls das Feld "unregelmäßig" ist, kann man das Feld über Schleifen belegen.

Man sollte sich hüten, ein einmal definiertes Feld erneut zu verwenden. Denn die maximale Feldlänge (und diese bestimmt die Anzahl der Schleifenläufe) wird intern gespeichert. Bei einer erneuten Feldbelegung mit einer kleineren Elementanzahl kommt es dann zu Fehlern.

Beispiel 1 - Pfetten einer Stahlhalle

In den Feldern ya und yb stecken die Y-Werte der einzelnen Hallenrahmen.

Die nachstehende Schleife generiert über alle 14 Felder die Pfetten. Mit der if-Bedingung wird noch der entsprechende Querschnitt ausgewählt.

!*!Label Längspfetten auf dem Dach

let#ya #y1,#y2,#y3,#y4,#y5,#y6,#y7,#y8,#y9,#y10,#y11,#y12,#y13,#y14

let#yb #y2,#y3,#y4,#y5,#y6,#y7,#y8,#y9,#y10,#y11,#y12,#y13,#y14,#y15

loop#i ya

       let#l           #ya(#i)-#yb(#i)
       let#y11         #yb(#i)+((#l/2)+(#ylb/2))
       let#y12         #y11-#ylb
       let#grp 410+(#i*10)
       let#knr         #grp*#gdiv      $ neue Knoten
       spt     nr              x       y               z
               #knr+11+100     #x31    #y11            #z31
               #knr+12+100     #x31    #y12            #z31
               #knr+11+200     #x32    #y11            #z32
               #knr+12+200     #x32    #y12            #z32
               #knr+11+300     #x33    #y11            #z33
               #knr+12+300     #x33    #y12            #z33
       $        Pfetten
       let#grpa        10+(#i)*10
       let#grpb        #grpa+10 $ Gruppe des hinteren Rahmen
       if #i==6
               let#qnr 27
       else
               let#qnr 26
       endif
       sln     nr      npa             npe                             qnr=#qnr     grp=#grp        styp='B'
               -       #gdiv*#grpa+31  #knr+11+100     $fixa mymz
               -       #knr+11+100     #knr+12+100
               -       #knr+12+100     #gdiv*#grpb+31  $fixe mymz
               -       #gdiv*#grpa+32  #knr+11+200     $fixa mymz
               -       #knr+11+200     #knr+12+200
               -       #knr+12+200     #gdiv*#grpb+32  $fixe mymz
               -       #gdiv*#grpa+33  #knr+11+300     $fixa mymz
               -       #knr+11+300     #knr+12+300
               -       #knr+12+300     #gdiv*#grpb+33  $fixe mymz

endloop

Beispiel 2 - vier verschiedene Laststellungen

Im Feld pos werden die vier unterschiedlichen X-Werte der Laststellungen gespeichert. Der includierte Block area2 beinhaltet die Definition der kleinen Flächenlasten.

Die Schleife erzeugt die einzelnen Lastfälle FAT:

let#pos 0,1.5,2.7,7.15-(4.2),7.15-(4.2/2)

let#lf 101

loop#i pos

       lf nr #lf typ FAT bez 'FAT - #lf'
       $Startpunkt 1
       let#xs #pos(#i)
       let#ys 3.500
       let#zs 0.000
       #include area2
       $Startpunkt 2
       let#xs #pos(#i)
       let#ys 3.500-3
       let#zs 0.000
       #include area2
       let#lf #lf+1

endloop

Anzahl der Elemente

Es gibt eine spezielle "Schleife", mit welcher man die Anzahl der Elemente eines Feldes ermitteln und in einer Variablen ablegen kann.

let#grp 4

let#nr #grpdiv*#grp

$ QT 1. Feld

let#nrwv 2,3,6,8,9,10,11,12,13,16

loop#anz def(nrwv) $ Anzahl der Feldelemente des Feldes nrwv in der Variable anz speichern

endloop

loop#3 #anz-1

   sln     nr              npa                     npe             grp=#grp styp='B' qnr=3
           #nr+(#3*10+1)   #nrwv(#3)*100+12        #nrwv(#3+1)*100+51
           #nr+(#3*10+2)   #nrwv(#3+1)*100+51      #nrwv(#3)*100+62

endloop