Also unsere Aufgabe ist es, Woche für Woche mit anderen Programmiersprachen die Wurzelberechnung "k-te Wurzel von r" zu berechnen. Grundlage ist der Quellcode für die Quadratwurzelberechnung.

Diese Woche ist LISP dran :beagolisc , die Sprache der unendlichen Klammern. Vorher Fortran und C+, was kein Problem war.

programm_sqrt.lsp

; Naeherungsloesung der Quadratwurzel

; (Nullstellenbestimmung mit dem Newton-Verfahren)

; Der Radikand wird vom Benutzer erfragt.

;

; Vorgegebenes Programm in Sprache LISP zur 3. Uebung

(DEFUN program_sqrt () ;Funktionsdefinition

(PROGN ;Prozedurrumpf:Sequenz

(DEFUN quadratwurzel (radikand) ;Funktionsdefinition

(COND ;Prozedurrumpf:Fallunterscheidung

((< radikand 0.00001) "ohne Ergebnis abgebrochen") ;Ausnahmefall

( T (DO ( ;Normallfall:Wiederholung:Zustandsblock

(naeh1 1.0 naeh2) ;Komponente naeh1

(naeh2 (/ (+ 1.0 radikand) 2) ;Komponente naeh2

(/ (+ (EXPT naeh2 2) radikand) (* 2 naeh2)) )) ;Folgewert

((< (* 10000.0 (ABS (- naeh2 naeh1)) ) naeh2) ;Ausstiegsblock:Abbruchbedingung

naeh2) )))) ;Ergebnis+Leerer Rumpf

(PRINT "Bitte Radikand als Liste eingeben: ®= ") ;Eingabeaufforderung

(SETQ kr (CONS 2 (READ))) ;Listenaufbau(Grad Radikand)

(SETQ k (CAR kr)) ;Grad-Extraktion

(SETQ r (CADR kr)) ;Radikand-Extraktion

(SETQ ergebnis (CONS (FLOAT (quadratwurzel r)) NIL)) ;Listenaufbau(Ergebnis)

(PRINT "Wurzelgrad k Radikand r k-te Wurzel aus r") ;Ausgabeerklärung

(CONS 2 (CONS r ergebnis)) )) ;Listenaufbau und -ausgabe

Dabei ist zu beachten, dass das Programm ursprünglich schon für die k-te Wurzel ausgelegt wurde, sieht man an einigen Ausdrücken.

Hier mal die konkrete Aufgabenstellung:

Mit dem gegebenen LISP-Programm ist in gleicher Weise zu verfahren wie mit dem C-Programm der zweiten Übung. Das heißt, der Programmtext ist so abzuändern, (1) dass anstelle der Quadratwurzel die k-te Wurzel berechnet wird, und (2) dass die Folge der numerierten Näherungswerte ausgegeben wird. Im Unterschied zur Sprache C gibt es in LISP eine Funktion zum Potenzieren von Zahlen mit ganzzahligen Exponenten: Die Auswertung des Ausdrucks (EXPT b e) liefert das Ergebnis be .

Und hier das gleiche Konzept schon fertig für C+.

/********************************************************************/

/* */

/* Naeherungsloesung der Quadratwurzel */

/* (Nullstellenbestimmung mit dem Newton-Verfahren) */

/* Der Radikand wird vom Benutzer erfragt. */

/* */

/* Vorgegebenes Programm in Sprache C fuer die 2. Uebung */

/* */

/* X & Y */

/********************************************************************/

#include <stdio.h>

#include <math.h>

#include <stdlib.h>

int main()

{

/* Beginn des Vereinbarungsteils */

int grad, i,j, imax=100;

double radikand, naeh1, naeh2, maxdist=1.0e+4, rmin=1.0e-4;

/* Ende des Vereinbarungsteils */

/* Beginn des Eingabeteils */

printf("Radikand = ");

scanf("%lf", &radikand);

printf("Wurzelgrad = ");

scanf("%d", &grad);

/* Ende des Eingabeteils */

if (radikand < rmin)

/* Beginn der Ausnahmebehandlung */

printf("ohne Ergebnis abgebrochen");

/* Ende der Ausnahmebehandlung */

else

/* Beginn des Berechnungsteils */

{ naeh1 = 1.0;

naeh2 = ((grad-1)*naeh1 + radikand)/(grad*naeh1);

i = 1;

while((fabs(naeh2-naeh1)*maxdist > naeh2) && (i<imax))

{ printf("%d : %f\n", i, naeh1);

naeh1 = naeh2;

j=1;

while(j < (grad-1))

{ naeh2 = naeh2 * naeh1;

j = j + 1;

}

naeh2 = ((grad-1)*naeh1*naeh2 + radikand)/(grad*naeh2);

i = i+1;

};

printf("%d-te Wurzel aus %f = ", grad, radikand);

printf("%f\n", naeh2);

}/* Ende des Berechnungsteils */

return 0;

} /* end of main */

Habt ihr eventuell nen Ansatz?

Danke, Moeki.

google hilft :-)

(DEFUN program_k-root() ;Funktionsdefinition

(PROGN ;Prozedurrumpf:Sequenz

(DEFUN wurzel (radikand grad) ;Funktionsdefinition

(COND ;Prozedurrumpf:Fallunterscheidung

((< radikand 0.00001) "ohne Ergebnis abgebrochen") ;Ausnahmefall

((< grad 1) "Grad kleiner als 1") ;Ausnahmefall für grad < 1

( T

(DO

( ;Normallfall:Wiederholung:Zustandsblock

(naeh1 1.0 (PRINT naeh2)) ;Komponente naeh1

(naeh2 (/ (+ 1.0 radikand) 2) ;Komponente naeh2

(/ (+ (* (EXPT naeh2 grad) (- grad 1)) radikand) ;Folgewert

(* grad (EXPT naeh2 (- grad 1)))

)

)

)

((< (* 10000.0 (ABS (- naeh2 naeh1)) ) naeh2) ;Ausstiegsblock:Abbruchbedingung

naeh2) ;Ergebnis+Leerer Rumpf

))))

(PRINT "Bitte Grad und Radikand als Liste eingeben: (k r)= ") ;Eingabeaufforderung

(SETQ kr (READ)) ;Listenaufbau(Grad Radikand)

(SETQ k (CAR kr)) ;Grad-Extraktion

(SETQ r (CADR kr)) ;Radikand-Extraktion

(PRINT "Näherungslösung:")

(SETQ ergebnis (CONS (FLOAT (wurzel r k)) NIL)) ;Listenaufbau(Ergebnis)

(PRINT "Wurzelgrad k Radikand r k-te Wurzel aus r") ;Ausgabeerklärung

(CONS k (CONS r ergebnis)) )) ;Listenaufbau und -ausgabe

@moeki sich selbst antworten ist auch ne Möglichkeit die Aufgabe zu lösen?! :confused: