GNU Libmatheval in C++ Programm anwenden

[gerbej s. (sgerbej)]

Hallo zusammen!

ich habe ein kleinclass geschrieben.zwei Methoden von diesem Class 
sollten Werte an X und y Pair in globale Struct zuweisen :

  class.h

struct XYpair{
  double x;
  double y;
};

class INPUT{

 private:
  int psize;
  double xmin,xmax;
  XYpair* ptr;
  int intep;
  int dacrate;
  int ns;
public:
  void setvalue();
  XYpair* Dezim(int& psize, XYpair* ptr);
  XYpair* Interp(int& ns,  XYpair* ptr);

class.pp

XYpair* INPUT::Dezim(int& psize, struct XYpair* ptr){
  
  double xr=xmax-xmin/psize;
  double X=0.0;
  int i;
  XYpair *dptr= new XYpair [psize];
  for(i=0;i<psize;i++){
    dptr[i].x=X;
    dptr[i].y=sin(X);    <-----//mit f_eingeben() auswerten
    X+=xr;
  }
  return dptr;
}

XYpair* INPUT::Interp(int& ns, XYpair* ptr){
  
  double xr=(double)(intep*4/dacrate);
  XYpair *iptr;
  iptr=new XYpair[ns];
  int i;
  for(i=0;i<ns;i++)
{
  iptr[i].x=xr;
  iptr[i].y=sin(iptr[i].x*i);     <-----//mit f_eingeben() auswerten
  xr++;
 }
  delete[]iptr;

 }

nun möchte ich die Werte durch eine Funktion, die ich über Konsole 
eingebe,erstmal auswerten und dafür benutze GNU Libmathavel(C- 
Bibleotheck), die der eingegebenen mathematischen Funktionen für 
spezifizierte variable Werte auswerten kann; ich habe sie in 
Funktionparser schön verwendet;

hier ist die funktionsparser:

void f_eingeben(){

 char buffer[BUFFER_SIZE];
  int length;
  void *f;
  char **names;
  int count j,i;
  double X;
  double *x_f;
  cout <<"f(x_f) = ";
  cin.getline(buffer, BUFFER_SIZE);
  length = strlen (buffer);
  if (length > 0 && buffer[length - 1] == '\n')
    buffer[length - 1] = '\0';
  
  f = evaluator_create (buffer); /* Create evaluator for function.  */
  assert (f);
/* Print variable names appearing in function. */
  evaluator_get_variables (f,&names, &count);
  cout <<" " ;
  for (j = 0; j < count; j++)
    // printf ("%s ", names[j]);
    cout <<'\n';

 double* y= new double [N_SAMPLES];
double X=0.001;
for(j=0;j<=N_SAMPLES-1;j++){
  // Funktion evalutator_evaluate_x() zur   Auswertung von f(x)
   y[j]=evaluator_evaluate_x (f,X);
       X=X*j;}

 /* Destroy evaluators.  */
evaluator_destroy (f);

Nun meine Frage wie Kann ich die f_eingeben () in meiner classmathoden 
verwenden (classmethod:dezim() gibt Funktionsplottwerte zurück und 
inter() liefert Funcktionstransmittwerte);
ich überlege mir die f_eingeben() als golable funktion zu definieren;
aber ich weis nicht wie die in Dezim() bzw interp() aufrufen kann;
also wenn man eine Idee für mich hat wie ich meine Aufgaben lösen kann 
dann bin sehr Dankbar.

Gruß

Sgerbej

[Karl H. (kbuchegg)]

gerbej seb schrieb:

>   XYpair* Dezim(int& psize, XYpair* ptr);
>   XYpair* Interp(int& ns,  XYpair* ptr);

einen int per Referenz zu übegreben ist nicht sehr sinnvoll.


> Nun meine Frage wie Kann ich die f_eingeben () in meiner classmathoden
> verwenden

natürlich.


> ich überlege mir die f_eingeben() als golable funktion zu definieren;
> aber ich weis nicht wie die in Dezim() bzw interp() aufrufen kann;

einfach aufrufen.
Solange ein Funktionsprototyp dafür sichtbar ist, gibt es kein Problem. 
Nur weil C++ Klassen hat, heißt das noch lange nicht, dass jede Funktion 
in einer Klasse stecken muss. Es gibt auch freistehende Funktionen, die 
keiner Klasse zugeordnet sind, so wie es sie auch in C gab. Du rufst ja 
sin() auch einfach auf, ohne dir Gedanken darum zu machen ob die in 
einer Klasse steckt oder nicht.

Aber ich denke ernsthaft, dass es besser wäre, eine Evaluierungsfunktion 
(private oder protected Funktion) in deiner INPUT Klasse zu schreiben 
und so eine stärkere Bindung zu erreichen. INPUT hat eine Methode, mit 
der sie einen String übernimmt, der als auszuwertender Ausdruck 
gespeichert wird. Und in der Eval Funktion wird der dann ausgewertet. 
Auf die Art soll, nein muss, sich INPUT nicht damit herumschlagen, wo 
denn dieser String eigentlich herkommt. Das geht diese Klasse nichts an 
und ist nicht ihr Bier. Sie bekommt diesen String und soll Wertepaare 
dafür auswerten. Also: Ein/Ausgabe von den Arbeitsfunktionen trennen.

[Karl H. (kbuchegg)]

  double xr=xmax-xmin/psize;

ich denke, du wolltest eigentlich

  double xr = ( xmax-xmin ) / psize;

und X dann mit dem Wert xmin starten lassen.

  for(i=0;i<psize;i++){
    dptr[i].x=X;
    dptr[i].y=sin(X);    <-----//mit f_eingeben() auswerten
    X+=xr;
  }

Das ist nicht so schlau. Denn in einem Computer gibt es ein Problem: 
Begrenzte Rechengenaugikeit.

In dieser Aufsummierung landest du am Ende irgendwo, aber sicher nicht 
am Endwert. Zumindest nicht exakt. Wenn du in einer Schleife beginnend 
bei 0.0 immer 0.001 dazuzählst, und das 1-tausend mal. Dann hast du am 
Ende nicht 1.0 erreicht sondern 0.99999  und das ist nun mal nicht 1.0 
(ein Vergleich auf 1.0 schlägt fehl)

Besser ist es, keinen derartigen aufsummierenden Fehler zuzulassen

  for(i = 0; i < psize; i++ ) {
    dptr[i].x = xmin + i * xr;
    dptr[i].y = sin( dptr[i].x );
  }

[Karl H. (kbuchegg)]

Ein weiteres "organisatorisches" Problem:
Es ist nie besonders schlau, new und den zugehörigen delete auseinander 
zu reissen.

wie zb hier

XYpair* INPUT::Dezim(int& psize, struct XYpair* ptr){
  
  double xr=xmax-xmin/psize;
  double X=0.0;
  int i;
  XYpair *dptr= new XYpair [psize];
  for(i=0;i<psize;i++){
    dptr[i].x=X;
    dptr[i].y=sin(X);    <-----//mit f_eingeben() auswerten
    X+=xr;
  }
  return dptr;
}

wo ist der zugehörige delete[] ?

Die Antwort ist: du kannst ihn hier nicht machen, sondern musst darauf 
vertrauen, dass ihn der Aufrufer erledigen wird.
Das ist aber nicht besonders gut. Besser ist es, wenn du das so 
gestalten kannst, dass der Aufrufer eben nicht vergessen kann. Und an 
dieser Stelle kommen Container ins Spiel.
C++ gibt dir bereits Container an die Hand. zb einen std::vector. 
Benutze sie, sie vereinfachen dein Leben. WEnn die Funktion einen 
std::vector<XYpair> zurückliefert, dann KANN der Aufrufer nicht 
vergessen, den Speicher freizugeben. Der std::vector kümmert sich darum! 
Sobald er ausser Scope geht, gibt er den allokierten Speicher frei.

C++ leidet immer noch unter dem Ruf, dass dynamische Speicherverwaltung 
so wahnsinnig kompliziert wäre und man so wahnisnnig aufpassen muss. 
Darum wurden Garbage Collectoren entwickelt, die hinter einem aufräumen. 
Dabei ist es in C++ mit seinen Möglichkeiten relativ einfach, ein System 
hochzuziehen, in dem die Klassen selber hinter sich aufräumen. Man muss 
nur ein wenig seine C Gewohnheiten über Bord werfen und dann wird 
dynamisches Speichermanagement relativ einfach und auch zuverlässig. Und 
zwar ohne dass die Speicherbelastung erst mal auf ein paar Gigabyte 
anwachsen muss, ehe sich dann der GC erbarmt und aufräumt.

Daher:
std::string, std::vector, std::list und all die anderen Template Klassen 
sind deine Freunde. Benutze sie! Auch wenn man immer wieder mal andere 
Meinungen hört: Es gibt keinen Grund, um Container einen Bogen zu machen 
und sich selber um die Allokierungen zu kümmern.

#include <vector>

std::vector<XYPair> INPUT::Dezim( int psize )
{
  double xr = ( xmax-xmin ) / psize;
  std::vector<XYPair> result;
 
  for( int i = 0; i < psize; i++ )
  {
    double X = xmin + i * xr;
    result.push_back( XYPair( X, sin( X ) );
  }
  return result;
}

Verwendung:

void foo()
{
  std::vector<XYPair> values;
  INPUT wasAuchImmer;

  ....

  values = wasAuchImmer( 25 );

  ...
}  // mit Beendigung der Funktion räumt der std::vector selbsttätig den
   // Speicher auf. Keine Speicher Löcher

[gerbej s. (sgerbej)]

Hallo zusammen!

Danke sehr  Karl für deine ausführliche Erklärung; ich habe mein Code 
nach deiner Vorschläge geändert und es gut std:: vector gut geklappt.
Nun versuche ich die C-Library zu verwenden; ich habe eine nue Funktion 
f_eingeben()
für die mathematische funktion,die ich über konsleeingebe, zugefügt;
aber weis nicht ob es so laufen würde,denn ich habe da Problem mit der 
linke  weis jamend wie ich die  in Makefile den linke übergeben kann?

hier ist class.h:

  
#define BUFFER_SIZE 200

using namespace std;


struct XYpair{
  double x;
  double y;
  XYpair(double x, double y):x(x),y(y){}
};

class INPUT{

 private:
  int psize,ns;
  double xmin,xmax;
  //XYpair* ptr;
  std::vector<XYpair> dptr;
  int intep;
  int dacrate;
  
  //int BUFFER_SIZE=200;
  char buffer[BUFFER_SIZE];
  int length;
  void *f;
  char **names;
  int count;
  double X;
  double *x_f;
 
 public:
  void setvalue();
  //XYpair* Dezim(int& psize, XYpair* ptr);
  //XYpair* Interp(int& ns,  XYpair* ptr);
  
  std::vector<XYpair> Dezim(int psize);
  std::vector<XYpair> Interp(int ns);
  void setvalue_int();

 protected:
  void f_eingeben();
 
};

abschnitt von class.cpp

void INPUT::f_eingeben(){
  
  cin.getline(buffer, BUFFER_SIZE);
  length = strlen (buffer);
  if (length > 0 && buffer[length - 1] == '\n')
    buffer[length - 1] = '\0';
  
  f = evaluator_create (buffer); /* Create evaluator for function.  */
  assert (f);
/* Print variable names appearing in function. */
  evaluator_get_variables (f,&names, &count);
  cout <<" " ;
  for (j = 0; j < count; j++)
    // printf ("%s ", names[j]);
    cout <<'\n';
     
/* Destroy evaluators.  */
evaluator_destroy (f);
}


std::vector<XYpair> INPUT::Dezim(int psize){
  
  double xr=(double)(xmax-xmin)/psize;
  double X=xmin;
  int i;
  std::vector<XYpair> dptr;
  X=xmin;
  for(i=0; i<psize; i++){
    dptr.push_back(XYpair(X,evaluator_evaluate_x (f,X)));
    X+=xr;
  }
  return dptr;
}


std::vector<XYpair> INPUT::Interp(int ns){
  
  double xr=(double)intep*4/dacrate;
  std::vector<XYpair> iptr;
  for(int i=0 ; i<ns; i++){
    iptr.push_back( XYpair(i*xr,evaluator_evaluate_x(f,xr*i)));
}
  return iptr;
 }

Abschnitt main.cpp

 
extern "C" {
#include <matheval.h>
}
    
using namespace std;

int main(){
  int ns=20;
  int psize=15;
  std::vector<XYpair> V;
  INPUT Func;

  Func.f_eingeben();
  int wahl;

  cout << ":2 für Dezimat() und 1 für Interp():";
  cin >> wahl;
  if(wahl==1){
    Func.setvalue_int();
                                   // M=Func.Interp(ns,v);
    V =Func.Interp(ns);
    for(int i=0;i<ns-1; i++){
      cout <<"V.x"<<V[i].x<<"V.y"<<V[i].y<<'\n';
  }

Makefile

project:project.o main.o
  g++ -o project project.o main.o

project.o:project.cpp project.h
  g++ -c project.cpp

main.o:main.cpp project.h
  g++ -c main.cpp

clean:
  rm project project.o main.o

#that's all

paare Fehlermeldung:

error: ‘evaluator_create’ was not declared in this scope
project.cpp:30:12: error: ‘assert’ was not declared in this scope
project.cpp:32:44: error: ‘evaluator_get_variables’ was not declared in this scope
project.cpp:34:8: error: ‘j’ was not declared in this scope

Danke schönmal im Voraus für jede Hilfe

Gruß

Seb