1 / 50

Chapter 15 Functions and graphing

Learn how to graph functions and use programming techniques to create real programs. Includes examples and tips for problem-solving and class usage.

schickj
Download Presentation

Chapter 15 Functions and graphing

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Chapter 15 Functions and graphing Bjarne Stroustrup www.stroustrup.com/Programming

  2. Abstract • Here we present ways of graphing functions and data and some of the programming techniques needed to do so, notably scaling. Stroustrup/Programming/2015

  3. Note • This course is about programming • The examples – such as graphics – are simply examples of • Useful programming techniques • Useful tools for constructing real programs Look for the way the examples are constructed • How are “big problems” broken down into little ones and solved separately? • How are classes defined and used? • Do they have sensible data members? • Do they have useful member functions? • Use of variables • Are there too few? • Too many? • How would you have named them better? Stroustrup/Programming/2015

  4. Graphing functions • Start with something really simple • Always remember “Hello, World!” • We graph functions of one argument yielding one value • Plot (x, f(x)) for values of x in some range [r1,r2) • Let’s graph three simple functions: double one(double x) { return 1; } // y==1 double slope(double x) { return x/2; } // y==x/2 double square(double x) { return x*x; } // y==x*x Stroustrup/Programming/2015

  5. Functions double one(double x) { return 1; } // y==1 double slope(double x) { return x/2; } // y==x/2 double square(double x) { return x*x; } // y==x*x Stroustrup/Programming/2015

  6. How do we write code to do this? Function to be graphed Simple_windowwin0 {Point{100,100},xmax,ymax,"Function graphing"}; Function s {one, -10,11, orig, n_points, x_scale,y_scale}; Function s2 {slope, -10,11, orig, n_points, x_scale,y_scale}; Function s3 {(square, -10,11, orig, n_points, x_scale,y_scale}; win0.attach(s); win0.attach(s2); win0.attach(s3); win0.wait_for_button( ); First point “stuff” to make the graph fit into the window Range in which to graph [x0:xN) Stroustrup/Programming/2015

  7. We need some Constants const int xmax = win0.x_max();// window size (600 by 400) const int ymax = win0.y_max(); const intx_orig = xmax/2; const inty_orig = ymax/2; const Point orig {x_orig, y_orig}; // position of Cartesian (0,0) in window const intr_min = -10; // range [-10:11) == [-10:10] of x const intr_max = 11; const intn_points = 400; // number of points used in range const intx_scale = 20; // scaling factors const inty_scale = 20; // Choosing a center (0,0), scales, and number of points can be fiddly // The range usually comes from the definition of what you are doing Stroustrup/Programming/2015

  8. Functions – but what does it mean? • What’s wrong with this? • No axes (no scale) • No labels Stroustrup/Programming/2015

  9. Label the functions Text ts {Point{100,y_orig-30},"one"}; Text ts2 {Point{100,y_orig+y_orig/2-10},"x/2"}; Text ts3 {Point{x_orig-90,20),"x*x"}; Stroustrup/Programming/2015

  10. Add x-axis and y-axis • We can use axes to show (0,0) and the scale Axis x {Axis::x, Point{20,y_orig}, xlength/x_scale, "one notch == 1"}; Axis y {Axis::y, Point{x_orig, ylength+20}, ylength/y_scale, "one notch == 1"}; Stroustrup/Programming/2015

  11. Use color (in moderation) x.set_color(Color::red); y.set_color(Color::red); Stroustrup/Programming/2015

  12. The implementation of Function • We need a type for the argument specifying the function to graph • using can be used to declare a new name for a type • using Count = int; // now Count means int • Define the type of our desired argument, Fct • using Fct = std::function<(double(double)>; // the type of afunction// taking a double argument// and returning a double • std::function is a standard-library type • Examples of functions of type Fct: double one(double x) { return 1; } // y==1 double slope(double x) { return x/2; } // y==x/2 double square(double x) { return x*x; } // y==x*x Stroustrup/Programming/2015

  13. Now Define “Function” struct Function : Shape // Function is derived from Shape { // all it needs is a constructor: Function( Fct f, // f is aFct (takes a double, returns a double) double r1, // the range of x values (arguments to f) [r1:r2) double r2, Point orig, // the screen location of Cartesian (0,0) Count count, // number of points used to draw the function // (number of line segments used is count-1) double xscale , //the location (x,f(x)) is(xscale*x, -yscale*f(x)), double yscale //relative to orig(why minus?) ); }; Stroustrup/Programming/2015

  14. Implementation of Function Function::Function( Fct f, double r1, double r2, // range Point xy, Count count, double xscale, double yscale ) { if (r2-r1<=0) error("bad graphing range"); if (count<=0) error("non-positive graphing count"); double dist = (r2-r1)/count; double r = r1; for (inti = 0; i<count; ++i) { add(Point{xy.x+int(r*xscale), xy.y-int(f(r)*yscale)}); r += dist; } } Stroustrup/Programming/2015

  15. Default arguments • Seven arguments are too many! • Many too many • We’re just asking for confusion and errors • Provide defaults for some (trailing) arguments • Default arguments are often useful for constructors struct Function : Shape { Function(Fct f, double r1, double r2,Point xy, Count count = 100,double xscale = 25, double yscale=25 ); }; Function f1 {sqrt, 0, 11, orig, 100, 25, 25}; // ok (obviously) Function f2 {sqrt, 0, 11, orig, 100, 25}; // ok: exactly the same as f1 Function f3 {sqrt, 0, 11, orig, 100}; // ok: exactly the same as f1 Function f4 {sqrt, 0, 11, orig}; // ok: exactly the same as f1 Stroustrup/Programming/2015

  16. Function • Is Function a “pretty class”? • No • Why not? • What could you do with all of those position and scaling arguments? • See 15.6.3 for one minor idea • If you can’t do something genuinely clever, do something simple, so that the user can do anything needed • Such as adding parameters so that the caller can control precision Stroustrup/Programming/2015

  17. Some more functions #include<cmath> // standard mathematical functions // You can combine functions (e.g., by addition): double sloping_cos(double x) { return cos(x)+slope(x); } Function s4 {cos,-10,11,orig,400,20,20}; s4.set_color(Color::blue); Function s5 {sloping_cos,-10,11,orig,400,20,20}; Stroustrup/Programming/2015

  18. Cos and sloping-cos Stroustrup/Programming/2015

  19. Standard mathematical functions (<cmath>) • double abs(double); // absolute value • double ceil(double d); // smallest integer >= d • double floor(double d); // largest integer <= d • double sqrt(double d); // d must be non-negative • double cos(double); • double sin(double); • double tan(double); • double acos(double); // result is non-negative; “a” for “arc” • double asin(double); // result nearest to 0 returned • double atan(double); • double sinh(double); // “h” for “hyperbolic” • double cosh(double); • double tanh(double); Stroustrup/Programming/2015

  20. Standard mathematical functions (<cmath>) • double exp(double); // base e • double log(double d); // natural logarithm (basee) ; d must be positive • double log10(double); // base 10 logarithm • double pow(double x, double y); // x to the power of y • double pow(double x, int y); // x to the power of y • double atan2(double y, double x); // atan(y/x) • double fmod(double d, double m); // floating-point remainder // same sign as d%m • double ldexp(double d, int i); // d*pow(2,i) Stroustrup/Programming/2015

  21. Why graphing? • Because you can see things in a graph that are not obvious from a set of numbers • How would you understand a sine curve if you couldn’t (ever) see one? • Visualization • Is key to understanding in many fields • Is used in most research and business areas • Science, medicine, business, telecommunications, control of large systems • Can communicate large amounts of data simply Stroustrup/Programming/2015

  22. An example: ex ex == 1 + x + x2/2! + x3/3! + x4/4! + x5/5! + x6/6! + x7/7! + … Where ! means factorial (e.g. 4!==4*3*2*1) (This is the Taylor series expansion about x==0) Stroustrup/Programming/2015

  23. Simple algorithm to approximate ex double fac(int n) { /* … */ } // factorial double term(double x, int n) // xn/n! { return pow(x,n)/fac(n); } double expe(double x, int n) // sum of n terms of Taylor series for ex { double sum = 0; for (int i = 0; i<n; ++i) sum+=term(x,i); return sum; } Stroustrup/Programming/2015

  24. “Animate” approximations to ex Simple_window win {Point{100,100},xmax,ymax,""}; // the real exponential : Function real_exp {exp,r_min,r_max,orig,200,x_scale,y_scale}; real_exp.set_color(Color::blue); win.attach(real_exp); constintxlength = xmax-40; constintylength = ymax-40; Axis x {Axis::x, Point{20,y_orig}, xlength, xlength/x_scale, "one notch == 1"}; Axis y {Axis::y, Point{x_orig,ylength+20}, ylength, ylength/y_scale, "one notch == 1"}; win.attach(x); win.attach(y); x.set_color(Color::red); y.set_color(Color::red); Stroustrup/Programming/2015

  25. “Animate” approximations to ex for (int n = 0; n<50; ++n) { ostringstreamss; ss << "exp approximation; n==" << n ; win.set_label(ss.str().c_str()); expN_number_of_terms = n; // nasty sneaky argument to expN // next approximation: Function e([n](double x) { return expe(x,n); }, // n terms of Taylor series r_min,r_max,orig,200,x_scale,y_scale); win.attach(e); win.wait_for_button(); // give the user time to look win.detach(e); } Stroustrup/Programming/2015

  26. Lambda expression • What was this? • ([n](double x) { return expe(x,n);} //n terms of Taylor series • It’s a lambda, aka lambda expression aka lambda function • It takes n from the context and makes a function object using it • we can only graph functions of one argument, • so we had the language write one for us • ([n](double x) { return expe(x,n); } • Lambda expressions are important in modern C++ • A shorthand notation for defining function objects Argument declaration starts with ( Capture list starts with [ lambda function body Starts with { Stroustrup/Programming/2015

  27. Demo • The following screenshots are of the successive approximations of exp(x) using expe(x,n) Stroustrup/Programming/2015

  28. Demo n = 0 Stroustrup/Programming/2015

  29. Demo n = 1 Stroustrup/Programming/2015

  30. Demo n = 2 Stroustrup/Programming/2015

  31. Demo n = 3 Stroustrup/Programming/2015

  32. Demo n = 4 Stroustrup/Programming/2015

  33. Demo n = 5 Stroustrup/Programming/2015

  34. Demo n = 6 Stroustrup/Programming/2015

  35. Demo n = 7 Stroustrup/Programming/2015

  36. Demo n = 8 Stroustrup/Programming/2015

  37. Demo n = 18 Stroustrup/Programming/2015

  38. Demo n = 19 Stroustrup/Programming/2015

  39. Demo n = 20 Stroustrup/Programming/2015

  40. Demo n = 21 Stroustrup/Programming/2015

  41. Demo n = 22 Stroustrup/Programming/2015

  42. Demo n = 23 Stroustrup/Programming/2015

  43. Demo n = 30 Stroustrup/Programming/2015

  44. Why did the graph “go wild”? • Floating-point numbers are an approximations of real numbers • Just approximations • Real numbers can be arbitrarily large and arbitrarily small • Floating-point numbers are of a fixed size and can’t hold all real numbers • Also, sometimes the approximation is not good enough for what you do • Small inaccuracies (rounding errors) can build up into huge errors • Always • be suspicious about calculations • check your results • hope that your errors are obvious • You want your code to break early – before anyone else gets to use it Stroustrup/Programming/2015

  45. Graphing data • Often, what we want to graph is data, not a well-defined mathematical function • Here, we used three Open_polylines Stroustrup/Programming/2015

  46. Graphing data • Carefully design your screen layout Stroustrup/Programming/2015

  47. Code for Axis struct Axis : Shape { enum Orientation { x, y, z }; Axis(Orientation d, Point xy, int length, intnumber_of_notches = 0, // default: no notches string label = "" // default : no label ); void draw_lines() const; void move(int dx, intdy); void set_color(Color); // in case we want to change the color of all parts at once // line stored in Shape // orientation not stored (can be deduced from line) Text label; Lines notches; }; Stroustrup/Programming/2015

  48. Axis::Axis(Orientation d, Point xy, int length, int n, string lab) :label(Point(0,0),lab) { if (length<0) error("bad axis length"); switch (d){ case Axis::x: { Shape::add(xy); // axis line begin Shape::add(Point{xy.x+length,xy.y}); // axis line end if (1<n) { intdist = length/n; int x = xy.x+dist; for (int i = 0; i<n; ++i) { notches.add(Point{x,xy.y},Point{x,xy.y-5}); x += dist; } } label.move(length/3,xy.y+20); // put label under the line break; } // … } Stroustrup/Programming/2015

  49. Axis implementation void Axis::draw_lines() const { Shape::draw_lines(); // the line notches.draw_lines(); // the notches may have a different color from the line label.draw(); // the label may have a different color from the line } void Axis::move(int dx, int dy) { Shape::move(dx,dy); // the line notches.move(dx,dy); label.move(dx,dy); } void Axis::set_color(Color c) { // … the obvious three lines … } Stroustrup/Programming/2015

  50. Next Lecture • Graphical user interfaces • Windows and Widgets • Buttons and dialog boxes Stroustrup/Programming/2015

More Related