In C Wurzel ziehen

[gigu]

Hallo
Könntet ihr mir sagen wie man in C eine Wurzel zieht. Oder wie man das überhaupt berechnet?
Danke :>
ach ja.. und wenn ihr sonst noch ein Fehler findet und in mir sagt bin ich natürlich dankbar :D


#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <cmath>
#include<iostream.h>


char Wert;
float Zahl1;
float Zahl2;
float Ergebniss;


int main()

{
//Eingabe
printf("Pythagoras\n\nKatheten und Hypotenusenberechnung\n\nGeben sie ein was sie berechnen wollen:\n k=Kathete\n h=Hypotenuse\n");
fflush (stdin);
scanf("%c", &Wert);

if(Wert == 'h')
printf("Sie berechnen Hypotenusen");
else if(Wert == 'k')
printf("Sie berechnen Katheten");
else
printf("Die Eingabe war ungueltig");

//Berechnung von Hypotenuse
if(Wert == 'h')
{
printf("\n\n\nGeben sie die beiden Zahlen die fuer die Hypotenusenberechung verwenden wollen\n");
printf("\nGeben sie die erste Zahl ein:\n", Zahl1);
fflush (stdin);
scanf("%f", &Zahl1);
if(Zahl1 <= 0)
printf("Die Eingabe war ungueltig");
else
printf("\nGeben sie nun die zweite Zahl ein:\n", Zahl2);
fflush (stdin);
scanf("%f", &Zahl2);
if(Zahl1 <= 0)
printf("Die Eingabe war ungueltig");
else
{
Ergebniss = (Zahl1*Zahl1)+(Zahl2*Zahl2);
double wurzel;
Ergebniss = sqrt(Ergebniss);
printf("\nDas ergebniss lautet: %f%\n", Ergebniss);
}
}

//Berechnung von Kathete
if(Wert == 'k')
{
printf("\n\n\nGeben sie die beiden Zahlen die fuer die Kathetenberechung verwenden wollen\n");
printf("\nGeben sie die Hypotenuse ein:\n", Zahl1);
fflush (stdin);
scanf("%f", &Zahl1);
if(Zahl1 <= 0)
printf("Die Eingabe war ungueltig");
else
printf("\nGeben sie nun die gegebene Kathete ein:\n", Zahl2);
fflush (stdin);
scanf("%f", &Zahl2);
if(Zahl1 <= 0)
printf("Die Eingabe war ungueltig");
else if(Zahl2 >= Zahl1)
printf("Die Eingabe war ungueltig");
else
{
Ergebniss = (Zahl1*Zahl1)-(Zahl2*Zahl2);
double wurzel;
Ergebniss = sqrt(Ergebniss);
printf("\nDas ergebniss lautet: %f%\n", Ergebniss);
}

}



getch();

}

[krusty]

also in c++ sieht das ganze so aus


#include <cmath>
double wurzel;
wurzel = sqrt(zahl);
glaub ich zumindest :?

[gigu]

Ja das funktiniert.
Vielen Dank :)

[krusty]

no problemo, kannst ja noch fehlermeldungen einbauen, wenn jemand eine negative zahl eingibt use...

[gigu]

is das so korrekt?

[xparet0209]

wenn du die funktion nicht kennen würdest dann kannst du auch
mathemtisch ran gehen...^^

man nimmt eine linke intervall grenze und eine rechte intervall grenze
meinetwegen double l,r //wobei l = 0 und r = Radikant
dann (l+r)/2 //also die mittlere zahl
wenn ((l+r)/2) * ((l+r)/2) größer als der gewünschte radikant ist
dann (l+r)/2 = r
wenn ((l+r)/2) * ((l+r)/2) kleiner als der radikant ist dann
(l+r)/2 = l
dass kannst du dann in einer schleife so lange weiter machen bis:
| ((l+r)/2) * ((l+r)/2) - Radikant| < 0,00001 // umso mehr nullen vor der 1 stehen, umso genauer wird die wurzel...
| soll betrag heißen...

danach gibst du (l+r)/2 aus....

ich glaube so müsste es auch gehne
wenn jemand nen fehler entdeckt bitte ich um verzeihung - ist schon spääääät...^^

[Deathskull]

xD
Leute es geht auch viel einfacher :D
Es gibt die schöne "pow Funktion", die für potenzieren da ist. Und was wissen wir aus dem Matheunterricht?
Genau folgendes: (xWurzel)2 <=> 2 ^ (1/x). Von daher reicht diese Funktion aus, um Wurzeln zu berechnen :)

http://www.cppreference.com/wiki/c/math/pow

MfG Blood.

[blackberry]

Leute es geht auch viel einfacher :D

"Wieso das Rad neu erfinden"?
Weil das selbstgebaute Rad vielleicht besser läuft als das alte.

Ich kann natürlich auch sagen, dass ich mit root(3, 0.5) das Quadrat von 3 berechnen kann.

Es gillt:
pow(x, y/z) = root(x, z/y);

root über pow zu definieren macht also nur Sinn, wenn du den genauen Aufbau von pow kennst!

@xparet0209
Ich habe deinen Weg mal aus Neugierde ausprobiert und es hat mir bei f(x) immer nur x/2 zurückgegeben... vielleicht habe ich auch Mist gebaut - ist schon "spääääät" ^^

Außerdem habe ich hier mal das Heron-Verfahren implementiert:

double _sqrt_(double r)
{
double x_n = HERON_X_0;
int loops = HERON_MAX_LOOPS;

while(loops--)
{
x_n = (x_n + r / x_n) / 2;
}
return x_n;
}

Bei folgenden Makros habe ich recht genaue Werte erzielen können:

#define HERON_X_0 1
#define HERON_MAX_LOOPS 100

http://de.wikipedia.org/wiki/Heron-Verfahren

Je größer HERON_MAX_LOOPS gewählt ist, desto genauer ist das Ergebnis (natürlich ist die Genauigkeit duch die Maximalwerte eines Doubles begrenzt und zu hohe Werte verlängern die Rechenleistung)!

[xparet0209]

ich hab das jetzt mal so geschrieben...
ich weiß ich nicht ganz so guter programmier stil^^
außerdem in c# und nicht c

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Quadratwurzel
{
class Program
{
static void Main(string[] args)
{
decimal l, r ,x , m , g_out;
double g;
string y;
Console.Write("Bitte geben Sie einen Radikanten ein: ");
x = Convert.ToDecimal(Console.ReadLine());
Console.Write("\nBitte geben Sie die Anzahl der Nachkommastellen an: ");
g = Convert.ToDouble(Console.ReadLine());
if (g == 0)
{
g_out = 0;
}
else
{
g_out = Convert.ToDecimal(1 / System.Math.Pow(10, g));
}
Console.Write("\n");
r = x;
l = 0;
do{
Console.WriteLine("[{0};{1}]",l,r);
m = (l + r) / 2;
if (m * m > x)
{
r = m;
}
else
{
if (m * m == x)
{
break;
}
l = m;
}
}while( m*m-x > g_out || x- m*m > g_out );
y = Convert.ToString(m);
Console.Write("Die Quadratwurzel aus {0} mit der Genauigkeit\n{1} ist ", x, g_out);
if (g == 0)
{
Console.Write(m);
}
else
{
for (int i = 0; i - 2 != g; i++)
{
Console.Write(y[i]);
}
}

Console.ReadLine();
}
}
}