debianforum.de

Verfasst: **25.03.2004 20:41:55**

Danke für die weiteren Links und Tipps. Habe gerade angefangen mit diesem Tutorial: http://web.mit.edu/taoyue/www/tutorials/pascal/

Erstes Ergebnis ist:

Code: Alles auswählen

Program chapter_one;

const
	int_signified = 5;

var
	integer_average : real;
	integer_sum : integer;
	num1, num2, num3, num4, num5: integer;	


begin (* main *)

	num1 := 45;
	num2 := 7;
	num3 := 68;
	num4 := 2;
	num5 := 34;
	integer_sum := num1 + num2 + num3 + num4 + num5;
	integer_average := integer_sum /  int_signified;

	writeln ('Anzahl an Integern = ', int_signified);
	writeln ('Zahl Eins = ', num1); 
	writeln ('Zahl Zwei = ', num2); 
	writeln ('Zahl Drei = ', num3); 
	writeln ('Zahl Vier = ', num4); 
	writeln ('Zahl Fuenf = ', num5); 
	writeln ('Summe = ', integer_sum);
	writeln ('Der Durchschnitt = ', integer_average);

end.

Ist natürlich Kinderkram aber ich hätte nicht gedacht dass man so schnell ein erstes Ergebnis bekommt ohne viel lesen zu müssen. Kapitel 1 ist damit schonmal durch.

MFG, David

Verfasst: **25.03.2004 20:46:14**

Bert hat geschrieben:Und ich verstehe nicht die allgemeine Abneigung gegen Java

Dem kann ich mich nur anschließen.
Ich möchte beispielsweise ganz sicher keine Webapplikation in C++ entwickeln müssen.

Bert hat geschrieben:In C++ fang ich bei jedem Programm von vorne an, mir die Schrauben zu feilen, obwohl ich doch eigentlich ein Auto bauen will. In Java greif ich dazu einfach in die Kiste.

Naja, ganz so schlimm ist es ja nun doch nicht. Es gibt viele gute (und auch freie) Bibliotheken, die eigentlich fast jeden Anwendungsbereich abdecken.
Außerdem legt man sich mit der Zeit ja auch seine eigene Toolbibliothek an.
Meine Schrauben feile ich einmal, danach nehme ich sie ins nächste Projekt mit.
Und auch in Java passt nicht alles wie aus einem Guß zusammen. Gerade die Container-Klassen sind im Vergleich zu C++ ne Katastrophe.

Bert hat geschrieben:@BeS: Ja, auf der gleichen Seite sagt Stroustrup (auf die Komplexität von C++ angesprochen) auch sinngemäß, das Java halt noch sehr Jung ist, und eine der fortgeschrittenen Konzepte (Templates) auch noch kommen werden und die Sprache dann auch komplexer wird. Und siehe da, er hat Recht behalten.

Naja, ich nehme mal an, Du spielst auf die Generics an. Alles, was die bringen, ist einem endlich die lästigen und fehlerträchtigen Typecasts in Verbindung mit Containern vom Hals zu schaffen.
Amsonsten sind Generics nicht ansatzweise so mächtig wie Templates. Stichwort Template-Metaprogrammierung.

Bert hat geschrieben:Achja, und für Java gibts einfach eine geniale IDE (eclipse)

Da gibts glaube ich auch ein C++-Plugin für.
Offengestanden finde ich das SWT-GTK-Binding grottenlahm. Da sollte das Eclipse-Team mal was dran machen. Das Windows-Binding ist wesentlich schneller.
Und die beste Java-IDE ist immer noch Codeguide. Leider nicht kostenlos.

Bert hat geschrieben:Zum Thema: Ich würd würde für den Anfang ganz klar zu Java raten. Wenn Du eventuell später mal Deine Brötchen mit dem Programmieren verdienen willst, dann ist Pascal, tja wie soll ichs höflich sagen, ...

Zum Lernen ist Java sicherlich nicht schlecht.

Mein persönliches Fazit:
Java ist ne tolle Sprache für Middlewar-Programmierung. Auf dem Desktop für mich immer noch zu langsam und zu resourcenfressend.

Verfasst: **26.03.2004 00:36:40**

Hi,

