Hallo,

ich habe hier mal ein Bsp:
Sie ein Programm das die Nulldurchgänge
in einem Array sucht. Das Unterprogramm zum Nulldurchgang suchen muss die
Anzahl der Nulldurchgaenge zurueckgeben.

Naja...

gibt es denn eine allgemein Formel für Nulldurchgänge berechnen, weil jede Funktion hat einen Nulldurgang.

Oder wäre da nur Sinus, Cosinus und Tangens gemeint?

Wobei: x=arcsin(0), x=arccos(0), x=arctan(0) --> nullstelle, aber Sinuns, Tangents und cosinus haben ja mehr wie eine. Was nun?

Danke im voraus!

mfg Googlehupf

Hi

war die Frage nicht, die Nuller aus einem Array zu finden, statt von einer math. Funktion?

Mhm, nein glaube nicht, da nämlich unter der Aufgabenstellung steht: #incluce <stdio.h>, #include <math.h>...

Also den Nulldurchgang einer Funktion(da ja math. includiert wird dann würde ich sagen von einer sinus-, cosinus- und/oder tangendsschwingung).
Naja, die Frage steht ja oben

Zitat von Googlehupf

Mhm, nein glaube nicht, da nämlich unter der Aufgabenstellung steht: #incluce <stdio.h>, #include <math.h>...

Was ist denn das für eine Begründung?
Da kann ich doch eben so gut
y = 2^x^24 - 3.5 * x^2
nehmen...

Zeig doch mal einen Screenshot etc. deiner Aufgabe.

Ich habe auch noch nicht ganz deine Aufgabe verstanden. Suchst du vielleicht die 0 im Array, wo das Vorzeichen wechselt?
Wie sheel sagte, ein Screenshot der Aufgabe, oder eine vernünftige Erklärung wäre hilfreich

Ok, stimmt .

* Kurzbeschreibung : Programm zum Arbeiten mit Strukturen.
* Schreiben Sie ein Programm in Anlehnung an strukturen4.c das die Nulldurchgänge
* in Punkt array sucht. Das Unterprogramm zum Nulldurchgang suchen muss die
* Anzahl der Nulldurchgaenge zurueckgeben.

strukturen4.c:

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

#include <stdlib.h> #include <stdio.h> #include <math.h> #include <string.h>   #define MAXSTRING 100 #define MAXPKT    100   struct punkt_struct {   float x;   float y; };     void getPunkte(punkt thePunkte[], int len) {   double t=0;     for( t = 0.0 ; t < len; t++)   {     thePunkte[(int)t].x = (float)t;     thePunkte[(int)t].y = (float)sin(t*0.1);   } }   void printPunkte(punkt thePunkte[], int len) {   int t=0;     for( t = 0 ; t < len; t++)   {     printf("(x,y)=(%f,%f)\n",thePunkte[t].x ,thePunkte[t].y);   } }   punkt getGreater(punkt p1, punkt p2) {   if (p1.y >= p2.y)   {     return p1;   }   return p2; }   punkt findMax(punkt thePunkte[], int len) {   int t=0;   punkt maxValue;     maxValue=thePunkte[0];   for( t = 0 ; t < len; t++)   {     maxValue = getGreater(thePunkte[t],maxValue);   }   return maxValue; }   void main() { //ausgabe }

Also wirklich Nullsuche im Array

Code cpp:

1 2 3 4 5 6 7 8 9 10 11

int anzahlNullstellen(punkt *thePunkte, int len) {     int ret = 0, i;       for(i = 0; i < len; i++)     {         if(thePunkte[i].y == 0.0)             ret++;     }     return ret; }

Eine andere Interpretationsmöglichkeit wäre:
Wenn man die Punkte am Papier mit einer Linie verbindet, bekommt man irgendeine math.Funktion.
Die hat Nullstellen. Die Nullstellen sind aber nicht bei den konkreten Punkten dabei, sondern müssen
(ungefähr) ermittelt werden.
Ansatz: In Bereiche nach der zweiten Ableitung einteilen.
Brauchst du Code? Wird aber vergleichsweise komplex.

Ich danke dir.

Ich habs nun so gemacht:

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