habe demletzt einen im Dezember veröffentlichten Bericht über die Features von Java 1.5 gelesen.
Nun, es sollen Templates in Java Einzug erhalten, aber der Compiler nutzt sie quasi nur als Wrapper, denn beim Übersetzen in Bytecode macht er doch die Lösung "von hinten durch die Brust ins Auge". Sicherlich ist das für den Programmierer einfacher und weniger umständlich und fehlerträchtig, was die Performance angeht, stellt sich hier also keine Besserung ein. Casting hier, Casting dort, die neuen Typen, Typüberprüfungen zur Laufzeit (instanceof ...) usw.
Also IMHO keine wirkliche Verbesserung, sondern nur ein Wrapper um einen Wrapper.

BTW, langsam kommen wir vom eigentlichen Problem von David ab

Und weil ich noch was zu David sagen will:

Code: Alles auswählen

integer_average : real;

irgendwie sieht das unsauber aus.
Gerade unter C und C++ gibt's ne Konvention, mir fällt gerade nicht mehr der Name ein -- polnische Notation, oder war das die Taschenrechnereingabe? -- bei der man den Datentyp beim Variablennamen mit angibt, also z.B.

Code: Alles auswählen

intVar_1 : integer;
chVar_2 : char;

entsprechend erwarte ich von einer Variablen, die mit integer beginnt, daß es auch ein integer ist.

Deine integer_average ist aufgrund dessen, was sie leisten muß, sinnvollerweise eine real-Variable, jedoch suggeriert der Name eine integer-Variable. Dies kann bei einem größeren Programm zu reichlich Verwirrung und Zuweisungsfehlern führen. Und weil's keine platte Kritik sein soll, gleich noch ein Verbesserungsvorschlag zur Benennung der Variable:

Code: Alles auswählen

av_of_int_sum : real;

Verfasst: **26.03.2004 01:08:38**

Hallo David und alle anderen Interessierten,

ich hab mal das Progrämmchen von David in Python umgesetzt.
Erstmal ohne Spezialsachen.

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: UTF-8 -*-

int_signified = 5

num1, num2, num3, num4, num5 = 45, 7, 68, 2, 34
integer_sum = num1 + num2 + num3 + num4 + num5
integer_average = integer_sum / int_signified

print 'Anzahl an Integern =', int_signified
print 'Zahl Eins =', num1
print 'Zahl Zwei =', num2
print 'Zahl Drei =', num3
print 'Zahl Vier =', num4
print 'Zahl Fuennf =', num5
print 'Summe =', integer_sum
print 'Der Durchschnitt =', integer_average

und jetzt wie ich das in Python mit allen Schikanen machen würde:

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: UTF-8 -*-

num = [45, 7, 68, 2, 34]
int_signified = len(num)
integer_sum = sum(num)
average = float(integer_sum) / float(int_signified)

print "Anzahl an Integern = %i" % int_signified

num_names = ["Eins", "Zwei", "Drei", "Vier", "Fuenf", "Sechs", "Sieben", "Acht"]
for name, value in zip(num_names, num):
    print "Zahl %s = %i" % (name, value)
    
print 'Summe =', integer_sum
print 'Der Durchschnitt = %0.2f' % average

Gruß

Dookie

Verfasst: **26.03.2004 01:26:03**

Dookie hat geschrieben: und jetzt wie ich das in Python mit allen Schikanen machen würde:

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: UTF-8 -*-

num = [45, 7, 68, 2, 34]
int_signified = len(num)
integer_sum = sum(num)
average = float(integer_sum) / float(int_signified)

print "Anzahl an Integern = %i" % int_signified

num_names = ["Eins", "Zwei", "Drei", "Vier", "Fuenf", "Sechs", "Sieben", "Acht"]
for name, value in zip(num_names, num):
    print "Zahl %s = %i" % (name, value)
    
print 'Summe =', integer_sum
print 'Der Durchschnitt = %0.2f' % average

Gruß

Dookie

Na, da finde ich Pascal oder C eindeutig lesbarer!

Hab mich gerade mal bei python.org umgeschaut. Klingt schon interessant, aber mit der Syntax kann ich mich irgendwie nicht so anfreunden. Hab ich schon zu lange in Pascal, C und C++ gecoded ....

Verfasst: **26.03.2004 01:56:36**

jogix hat geschrieben:Na, da finde ich Pascal oder C eindeutig lesbarer!

Das ist Gewöhnungssache. Und lesbarer als Perl isses allemal.