#include <stdlib.h> #include <stdio.h> #include <math.h> #include <string.h>   #define MAX_LEN 100000   struct punkt_struct {   float x;   float y; };   typedef struct punkt_struct punkte;     float find_nullpunkt(punkte the_array[], int len); void print_punkte(punkte the_array[], int len); void gen_punkte(punkte the_array[], int len);   void gen_punkte(punkte the_array[], int len) {   float t=0;     for(t=0.0; t<len; t++)   {     the_array[(int)t].x=t*0.1;     the_array[(int)t].y=sin(t*0.1);   } }   void print_punkte(punkte the_array[], int len) {   float t=0;     for(t=0.0; t<len; t++)   {     printf("(%f/%f)\n",the_array[(int)t].x,the_array[(int)t].y);   } }   float find_nullpunkt(punkte the_array[], int len) {   int t;     float anz=0;     for(t=0; t<len; t++)   {     if(the_array[t].y == 0)     {       anz++;     }   }     return(anz); }   int main() {   float anz=0;     punkte the_array[MAX_LEN];     gen_punkte(the_array,MAX_LEN);     print_punkte(the_array,MAX_LEN);     anz=find_nullpunkt(the_array,MAX_LEN);     printf("Die Anzahl der Nulldurchgaenge im punkt Array betraegt: %f",anz);     return(0); }

Aber schon wieder im Hauptprogramm bei float anz kommt ne Fehlermeldung: Quellcode nicht verfügbar , wenn ich mit F11 durchgehen will.

Das hatte ich immer seit dem ich mit Strukturen programmiere und sogenannte "casts" verwende .

Was könnte es da haben?

Also...

gen_punkte: Wenn du schon so gern castest, würd ich eher von int ausgehen.
Macht bei Schleifen, Indizes etc. weniger potenzielle Probleme:

Code cpp:

1 2 3 4 5 6 7 8 9

void gen_punkte(punkte the_array[], int len) {     int t;     for(t = 0; t < len; t++)     {         the_array[t].x = (float)t * 0.1;         the_array[t].y = sin((float)t * 0.1);     } }

Ebenso bei print_punkte.

Ebenso bei find_nullpunkt.
2.4 Nullpunkte wirds nicht geben, die Anzahl wird immer eine ganze Zahl sein. int.

main:
Wenn du schon Kommavariablen verwendest, sollten auch Kommazahlen rein.

Code cpp:

1	float anz = 0.0;

Außerdem musst du anz gar nicht auf 0.0 setzen, geht auch so.

Und zum Quellcode-nicht-verfügbar:
a) Wie kompilierst du das Programm? Release/Debug?
b) Wie startest du das Programm? Normal/Debugger?

Also ich hab einfach gemacht: Einfach auf "Debugging" und dann auf Einzelschritt und immer wieder dann F11 bis beom float anz halt die Fehlermeldung kommt...

ich hab das jetzt geändert in meinem programm was du mir da gesagt hast und jetzt gehts, also es hat irgendwas mit dem cast oder so.

Bitte achte auf die Netiquette.

Und ist es denn so schwer, alle Fragen zu beantworten?

Zitat von sheel

a) Wie kompilierst du das Programm? Release/Debug?
b) Wie startest du das Programm? Normal/Debugger?

Ok, sorry.

a) Debug
b) Debugger

Das ist interessant. Sollte nicht passieren, schon gar nicht in der ersten main-Zeile.

Du sagst, mit anderem Code passiert das nicht. Wie schaut er denn jetzt aus?

Code sieht so aus:

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

#include <stdlib.h> #include <stdio.h> #include <math.h> #include <string.h>   #define MAX_LEN 100   struct punkt_struct {   float x;   float y; };   typedef struct punkt_struct punkte;     float find_nullpunkt(punkte the_array[], int len); void print_punkte(punkte the_array[], int len); void gen_punkte(punkte the_array[], int len);   void gen_punkte(punkte the_array[], int len) {   int t=0;     for(t=0; t<len; t++)   {     the_array[t].x=(float)t*0.1;     the_array[t].y=sin((float)t*0.1);   } }   void print_punkte(punkte the_array[], int len) {   int t=0;     for(t=0; t<len; t++)   {     printf("(%f/%f)\n",the_array[t].x,the_array[t].y);   } }   float find_nullpunkt(punkte the_array[], int len) {   int t;     float anz=0;     for(t=0; t<len; t++)   {     if(the_array[t].y == 0)     {       anz++;     }   }     return(anz); }   int main() {   float anz=0.0;     punkte the_array[MAX_LEN];     gen_punkte(the_array,MAX_LEN);     print_punkte(the_array,MAX_LEN);     anz=find_nullpunkt(the_array,MAX_LEN);     printf("Die Anzahl der Nulldurchgaenge im punkt Array betraegt: %f",anz);     return(0); }

Das Einzige, was im main anders ist, ist das "0.0" statt 0
Solche Fehler sollten dadurch ja eigentlich nicht auftreten, aber was solls...
jetzt funktioniert es ja.

Gruß