jogix hat geschrieben:Gerade unter C und C++ gibt's ne Konvention, mir fällt gerade nicht mehr der Name ein -- polnische Notation, oder war das die Taschenrechnereingabe? -- bei der man den Datentyp beim Variablennamen mit angibt

Was Du meinst, ist die Ungarische Notation. Die heißt so, weil ihr "Erfinder" Charles Simonyi gebürtiger Ungar ist.
Erschwert IMHO die Lesbarkeit des Codes und ist unter C++ ohnehin nicht sinnvoll und konsequent umsetzbar.
Die Umgekehrt Polnische Notation (Postfix-Notation) gibts bei Taschenrechnern von HP. Dabei steht der Operator hinter den Operanden und nicht wie eigentlicht üblich zwischen ihnen. Das hat den Vorteil, das man keine Klammern braucht.

Verfasst: **26.03.2004 02:10:00**

spiffi hat geschrieben: Was Du meinst, ist die Ungarische Notation. Die heißt so, weil ihr "Erfinder" Charles Simonyi gebürtiger Ungar ist.
Erschwert IMHO die Lesbarkeit des Codes und ist unter C++ ohnehin nicht sinnvoll und konsequent umsetzbar.
Die Umgekehrt Polnische Notation (Postfix-Notation) gibts bei Taschenrechnern von HP. Dabei steht der Operator hinter den Operanden und nicht wie eigentlicht üblich zwischen ihnen. Das hat den Vorteil, das man keine Klammern braucht.

Na, da lag ich namentlich gar nicht so falsch

Verdammte Namen kann ich mir eh nicht merken

Nee, so lesbar finde ich die ungarische Notation auch nicht, es gibt aber Firmen, die unbedingt die Einhaltung dieser Konvention fordern - was will man machen?!

Aber letzlich ging es ja darum, wenn man schon einen Datentyp voranstellt, erwartet man auch, daß die Variable von diesem Typ ist, weil irgendwie logisch, zumindest wenn man diese Notation kennt

Aber ich tu mir ja auch bei C++ schon schwer, den Membervariablem ein m oder m_ voranzustellen, da Zuweisungen der Form

Code: Alles auswählen

m_meineVar = meineVar;

IMHO auf nicht gerade übersichtlich strukturierte Programmierung hinweisen.
Zudem, wenn man dann doch mal das m_ vergißt, wundert man sich gelegentlich, warum etwas passiert - oder eben nicht (Verändern einer Referenz, nicht speichern in lokaler Variablen). Und Fehler dieser Art lassen sich erfahrungsgemäß nur schwer entdecken

Verfasst: **26.03.2004 02:10:51**

jogix hat geschrieben: Hab mich gerade mal bei python.org umgeschaut. Klingt schon interessant, aber mit der Syntax kann ich mich irgendwie nicht so anfreunden. Hab ich schon zu lange in Pascal, C und C++ gecoded ....

jo C und C++ versaut einen

Das Beispiel ist auch nicht sehr aussagekräftig, ich wollte eher zeigen, was man sich alles bei Python erspart. Keine Variablendeklaraton, kein begin/end.

Ein schönes Stückchen Code finde ich meinen Nullstellenfinder.

Code: Alles auswählen

from math import *

func = "x*x*x+x+3" #wird von der GUI geändert

def f(x):
    return eval(func)

def solve(x1,x2):
    r1 = f(x1)
    r2 = f(x2)
    if r1 > 0.0 and r2 < 0.0:
        x1, x2 = x2, x1
        r1, r2 = r2, r1
    if r1 > 0.0 and r2 > 0.0:
        raise ValueError("Fehler: Beide Werte positiv")
    elif r1 < 0.0 and r2 < 0.0:
        raise ValueError("Fehler: Beide Werte negativ")
    elif r1 == 0.0:
        return x1
    elif r2 == 0.0:
        return x2

    # successive approximation
    for i in xrange(1,101):
        xm = (x1+x2)*0.5
        val = f(xm)
        if abs(val) < 1.0e-12:
            break # nearly zero found - exit loop
        if val < 0.0:
            x1 = xm
        else:
            x2 = xm
    else: # for 100 iterations 
        raise ValueError("nach 100 Iterationen keine Nullstelle")
        
    print "Iterationen -> %i" % (i)
    print "Abweichung  -> %e" % (val)
    return xm
    

if __name__ == "__main__":
    func = raw_input("Funktion:  ")
    a = float(input("Startwert: "))
    b = float(input("Endwert:   "))
    print "Ergebnis = %f" % (solve(a,b))

gibts auf http://www.boa3d.de/python/tools/Nullstellenrechner.zip auch mit Gtk2-GUI
Bild

Mach sowas mal mit C/C++

Gruß

Dookie

Verfasst: **26.03.2004 08:37:25**

entsprechend erwarte ich von einer Variablen, die mit integer beginnt, daß es auch ein integer ist.

Deine integer_average ist aufgrund dessen, was sie leisten muß, sinnvollerweise eine real-Variable, jedoch suggeriert der Name eine integer-Variable. Dies kann bei einem größeren Programm zu reichlich Verwirrung und Zuweisungsfehlern führen. Und weil's keine platte Kritik sein soll, gleich noch ein Verbesserungsvorschlag zur Benennung der Variable:

Danke für den Hinweis. Ich hatte es integer_ benannt, da ich damit die integer Zahlen berechne aber jetzt wo du es sagst werde ich mir das dann gleich abgewöhnen.

MFG, David

Verfasst: **26.03.2004 08:46:56**

@ dookie

Code: Alles auswählen

num = [45, 7, 68, 2, 34]
int_signified = len(num)

Verstehe ich dass richtig dass len(num) einfach die in der Variablen num gespeicherten Zahlen abzählt?

FLOAT ist synonym mit Pascal's REAL, oder? Es geht dabei um Fliesskommazahlen?!

Keine Variablendeklaraton, kein begin/end.

Gerade das finde ich aber als Anfänger recht angenehm, da ich so gleich eine gewisse Struktur vorgegebene habe. Später mag ich darüber dann anders denken, keine Ahnung...

Verfasst: **26.03.2004 10:13:20**

DavidJ hat geschrieben:@ dookie
Code: Alles auswählen
num = [45, 7, 68, 2, 34]
int_signified = len(num)
Verstehe ich dass richtig dass len(num) einfach die in der Variablen num gespeicherten Zahlen abzählt?

FLOAT ist synonym mit Pascal's REAL, oder? Es geht dabei um Fliesskommazahlen?!

Keine Variablendeklaraton, kein begin/end.
Gerade das finde ich aber als Anfänger recht angenehm, da ich so gleich eine gewisse Struktur vorgegebene habe. Später mag ich darüber dann anders denken, keine Ahnung...

yupp, len(num) gibt die Anzahl der Elemente in num zurück.
Und, ja, float und double, wie sie bei C, C++, Java, Python heißen sind Fließkommazahlen mit einfacher und doppelter Genauigkeit und somit quasi das gleiche wie real in Pascal.

Nun, auch wenn ich kein Programmieranfänger mehr bin, finde ich eine Fehlende Variablendeklaration nicht gerade sehr vertrauenswürdig. Ist doch irgendwie fragwürdig, ob die Typsicherheit da so gewährleistet ist. Und gerade damit wirbt doch z.B. Java und C++. Typsicherheit vermeidet seltsame Programmreaktionen durch falsche Zuweisungen.

BTW, so wild ist die Nullstellenproblematik bei C++ nun auch wieder nicht

Achso, genau, wenn Du eine x^3 Funktion hast, also eine Funktion dritten Grades oder höher, dann hast Du auch drei Nullstellen oder mehr, aber Du berechnest in dem Code nur zwei Nullstellen. Und doppelte Nullstellen (Berührpunkte) findest Du damit auch nicht

Aber das ist das Standardproblem bei Numerik

Wenn ich mal Zeit habe (insbesondere mich in Flex einzuarbeiten), dann schreibe ich mal ein Programm, das symbolisch integrieren und differenzieren kann. Zweiteres ist sowieso ganz einfach, ersteres sollte über die Taylorreihendarstellung auch nicht wirklich schwer sein, weil die Problematik bis auf zwei Ausnahmen komplett auf Int( x^n dx) zurückgeführt werden kann. Somit ist nur das sinnvolle Parsen des Ausdrucks wirklich kniffelig.

Verfasst: **26.03.2004 17:52:35**

Dookie hat geschrieben:Hallo David und alle anderen Interessierten,

und jetzt wie ich das in Python mit allen Schikanen machen würde:

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: UTF-8 -*-

num = [45, 7, 68, 2, 34]
int_signified = len(num)
integer_sum = sum(num)
average = float(integer_sum) / float(int_signified)

print "Anzahl an Integern = %i" % int_signified

num_names = ["Eins", "Zwei", "Drei", "Vier", "Fuenf", "Sechs", "Sieben", "Acht"]
for name, value in zip(num_names, num):
    print "Zahl %s = %i" % (name, value)
    
print 'Summe =', integer_sum
print 'Der Durchschnitt = %0.2f' % average

Gruß

Dookie

Also dazu möchte ich noch folgende Beispiele in anderen Programmiersprachen liefern (Java habe ich mal ausgelassen, da die konkrete Umsetzung des Problems eher gewöhnlich aussieht und keine speziellen Features der Sprache benötigt:

Ruby (eine sehr schöne Sprache meiner Meinung nach; leider keine Multiple Vererbung aber dafür Operator-Overloading; gibts das eigentlich in der Zwischenzeit auch in Python?) Wie man sieht ist sum nicht da, als habe ich es programmiert:

Code: Alles auswählen

#!/usr/bin/ruby1.8

a=45, 7, 68, 2, 34
b= "Eins", "Zwei", "Drei", "Vier", "Fuenf", "Sechs", "Sieben", "Acht"

class << a; def sum; r=0; each { |i| r+=i}; r; end; end

print "Anzahl ", a.length, "\n"
print "Summe ", a.sum, "\n"
print "Durchschnitt ", a.sum.to_f / a.length, "\n"

a.zip( b).each { |i, j| print "Zahl: ", i, " Name: ", j, "\n"}

Dann in der Sprache icon; eine Sprache, die viele Features aus Prolog mitbringt (implizites Backtracking, Goal-Orientierte Programmabarbeitung) aber immer noch eine C-Ähnliche Notation hat und recht gut lesbar ist, auch hier musste sum programmiert werden (rekursiv, geht aber auch iterativ), leider muß icon erst compiliert werden aber das ist eigentlich nicht weiter schlimm, wir sind nur schon viel zu versaut durch bash perl python ruby tcc ... :-):

Code: Alles auswählen

procedure sum( l)
 suspend l[1 ]+ sum( l[2:0]) | suspend 0;
end

procedure main()

 l1:= [ 45, 7, 68, 2, 34] 
 l2:= [ "Eins", "Zwei", "Drei", "Vier", "Fuenf", "Sechs", "Sieben", "Acht"]

 write( "Anzahl: ", *l1);

 write( "Summe ", sum( l1));

 write( "Durchschnitt ", ( 0.0+ sum( l1))/ ( *l1))

 ll1:= create( !l1);
 ll2:= create( !l2);

 while write( "Zahl: ", @ll1, " Name: ", @ll2)
end

Und zuletzt noch in Swi-Prolog, weil Prolog sehr schön mit Listen umgehen kann und man da einen faibel für rekursives Programmieren/Denken bekommt (teils, weil es auch nicht anders geht :-) ):

Code: Alles auswählen

#!/usr/bin/swipl -q -t main -s

numbers( [45, 7, 68, 2, 34]).
names( [ 'Eins', 'Zwei', 'Drei', 'Vier', 'Fuenf', 'Sechs', 'Sieben', 'Acht']).

len( [], 0).
len( L, LEN):- [_|T]= L, len( T, LEN_DOWN), LEN is LEN_DOWN+ 1.

sum( [], 0).
sum( L, SUM):- [H|T]= L, sum( T, SUM_DOWN), SUM is SUM_DOWN+ H.

mywrite( []).
mywrite( L):- [H|T]= L, write( H), mywrite( T).

mymap( _, [], _, [], _, []).
mymap( _, [], _, _, _, []).
mymap( _, _, _, [], _, []).
mymap( S1, L1, S2, L2, S3, LRES):- [H1|T1]=L1, [H2|T2]=L2, mymap( S1, T1, S2, T2, S3, TRES), LRES=[S1,H1,S2,H2,S3|TRES].

main:- numbers( LN), len( LN, LEN), mywrite( [ 'Anzahl ', LEN, '\n']), sum( LN, SUM),
       mywrite( [ 'Summe ', SUM, '\n']), AVG is SUM/LEN, mywrite( [ 'Durchschnitt ', AVG, '\n']),
       names( LNA), mymap( 'Zahl ', LN, ' Wert ', LNA, '\n', LIST), mywrite( LIST).

Jetzt wäre noch Ada und Lisp interessant, also, wer Lust hat, kann hier noch etwas dazu beitragen.

weedy.

Verfasst: **26.03.2004 20:57:58**

Hallo,
dann will ich auch mal die Programme in schem präsentieren

Das Programm von DavidJ:

Code: Alles auswählen

(define zahlen '((num1 45)(num2 7)(num3 68)(num4 2)(num5 34)))

(define program
  (lambda()
    (let loop ((liste zahlen)(sum 0)(anz 0))
      (cond ((null? liste)
             (display "Summe: ")(display sum)(newline)
             (display "Durchschnitt: ")(display (/ sum anz))(newline))
            (#t (display (car liste))(newline)
                (loop (cdr liste)(+ sum (cadar liste))(+ anz 1)))))))

Aufruf in einem scheme interpreten einfach mit (program)

Und das Programm von Dookie:

Code: Alles auswählen

(define dx 0.00001)

(define (ableitung func x)
  (/ (- (func(+ x dx)) (func x))
     dx))

(define (nullstelle func x)
  (let loop ((erg x))
    (cond ((> (abs (- (- erg (/ (func erg) (ableitung func erg))) erg))
              dx)
           (loop (- erg (/ (func erg) (ableitung func erg)))))
          (#t erg))))

Aufruf: (nullstelle (lambda(x)(+ (* x x x) x 3)) 0)
Mit diesem Aufruf wird die Nullstelle der Funktion x^3 +x + 3 berechnet, beginnend an dem Punkt x=0

Verfasst: **26.03.2004 21:31:27**

BeS hat geschrieben:

Code: Alles auswählen

(define dx 0.00001)

(define (ableitung func x)
  (/ (- (func(+ x dx)) (func x))
     dx))

(define (nullstelle func x)
  (let loop ((erg x))
    (cond ((> (abs (- (- erg (/ (func erg) (ableitung func erg))) erg))
              dx)
           (loop (- erg (/ (func erg) (ableitung func erg)))))
          (#t erg))))

Aufruf: (nullstelle (lambda(x)(+ (* x x x) x 3)) 0)

Das wäre dann in Python

Code: Alles auswählen

dx = 1e-6
def ableitung(func,x):
    return (func(x+dx) - func(x))/dx
                                                                                
def nullstelle(func,x):
    erg = x+2*dx
    while abs(erg-x)>dx:
        erg , x = x , x-func(x)/ableitung(func,x)
    return erg

Aufruf: nullstelle (lambda x: x**3+x+3,0)

Hey, dies könnte ja zu einem "meine Sprache ist besser"-Thread werden

BTW: Scheme ist auch nett, aufgrund der vielen Klammern kann man den Code aber nach ein paar Wochen nicht mehr lesen.

Irgendjemand hat noch geschrieben, dass es kompliziert wird, wenn Python verschiedene Programmparadigmen mischt. Das sehe ich nicht so, das Programm oben war zum größten Teil imperativ, die funktionelle Programmierweise ist halt da, wenn man sie mal braucht. Z.B. kann man quicksort wie folgt schreiben:

Code: Alles auswählen

def qsort(list):
    if len(list) == 0:
        return []
    first = list[0]
    return qsort ([i for i in list[1:] if i<first]) + \
           [first] + \
           qsort ([i for i in list[1:] if i>=first])

Natürlich würde man zum sortieren von listen einfach list.sort() aufrufen.

Soll ich jetzt noch ein Haskell programm posten?

Verfasst: **26.03.2004 21:44:24**

Joghurt hat geschrieben: BTW: Scheme ist auch nett, aufgrund der vielen Klammern kann man den Code aber nach ein paar Wochen nicht mehr lesen.

kommt eigentlich darauf an wie sauber man programmiert. Wenn man an den richtige Stellen eine neue Zeile anfängt erklärt sich das Programm eigentlich von selbst ohne das man auf die Klammern wirklich achten muß und bei schreiben zeigt dir dein Editor eigentlich immer an wo du bist damit man nicht durcheinander kommt.
Zum Beipspiel könnte man die >-Abfrage in der cond Zeile so etwas übersichtlicher machen:

Code: Alles auswählen

(> (abs (-
         (- erg
            (/ (func erg)
               (ableitung func erg)))
         erg))
   dx)

aber ich wollte dass das Programm nicht so groß wirkt

Ich finde auch solche "Spielereien" mit scheme ganz nett:
(apply map list '((a 1)(b 2)(c 3)(d 4)))
Da kommt dann raus: '((a b c d)(1 2 3 4))
Mit welchen anderen Sprachen, ausser Funktionellen, kann schon so nette Sachen machen

Soll ich jetzt noch ein Haskell programm posten?

klar, immer her damit

Verfasst: **26.03.2004 21:56:28**

Ist Scheme jetzt nur eine funktionale Erweiterung von Lisp oder bringt es auch Syntaxerweiterungen mit? Oder ist es gar eine bis auf das Aussehen eigenständige Sprache?

*verwirrt*

weedy.

PS: lerne demnächst mlton, goo, guile, scheme, haskell und ocaml.

Verfasst: **26.03.2004 22:00:30**

BeS hat geschrieben:Mit welchen anderen Sprachen, ausser Funktionellen, kann schon so nette Sachen machen

Ich liebe funktionelle Sprachen! BTW: map(None,('a',1),('b',2),('c',3),('d',4))

BeS hat geschrieben:klar, immer her damit

OK, aber für heute nur qsort

Code: Alles auswählen

qsort []     = []
qsort (x:xs) = qsort kleiner ++ [x] ++ groesser
	        where
	         kleiner  = [y | y <- xs, y<x]
                 groesser = [y | y <- xs, y>=x]

Mein Favorit, was die Syntax angeht.

Verfasst: **26.03.2004 22:02:06**

weedy hat geschrieben:Ist Scheme jetzt nur eine funktionale Erweiterung von Lisp

Ich dachte immer, LISP wäre auch funktional? Hilfe! Aufklärung

Verfasst: **26.03.2004 22:05:28**

weedy hat geschrieben:Ist Scheme jetzt nur eine funktionale Erweiterung von Lisp oder bringt es auch Syntaxerweiterungen mit? Oder ist es gar eine bis auf das Aussehen eigenständige Sprache?

scheme ist ein Lisp-Dialekt.
Wenn man scheme oder lisp kennt, dann kommt einem vieles beim anderen bekannt vor, aber ganz so einfach kann man letztlich doch nicht die Programme übertragen.
Besonders sympatisch an scheme finde ich das auf ~50 Seiten alles erklärt ist was es zu erklären gibt: http://www.schemers.org/Documents/Standards/R5RS/HTML/

PS: lerne demnächst mlton, goo, guile, scheme, haskell und ocaml.

Scheme und guile sind mehr oder weniger das gleiche. Ich mache alle meine scheme sachen mit guile.

@Joghurt:
Haskell hat eine gewisse ähnlichkeit mit ML, oder? Zumindest so auf den ersten Blick.

Verfasst: **26.03.2004 23:05:37**

Joghurt hat geschrieben:
weedy hat geschrieben:Ist Scheme jetzt nur eine funktionale Erweiterung von Lisp
Ich dachte immer, LISP wäre auch funktional? Hilfe! Aufklärung

Mit einer funktionalen Erweiterung meine ich: Erweitert um Funktionen und nicht um Syntaxelemente.

chvt

Verfasst: **26.03.2004 23:25:12**

Joghurt hat geschrieben:
BeS hat geschrieben:klar, immer her damit :)
OK, aber für heute nur qsort
Code: Alles auswählen
qsort []     = []
qsort (x:xs) = qsort kleiner ++ [x] ++ groesser
	        where
	         kleiner  = [y | y <- xs, y<x]
                 groesser = [y | y <- xs, y>=x]
Mein Favorit, was die Syntax angeht.

Moment mal, das sieht irgendwie Prologmäßig aus:

Code: Alles auswählen

qsort []     = [] ... ist der Rekursionsterminator für die leere Liste
qsort( x:xs) ... erstes Element der Liste und Listenrest
= qsort kleiner ++ [x] ++ groesser ... eine Verkettung von 3 Listen als Parameter für qsort
where ... sql :-)
 kleiner = [ ... listenbildung
  y | ... alle y, für die gilt
  y <- xs ... y ist element aus Listenrest xs (siehe auch icon-syntax)
  , ... wenn
  y<x] ... der Rest ist klar.

Da habe ich ja heute gleich den Einstieg für Scheme/Guile und Haskell gemacht, cool. Wieder was erledigt.

Hat eigentlich jemand Erfahrung mit PCCTS/ANTLR? Ich krieg das Tutorial nicht zum laufen.

weedy.

Verfasst: **27.03.2004 05:05:54**

Und zwar in Haskell:

Code: Alles auswählen

numbers = [ 45, 7, 68, 2, 34]
names = [ "Eins", "Zwei", "Drei", "Vier", "Fuenf", "Sechs", "Sieben", "Acht"]

satz (x,y) = "Zahl " ++ x ++ " Name " ++ y ++ "\n"

a_to_s [] = ""
a_to_s (x:xs) = x++a_to_s( xs)

ia_to_sa [] = []
ia_to_sa (x:xs) = show x : ia_to_sa( xs)

avg :: [Rational] -> Rational
avg l = sum l / toRational( length l)

main= putStr( "Anzahl Integer: "++ (show (length numbers)) ++ "\n" ++ "Summe: " ++ (show (sum numbers))++ "\n" ++ "Durchschnitt: "++ (show (avg numbers))++ "\n"++ a_to_s (map satz (zip (ia_to_sa numbers) names)))

Also ich muß mal anmerken: Haskell ist verdammt streng und das Tutorial ist alles andere als übersichtlich. Während meiner Tests sind bestimmt 2 Stunden vergangen, bis ich die recht allgemeine Funktion print gefunden hatte (ich hatte sie irgendwann einfach ausprobiert), mit der man ein xbeliebiges Objekt ausgeben kann. Aber ansonsten bin ich von Haskell stark überrascht. Da ist es sogar möglich infixfunktionen zu schreiben, also: parameter1 Funktionsname parameter2. Und es ist ähnlich icon und Prolog Goalbasiert. Es kann also nach Lösungen suchen. Das ist optimal, um z.B. Parser zu programmieren. Halkell besitzt die Möglichkeit, unendliche Listen zu erzeugen und zu verwenden ähnlich Iteratoren in Ruby oder Co-Expressions in Icon. Keine Frage, Haskell muß streng sein, da geringste Änderungen bereits große Auswirkungen haben. Lustigerweise spielt die Indentiation ähnlich Python eine Rolle in Blöcken und die Klammerung ist wie in lisp, Listen sind fast wie in Prolog, es gibt sogar die ungebundene Variable '_'.

weedy.

Verfasst: **27.03.2004 13:24:25**

Ja, ich mag Haskell auch

Sich einfach mal die Liste aller Primzahlen zu definieren und sich dann die elemente 1000-2000 ausgeben zu lassen ist schon praktisch. Desweiteren ist compilierter Haskellcode überraschend schnell. Bei irgendeinem Test hat es sogar ein C-Programm überholt, IIRC. Nur Ocaml war noch ein bisschen schneller. Python war natürlich außen vor, so etwa um den Faktor 20 langsamer, aber wo es auf Geschwindigkeit ankommt, schreibt man die Funktion kurz in C und bindet sie dann als Modul in Python ein.

Verfasst: **28.03.2004 22:27:12**

Joghurt hat geschrieben:Ja, ich mag Haskell auch :)
Sich einfach mal die Liste aller Primzahlen zu definieren und sich dann die elemente 1000-2000 ausgeben zu lassen ist schon praktisch. Desweiteren ist compilierter Haskellcode überraschend schnell. Bei irgendeinem Test hat es sogar ein C-Programm überholt, IIRC. Nur Ocaml war noch ein bisschen schneller. Python war natürlich außen vor, so etwa um den Faktor 20 langsamer, aber wo es auf Geschwindigkeit ankommt, schreibt man die Funktion kurz in C und bindet sie dann als Modul in Python ein.

Gibt es Besoderheiten bei Ocaml, die erwähnenswert sind?

weedy.

Verfasst: **29.03.2004 10:34:01**

Die Python-Interessierten können damit vielleicht was anfangen, war heute auf OSNews.com verlinkt: http://www.python.g2swaroop.net/

debianforum.de

Programmieren mit FreePascal

Frage an die Scheme-Freaks:

Re: Frage an die Scheme-Freaks:

Re: Frage an die Scheme-Freaks:

Re: Frage an die Scheme-Freaks:

Fortführung des angefangenen Werks von DavidJ und Dookie: