├── GUI.cpp
├── GUI.h
├── Graph.cpp
├── Graph.h
├── Gui.h
├── Matrix.h
├── Matrix11.h
├── MatrixIO.h
├── MatrixIO11.h
├── Point.h
├── Simple_window.cpp
├── Simple_window.h
├── Window.cpp
├── Window.h
├── fltk.h
└── std_lib_facilities.h


/GUI.cpp:
--------------------------------------------------------------------------------
 1 | #include "GUI.h"
 2 | #include "std_lib_facilities.h"
 3 | #include <sstream>
 4 | 
 5 | using namespace Graph_lib;
 6 | 
 7 | 
 8 | void Button::attach(Window& win)
 9 | 	{
10 | 		pw = new Fl_Button(loc.x, loc.y, width, height, label.c_str());
11 | 		pw->callback(reinterpret_cast<Fl_Callback*>(do_it), &win); // pass the window
12 | 		own = &win;
13 | 	}
14 | 
15 | int In_box::get_int()
16 | {
17 | 	Fl_Input& pi = reference_to<Fl_Input>(pw);
18 | //	return atoi(pi.value());
19 | 	const char* p = pi.value();
20 | 	if (!isdigit(p[0])) return -999999;
21 | 	return atoi(p);
22 | }
23 | 
24 | string In_box::get_string()
25 | {
26 | 	Fl_Input& pi = reference_to<Fl_Input>(pw);
27 | 	return string(pi.value());
28 | }
29 | 
30 | void In_box::attach(Window& win)
31 | {
32 | 	pw = new Fl_Input(loc.x, loc.y, width, height, label.c_str());
33 | 	own = &win;
34 | }
35 | 
36 | void Out_box::put(int i)
37 | {
38 | 	Fl_Output& po = reference_to<Fl_Output>(pw);
39 | 	std::stringstream ss;
40 | 	ss << i;
41 | 	po.value(ss.str().c_str());
42 | }
43 | 
44 | void Out_box::put(const string& s)
45 | {
46 | 	reference_to<Fl_Output>(pw).value(s.c_str());
47 | }
48 | 
49 | void Out_box::attach(Window& win)
50 | {
51 | 	pw = new Fl_Output(loc.x, loc.y, width, height, label.c_str());
52 | 	own = &win;
53 | }
54 | 
55 | Menu::Menu(Point xy, int w, int h, Kind kk, const string& s)
56 | :Widget(xy,w,h,s,0), k(kk), offset(0)
57 | {
58 | }
59 | 
60 | int Menu::attach(Button& b)
61 | {
62 | 	b.width = width;
63 | 	b.height = height;
64 | 
65 | 	switch(k) {
66 | 	case horizontal:
67 | 		b.loc = Point(loc.x+offset,loc.y);
68 | 		offset+=b.width;
69 | 		break;
70 | 	case vertical:
71 | 		b.loc = Point(loc.x,loc.y+offset);
72 | 		offset+=b.height;
73 | 		break;
74 | 	}
75 | 	selection.push_back(&b);
76 | 	return int(selection.size()-1);
77 | }
78 | 
79 | int Menu::attach(Button* p)
80 | {
81 | //	owned.push_back(p);
82 | 	return attach(*p);
83 | }


--------------------------------------------------------------------------------
/GUI.h:
--------------------------------------------------------------------------------
  1 | 
  2 | //
  3 | // This is a GUI support code to the chapters 12-16 of the book
  4 | // "Programming -- Principles and Practice Using C++" by Bjarne Stroustrup
  5 | //
  6 | 
  7 | #ifndef GUI_GUARD
  8 | #define GUI_GUARD
  9 | 
 10 | #include "Window.h"
 11 | #include "Graph.h"
 12 | 
 13 | namespace Graph_lib {
 14 | 
 15 | //------------------------------------------------------------------------------
 16 | 
 17 |     typedef void* Address;    // Address is a synonym for void*
 18 |     typedef void(*Callback)(Address, Address);    // FLTK's required function type for all callbacks
 19 | 
 20 | //------------------------------------------------------------------------------
 21 | 
 22 |     template<class W> W& reference_to(Address pw)
 23 |     // treat an address as a reference to a W
 24 |     {
 25 |         return *static_cast<W*>(pw);
 26 |     }
 27 | 
 28 | //------------------------------------------------------------------------------
 29 | 
 30 |     class Widget {
 31 |     // Widget is a handle to an Fl_widget - it is *not* an Fl_widget
 32 |     // We try to keep our interface classes at arm's length from FLTK
 33 |     public:
 34 |         Widget(Point xy, int w, int h, const string& s, Callback cb)
 35 |             : loc(xy), width(w), height(h), label(s), do_it(cb)
 36 |         {}
 37 | 
 38 |         virtual void move(int dx,int dy) { hide(); pw->position(loc.x+=dx, loc.y+=dy); show(); }
 39 |         virtual void hide() { pw->hide(); }
 40 |         virtual void show() { pw->show(); }
 41 |         virtual void attach(Window&) = 0;
 42 | 
 43 |         Point loc;
 44 |         int width;
 45 |         int height;
 46 |         string label;
 47 |         Callback do_it;
 48 | 
 49 |         virtual ~Widget() { }
 50 | 
 51 |     protected:
 52 |         Window* own;    // every Widget belongs to a Window
 53 |         Fl_Widget* pw;  // connection to the FLTK Widget
 54 |     private:
 55 |         Widget& operator=(const Widget&); // don't copy Widgets
 56 |         Widget(const Widget&);
 57 |     };
 58 | 
 59 | //------------------------------------------------------------------------------
 60 | 
 61 |     struct Button : Widget {
 62 |         Button(Point xy, int w, int h, const string& label, Callback cb)
 63 |             : Widget(xy,w,h,label,cb)
 64 |         {}
 65 | 
 66 |         void attach(Window&);
 67 |     };
 68 | 
 69 | //------------------------------------------------------------------------------
 70 | 
 71 |     struct In_box : Widget {
 72 |         In_box(Point xy, int w, int h, const string& s)
 73 |             :Widget(xy,w,h,s,0) { }
 74 |         int get_int();
 75 |         string get_string();
 76 | 
 77 |         void attach(Window& win);
 78 |     };
 79 | 
 80 | //------------------------------------------------------------------------------
 81 | 
 82 |     struct Out_box : Widget {
 83 |         Out_box(Point xy, int w, int h, const string& s)
 84 |             :Widget(xy,w,h,s,0) { }
 85 |         void put(int);
 86 |         void put(const string&);
 87 | 
 88 |         void attach(Window& win);
 89 |     };
 90 | 
 91 | //------------------------------------------------------------------------------
 92 | 
 93 |     struct Menu : Widget {
 94 |         enum Kind { horizontal, vertical };
 95 |         Menu(Point xy, int w, int h, Kind kk, const string& label)
 96 |             : Widget(xy,w,h,label,0), k(kk), offset(0)
 97 |         {}
 98 | 
 99 |         Vector_ref<Button> selection;
100 |         Kind k;
101 |         int offset;
102 |         int attach(Button& b);      // Menu does not delete &b
103 |         int attach(Button* p);      // Menu deletes p
104 | 
105 |         void show()                 // show all buttons
106 |         {
107 |             for (unsigned int i = 0; i<selection.size(); ++i)
108 |                 selection[i].show();
109 |         }
110 |         void hide()                 // hide all buttons
111 |         {
112 |             for (unsigned int i = 0; i<selection.size(); ++i) 
113 |                 selection[i].hide(); 
114 |         }
115 |         void move(int dx, int dy)   // move all buttons
116 |         {
117 |             for (unsigned int i = 0; i<selection.size(); ++i) 
118 |                 selection[i].move(dx,dy);
119 |         }
120 | 
121 |         void attach(Window& win)    // attach all buttons
122 |         {
123 |             for (int i=0; i<selection.size(); ++i) win.attach(selection[i]);
124 |             own = &win;
125 |         }
126 | 
127 |     };
128 | 
129 | //------------------------------------------------------------------------------
130 | 
131 | } // of namespace Graph_lib
132 | 
133 | #endif // GUI_GUARD
134 | 


--------------------------------------------------------------------------------
/Graph.cpp:
--------------------------------------------------------------------------------
  1 | #include "Graph.h"
  2 | #include<map>
  3 | 
  4 | namespace Graph_lib {
  5 | 
  6 | void Shape::draw_lines() const
  7 | {
  8 | 	if (color().visibility() && 1<points.size())	// draw sole pixel?
  9 | 		for (unsigned int i=1; i<points.size(); ++i)
 10 | 			fl_line(points[i-1].x,points[i-1].y,points[i].x,points[i].y);
 11 | }
 12 | 
 13 | void Shape::draw() const
 14 | {
 15 | 	Fl_Color oldc = fl_color();
 16 | 	// there is no good portable way of retrieving the current style
 17 | 	fl_color(lcolor.as_int());
 18 | 	fl_line_style(ls.style(),ls.width());
 19 | 	draw_lines();
 20 | 	fl_color(oldc);	// reset color (to pevious) and style (to default)
 21 | 	fl_line_style(0);
 22 | }
 23 | 
 24 | 
 25 | // does two lines (p1,p2) and (p3,p4) intersect?
 26 | // if se return the distance of the intersect point as distances from p1
 27 | inline pair<double,double> line_intersect(Point p1, Point p2, Point p3, Point p4, bool& parallel) 
 28 | {
 29 |     double x1 = p1.x;
 30 |     double x2 = p2.x;
 31 | 	double x3 = p3.x;
 32 | 	double x4 = p4.x;
 33 | 	double y1 = p1.y;
 34 | 	double y2 = p2.y;
 35 | 	double y3 = p3.y;
 36 | 	double y4 = p4.y;
 37 | 
 38 | 	double denom = ((y4 - y3)*(x2-x1) - (x4-x3)*(y2-y1));
 39 | 	if (denom == 0){
 40 | 		parallel= true;
 41 | 		return pair<double,double>(0,0);
 42 | 	}
 43 | 	parallel = false;
 44 | 	return pair<double,double>( ((x4-x3)*(y1-y3) - (y4-y3)*(x1-x3))/denom,
 45 | 								((x2-x1)*(y1-y3) - (y2-y1)*(x1-x3))/denom);
 46 | }
 47 | 
 48 | 
 49 | //intersection between two line segments
 50 | //Returns true if the two segments intersect,
 51 | //in which case intersection is set to the point of intersection
 52 | bool line_segment_intersect(Point p1, Point p2, Point p3, Point p4, Point& intersection){
 53 |    bool parallel;
 54 |    pair<double,double> u = line_intersect(p1,p2,p3,p4,parallel);
 55 |    if (parallel || u.first < 0 || u.first > 1 || u.second < 0 || u.second > 1) return false;
 56 |    intersection.x = p1.x + u.first*(p2.x - p1.x);
 57 |    intersection.y = p1.y + u.first*(p2.y - p1.y);
 58 |    return true;
 59 | } 
 60 | 
 61 | void Polygon::add(Point p)
 62 | {
 63 | 	int np = number_of_points();
 64 | 
 65 | 	if (1<np) {	// check that thenew line isn't parallel to the previous one
 66 | 		if (p==point(np-1)) error("polygon point equal to previous point");
 67 | 		bool parallel;
 68 | 		line_intersect(point(np-1),p,point(np-2),point(np-1),parallel);
 69 | 		if (parallel)
 70 | 			error("two polygon points lie in a straight line");
 71 | 	}
 72 | 
 73 | 	for (int i = 1; i<np-1; ++i) {	// check that new segment doesn't interset and old point
 74 | 		Point ignore(0,0);
 75 | 		if (line_segment_intersect(point(np-1),p,point(i-1),point(i),ignore))
 76 | 			error("intersect in polygon");
 77 | 	}
 78 | 	
 79 | 
 80 | 	Closed_polyline::add(p);
 81 | }
 82 | 
 83 | 
 84 | void Polygon::draw_lines() const
 85 | {
 86 | 		if (number_of_points() < 3) error("less than 3 points in a Polygon");
 87 | 		Closed_polyline::draw_lines();
 88 | }
 89 | 
 90 | void Open_polyline::draw_lines() const
 91 | {
 92 | 		if (fill_color().visibility()) {
 93 | 			fl_color(fill_color().as_int());
 94 | 			fl_begin_complex_polygon();
 95 | 			for(int i=0; i<number_of_points(); ++i){
 96 | 				fl_vertex(point(i).x, point(i).y);
 97 | 			}
 98 | 			fl_end_complex_polygon();
 99 | 			fl_color(color().as_int());	// reset color
100 | 		}
101 | 		
102 | 		if (color().visibility())
103 | 			Shape::draw_lines();
104 | }
105 | 
106 | 
107 | void Closed_polyline::draw_lines() const
108 | {
109 | 	Open_polyline::draw_lines();
110 | 		
111 | 	if (color().visibility())	// draw closing line:
112 | 		fl_line(point(number_of_points()-1).x,point(number_of_points()-1).y,point(0).x,point(0).y);
113 | }
114 | void Shape::move(int dx, int dy)
115 | {
116 | 	for (unsigned int i = 0; i<points.size(); ++i) {
117 | 		points[i].x+=dx;
118 | 		points[i].y+=dy;
119 | 	}
120 | }
121 | 
122 | void Lines::draw_lines() const
123 | {
124 | //	if (number_of_points()%2==1) error("odd number of points in set of lines");
125 | 	if (color().visibility())
126 | 		for (int i=1; i<number_of_points(); i+=2)
127 | 			fl_line(point(i-1).x,point(i-1).y,point(i).x,point(i).y);
128 | }
129 | 
130 | void Text::draw_lines() const
131 | {
132 | 	int ofnt = fl_font();
133 | 	int osz = fl_size();
134 | 	fl_font(fnt.as_int(),fnt_sz);
135 | 	fl_draw(lab.c_str(), point(0).x, point(0).y);
136 | 	fl_font(ofnt,osz);
137 | }
138 | 
139 | Function::Function(Fct f, double r1, double r2, Point xy, int count, double xscale, double yscale)
140 | // graph f(x) for x in [r1:r2) using count line segments with (0,0) displayed at xy
141 | // x coordinates are scaled by xscale and y coordinates scaled by yscale
142 | {
143 | 	if (r2-r1<=0) error("bad graphing range");
144 | 	if (count<=0) error("non-positive graphing count");
145 | 	double dist = (r2-r1)/count;
146 | 	double r = r1;
147 | 	for (int i = 0; i<count; ++i) {
148 | 		add(Point(xy.x+int(r*xscale),xy.y-int(f(r)*yscale)));
149 | 		r += dist;
150 | 	}
151 | }
152 | 
153 | void Rectangle::draw_lines() const
154 | {
155 | 	if (fill_color().visibility()) {	// fill
156 | 		fl_color(fill_color().as_int());
157 | 		fl_rectf(point(0).x,point(0).y,w,h);
158 | 		fl_color(color().as_int());	// reset color
159 | 	}
160 | 
161 | 	if (color().visibility()) {	// edge on top of fill
162 | 		fl_color(color().as_int());
163 | 		fl_rect(point(0).x,point(0).y,w,h);
164 | 	}
165 | }
166 | 
167 | 
168 | Axis::Axis(Orientation d, Point xy, int length, int n, string lab)
169 | 	:label(Point(0,0),lab)
170 | {
171 | 	if (length<0) error("bad axis length");
172 | 	switch (d){
173 | 	case Axis::x:
174 | 		{	Shape::add(xy);	// axis line
175 | 			Shape::add(Point(xy.x+length,xy.y));	// axis line
176 | 			if (1<n) {
177 | 				int dist = length/n;
178 | 				int x = xy.x+dist;
179 | 				for (int i = 0; i<n; ++i) {
180 | 					notches.add(Point(x,xy.y),Point(x,xy.y-5));
181 | 				x += dist;
182 | 			}
183 | 		}
184 | 		// label under the line
185 | 		label.move(length/3,xy.y+20);
186 | 		break;
187 | 	}
188 | 	case Axis::y:
189 | 		{	Shape::add(xy);	// a y-axis goes up
190 | 			Shape::add(Point(xy.x,xy.y-length));
191 | 			if (1<n) {
192 | 			int dist = length/n;
193 | 			int y = xy.y-dist;
194 | 			for (int i = 0; i<n; ++i) {
195 | 				notches.add(Point(xy.x,y),Point(xy.x+5,y));
196 | 				y -= dist;
197 | 			}
198 | 		}
199 | 		// label at top
200 | 		label.move(xy.x-10,xy.y-length-10);
201 | 		break;
202 | 	}
203 | 	case Axis::z:
204 | 		error("z axis not implemented");
205 | 	}
206 | }
207 | 
208 | void Axis::draw_lines() const
209 | {
210 | 	Shape::draw_lines();	// the line
211 | 	notches.draw();	// the notches may have a different color from the line
212 | 	label.draw();	// the label may have a different color from the line
213 | }
214 | 
215 | 
216 | void Axis::set_color(Color c)
217 | {
218 | 	Shape::set_color(c);
219 | 	notches.set_color(c);
220 | 	label.set_color(c);
221 | }
222 | 
223 | void Axis::move(int dx, int dy)
224 | {
225 | 	Shape::move(dx,dy);
226 | 	notches.move(dx,dy);
227 | 	label.move(dx,dy);
228 | }
229 | 
230 | void Circle::draw_lines() const
231 | {
232 | 	if (fill_color().visibility()) {	// fill
233 | 		fl_color(fill_color().as_int());
234 | 		fl_pie(point(0).x,point(0).y,r+r-1,r+r-1,0,360);
235 | 		fl_color(color().as_int());	// reset color
236 | 	}
237 | 
238 | 	if (color().visibility()) {
239 | 		fl_color(color().as_int());
240 | 		fl_arc(point(0).x,point(0).y,r+r,r+r,0,360);
241 | 	}
242 | }
243 | 
244 | 
245 | void Ellipse::draw_lines() const
246 | {
247 | 	if (fill_color().visibility()) {	// fill
248 | 		fl_color(fill_color().as_int());
249 | 		fl_pie(point(0).x,point(0).y,w+w-1,h+h-1,0,360);
250 | 		fl_color(color().as_int());	// reset color
251 | 	}
252 | 
253 | 	if (color().visibility()) {
254 | 		fl_color(color().as_int());
255 | 		fl_arc(point(0).x,point(0).y,w+w,h+h,0,360);
256 | 	}
257 | }
258 | 
259 | void draw_mark(Point xy, char c)
260 | {
261 | 	static const int dx = 4;
262 | 	static const int dy = 4;
263 | 	string m(1,c);
264 | 	fl_draw(m.c_str(),xy.x-dx,xy.y+dy);
265 | }
266 | 
267 | void Marked_polyline::draw_lines() const
268 | {
269 | 	Open_polyline::draw_lines();
270 | 	for (int i=0; i<number_of_points(); ++i) 
271 | 		draw_mark(point(i),mark[i%mark.size()]);
272 | }
273 | /*
274 | void Marks::draw_lines() const
275 | {
276 | 	for (int i=0; i<number_of_points(); ++i) 
277 | 		fl_draw(mark.c_str(),point(i).x-4,point(i).y+4);
278 | }
279 | */
280 | 
281 | 
282 | std::map<string,Suffix::Encoding> suffix_map;
283 | 
284 | int init_suffix_map()
285 | {
286 | 	suffix_map["jpg"] = Suffix::jpg;
287 | 	suffix_map["JPG"] = Suffix::jpg;
288 | 	suffix_map["jpeg"] = Suffix::jpg;
289 | 	suffix_map["JPEG"] = Suffix::jpg;
290 | 	suffix_map["gif"] = Suffix::gif;
291 | 	suffix_map["GIF"] = Suffix::gif;
292 | 	suffix_map["bmp"] = Suffix::bmp;
293 | 	suffix_map["BMP"] = Suffix::bmp;
294 | 	return 0;
295 | }
296 | 
297 | Suffix::Encoding get_encoding(const string& s)
298 | 		// try to deduce type from file name using a lookup table
299 | {
300 | 	static int x = init_suffix_map();
301 | 
302 | 	string::const_iterator p = find(s.begin(),s.end(),'.');
303 | 	if (p==s.end()) return Suffix::none;	// no suffix
304 | 
305 | 	string suf(p+1,s.end());
306 | 	return suffix_map[suf];
307 | }
308 | 
309 | bool can_open(const string& s)
310 |             // check if a file named s exists and can be opened for reading
311 | {
312 | 	ifstream ff(s.c_str());
313 | 	return ff;
314 | }
315 | 
316 | 
317 | // somewhat overelaborate constructor
318 | // because errors related to image files can be such a pain to debug
319 | Image::Image(Point xy, string s, Suffix::Encoding e)
320 | 	:w(0), h(0), fn(xy,"")
321 | {
322 | 	add(xy);
323 | 
324 | 	if (!can_open(s)) {
325 | 		fn.set_label("cannot open \""+s+'\"');
326 | 		p = new Bad_image(30,20);	// the "error image"
327 | 		return;
328 | 	}
329 | 
330 | 	if (e == Suffix::none) e = get_encoding(s);
331 | 	
332 | 	switch(e) {
333 | 	case Suffix::jpg:
334 | 		p = new Fl_JPEG_Image(s.c_str());
335 | 		break;
336 | 	case Suffix::gif:
337 | 		p = new Fl_GIF_Image(s.c_str());
338 | 		break;
339 | //	case Suffix::bmp:
340 | //		p = new Fl_BMP_Image(s.c_str());
341 | //		break;
342 | 	default:	// Unsupported image encoding
343 | 		fn.set_label("unsupported file type \""+s+'\"');
344 | 		p = new Bad_image(30,20);	// the "error image"
345 | 	}
346 | }
347 | 
348 | void Image::draw_lines() const
349 | {
350 | 	if (fn.label()!="") fn.draw_lines();
351 | 
352 | 	if (w&&h)
353 | 		p->draw(point(0).x,point(0).y,w,h,cx,cy);
354 | 	else
355 | 		p->draw(point(0).x,point(0).y);
356 | }
357 | 
358 | } // Graph


--------------------------------------------------------------------------------
/Graph.h:
--------------------------------------------------------------------------------
  1 | 
  2 | #ifndef GRAPH_GUARD
  3 | #define GRAPH_GUARD 1
  4 | 
  5 | #include "Point.h"
  6 | #include<vector>
  7 | //#include<string>
  8 | //#include<cmath>
  9 | #include "fltk.h"
 10 | //#include "std_lib_facilities.h"
 11 | 
 12 | namespace Graph_lib {
 13 | // defense against ill-behaved Linux macros:
 14 | #undef major
 15 | #undef minor
 16 | 
 17 | struct Color {
 18 | 	enum Color_type {
 19 | 		red=FL_RED, blue=FL_BLUE, green=FL_GREEN,
 20 | 		yellow=FL_YELLOW, white=FL_WHITE, black=FL_BLACK,
 21 | 		magenta=FL_MAGENTA, cyan=FL_CYAN, dark_red=FL_DARK_RED,
 22 | 		dark_green=FL_DARK_GREEN, dark_yellow=FL_DARK_YELLOW, dark_blue=FL_DARK_BLUE,
 23 | 		dark_magenta=FL_DARK_MAGENTA, dark_cyan=FL_DARK_CYAN
 24 | 	};
 25 | 	enum Transparency { invisible = 0, visible=255 };
 26 | 
 27 | 	Color(Color_type cc) :c(Fl_Color(cc)), v(visible) { }
 28 | 	Color(Color_type cc, Transparency vv) :c(Fl_Color(cc)), v(vv) { }
 29 | 	Color(int cc) :c(Fl_Color(cc)), v(visible) { }
 30 | 	Color(Transparency vv) :c(Fl_Color()), v(vv) { }
 31 | 
 32 | 	int as_int() const { return c; }
 33 | 	char visibility() const { return v; }
 34 | 	void set_visibility(Transparency vv) { v=vv; }
 35 | private:
 36 | 	unsigned char v;	// 0 or 1 for now
 37 | 	Fl_Color c;
 38 | };
 39 | 
 40 | struct Line_style {
 41 | 	enum Line_style_type {
 42 | 		solid=FL_SOLID,				// -------
 43 | 		dash=FL_DASH,				// - - - -
 44 | 		dot=FL_DOT,					// ....... 
 45 | 		dashdot=FL_DASHDOT,			// - . - . 
 46 | 		dashdotdot=FL_DASHDOTDOT,	// -..-..
 47 | 	};
 48 | 	Line_style(Line_style_type ss) :s(ss), w(0) { }
 49 | 	Line_style(Line_style_type lst, int ww) :s(lst), w(ww) { }
 50 | 	Line_style(int ss) :s(ss), w(0) { }
 51 | 
 52 | 	int width() const { return w; }
 53 | 	int style() const { return s; }
 54 | private:
 55 | 	int s;
 56 | 	int w;
 57 | };
 58 | 
 59 | class Font {
 60 | public:
 61 | 	enum Font_type {
 62 | 		helvetica=FL_HELVETICA,
 63 | 		helvetica_bold=FL_HELVETICA_BOLD,
 64 | 		helvetica_italic=FL_HELVETICA_ITALIC,
 65 | 		helvetica_bold_italic=FL_HELVETICA_BOLD_ITALIC,
 66 | 		courier=FL_COURIER,
 67 |   		courier_bold=FL_COURIER_BOLD,
 68 |   		courier_italic=FL_COURIER_ITALIC,
 69 |   		courier_bold_italic=FL_COURIER_BOLD_ITALIC,
 70 | 		times=FL_TIMES,
 71 | 		times_bold=FL_TIMES_BOLD,
 72 | 		times_italic=FL_TIMES_ITALIC,
 73 | 		times_bold_italic=FL_TIMES_BOLD_ITALIC,
 74 | 		symbol=FL_SYMBOL,
 75 | 		screen=FL_SCREEN,
 76 | 		screen_bold=FL_SCREEN_BOLD,
 77 | 		zapf_dingbats=FL_ZAPF_DINGBATS
 78 | 	};
 79 | 
 80 | 	Font(Font_type ff) :f(ff) { }
 81 | 	Font(int ff) :f(ff) { }
 82 | 
 83 | 	int as_int() const { return f; }
 84 | private:
 85 | 	int f;
 86 | };
 87 | 
 88 | template<class T> class Vector_ref {
 89 | 	vector<T*> v;
 90 | 	vector<T*> owned;
 91 | public:
 92 | 	Vector_ref() {}
 93 | 
 94 | 	Vector_ref(T* a, T* b=0, T* c=0, T* d=0)
 95 | 	{
 96 | 			if (a) push_back(a);
 97 | 			if (b) push_back(b);
 98 | 			if (c) push_back(c);
 99 | 			if (d) push_back(d);
100 | 	}
101 | 
102 | 	~Vector_ref() { for (int i=0; i<owned.size(); ++i) delete owned[i]; }
103 | 
104 | 	void push_back(T& s) { v.push_back(&s); }
105 | 	void push_back(T* p) { v.push_back(p); owned.push_back(p); }
106 | 
107 | 	// ???void erase(???)
108 | 
109 | 	T& operator[](int i) { return *v[i]; }
110 | 	const T& operator[](int i) const { return *v[i]; }
111 | 	int size() const { return v.size(); }
112 | };
113 | 
114 | typedef double Fct(double);
115 | 
116 | class Shape  {	// deals with color and style, and holds sequence of lines
117 | protected:
118 | 	Shape() { }
119 | 	Shape(initializer_list<Point> lst);  // add() the Points to this Shape
120 | 
121 | //	Shape() : lcolor(fl_color()),
122 | //		ls(0),
123 | //		fcolor(Color::invisible) { }
124 | 	
125 | 	void add(Point p){ points.push_back(p); }
126 | 	void set_point(int i, Point p) { points[i] = p; }
127 | public:
128 | 	void draw() const;					// deal with color and draw_lines
129 | protected:
130 | 	virtual void draw_lines() const;	// simply draw the appropriate lines
131 | public:
132 | 	virtual void move(int dx, int dy);	// move the shape +=dx and +=dy
133 | 
134 | 	void set_color(Color col) { lcolor = col; }
135 | 	Color color() const { return lcolor; }
136 | 
137 | 	void set_style(Line_style sty) { ls = sty; }
138 | 	Line_style style() const { return ls; }
139 | 
140 | 	void set_fill_color(Color col) { fcolor = col; }
141 | 	Color fill_color() const { return fcolor; }
142 | 
143 | 	Point point(int i) const { return points[i]; }
144 | 	int number_of_points() const { return int(points.size()); }
145 | 
146 | 	virtual ~Shape() { }
147 | 	/*
148 | 	struct Window* attached;
149 | 	Shape(const Shape& a)
150 | 		:attached(a.attached), points(a.points), line_color(a.line_color), ls(a.ls)
151 | 	{
152 | 		if (a.attached)error("attempt to copy attached shape");
153 | 	}
154 | 	*/
155 | 	Shape(const Shape&) = delete;
156 | 	Shape& operator=(const Shape&) = delete;
157 | private:
158 | 	vector<Point> points;	// not used by all shapes
159 | 	Color lcolor {fl_color()};
160 | 	Line_style ls {0};
161 | 	Color fcolor {Color::invisible};
162 | 
163 | //	Shape(const Shape&);
164 | //	Shape& operator=(const Shape&);
165 | };
166 | 
167 | struct Function : Shape {
168 | 	// the function parameters are not stored
169 | 	Function(Fct f, double r1, double r2, Point orig, int count = 100, double xscale = 25, double yscale = 25);
170 | 	//Function(Point orig, Fct f, double r1, double r2, int count, double xscale = 1, double yscale = 1);	
171 | };
172 | 
173 | struct Fill {
174 | 	Fill() :no_fill(true), fcolor(0) { }
175 | 	Fill(Color c) :no_fill(false), fcolor(c) { }
176 | 
177 | 	void set_fill_color(Color col) { fcolor = col; }
178 | 	Color fill_color() { return fcolor; }
179 | protected:
180 | 	bool no_fill;
181 | 	Color fcolor;
182 | };
183 | 
184 | struct Line : Shape {
185 | 	Line(Point p1, Point p2) { add(p1); add(p2); }
186 | };
187 | 
188 | struct Rectangle : Shape {
189 | 
190 | 	Rectangle(Point xy, int ww, int hh) :w{ ww }, h{ hh }
191 | 	{
192 | 		if (h<=0 || w<=0) error("Bad rectangle: non-positive side");
193 | 		add(xy);
194 | 	}
195 | 	Rectangle(Point x, Point y) :w{ y.x - x.x }, h{ y.y - x.y }
196 | 	{
197 | 		if (h<=0 || w<=0) error("Bad rectangle: first point is not top left");
198 | 		add(x);
199 | 	}
200 | 	void draw_lines() const;
201 | 
202 | //	void set_fill_color(Color col) { fcolor = col; }
203 | //	Color fill_color() { return fcolor; }
204 | 
205 | 	int height() const { return h; }
206 | 	int width() const { return w; }
207 | private:
208 | 	int h;			// height
209 | 	int w;			// width
210 | //	Color fcolor;	// fill color; 0 means "no fill"
211 | };
212 | 
213 | bool intersect(Point p1, Point p2, Point p3, Point p4);
214 | 
215 | 
216 | struct Open_polyline : Shape {	// open sequence of lines
217 | 	using Shape::Shape;
218 | 	void add(Point p) { Shape::add(p); }
219 | 	void draw_lines() const;
220 | };
221 | 
222 | struct Closed_polyline : Open_polyline {	// closed sequence of lines
223 | 	using Open_polyline::Open_polyline;
224 | 	void draw_lines() const;
225 | 	
226 | //	void add(Point p) { Shape::add(p); }
227 | };
228 | 
229 | 
230 | struct Polygon : Closed_polyline {	// closed sequence of non-intersecting lines
231 | 	using Closed_polyline::Closed_polyline;
232 | 	void add(Point p);
233 | 	void draw_lines() const;
234 | };
235 | 
236 | struct Lines : Shape {	// indepentdent lines
237 | 	Lines() {}
238 | 	Lines(initializer_list<Point> lst) : Shape{lst} { if (lst.size() % 2) error("odd number of points for Lines"); }
239 | 	void draw_lines() const;
240 | 	void add(Point p1, Point p2) { Shape::add(p1); Shape::add(p2); }
241 | };
242 | 
243 | struct Text : Shape {
244 | 	// the point is the bottom left of the first letter
245 | 	Text(Point x, const string& s) : lab{ s } { add(x); }
246 | 
247 | 	void draw_lines() const;
248 | 
249 | 	void set_label(const string& s) { lab = s; }
250 | 	string label() const { return lab; }
251 | 
252 | 	void set_font(Font f) { fnt = f; }
253 | 	Font font() const { return Font(fnt); }
254 | 
255 | 	void set_font_size(int s) { fnt_sz = s; }
256 | 	int font_size() const { return fnt_sz; }
257 | private:
258 | 	string lab;	// label
259 | 	Font fnt{ fl_font() };
260 | 	int fnt_sz{ (14<fl_size()) ? fl_size() : 14 };	// at least 14 point
261 | };
262 | 
263 | 
264 | struct Axis : Shape {
265 | 	// representation left public
266 | 	enum Orientation { x, y, z };
267 | 	Axis(Orientation d, Point xy, int length, int nummber_of_notches=0, string label = "");
268 | 
269 | 	void draw_lines() const;
270 | 	void move(int dx, int dy);
271 | 
272 | 	void set_color(Color c);
273 | 
274 | 	Text label;
275 | 	Lines notches;
276 | //	Orientation orin;
277 | //	int notches;
278 | };
279 | 
280 | struct Circle : Shape {
281 | 	Circle(Point p, int rr)	// center and radius
282 | 	:r{ rr } {
283 | 		add(Point{ p.x - r, p.y - r });
284 | 	}
285 | 
286 | 	void draw_lines() const;
287 | 
288 | 	Point center() const { return { point(0).x + r, point(0).y + r }; }
289 | 
290 | 	void set_radius(int rr) { r=rr; }
291 | 	int radius() const { return r; }
292 | private:
293 | 	int r;
294 | };
295 | 
296 | 
297 | struct Ellipse : Shape {
298 | 	Ellipse(Point p, int ww, int hh)	// center, min, and max distance from center
299 | 	:w{ ww }, h{ hh } {
300 | 		add(Point{ p.x - ww, p.y - hh });
301 | 	}
302 | 
303 | 	void draw_lines() const;
304 | 
305 | 	Point center() const { return{ point(0).x + w, point(0).y + h }; }
306 | 	Point focus1() const { return{ center().x + int(sqrt(double(w*w - h*h))), center().y }; }
307 | 	Point focus2() const { return{ center().x - int(sqrt(double(w*w - h*h))), center().y }; }
308 | 	
309 | 	void set_major(int ww) { w=ww; }
310 | 	int major() const { return w; }
311 | 	void set_minor(int hh) { h=hh; }
312 | 	int minor() const { return h; }
313 | private:
314 | 	int w;
315 | 	int h;
316 | };
317 | /*
318 | struct Mark : Text {
319 | 	static const int dw = 4;
320 | 	static const int dh = 4;
321 | 	Mark(Point xy, char c) : Text(Point(xy.x-dw, xy.y+dh),string(1,c)) {}
322 | };
323 | */
324 | 
325 | struct Marked_polyline : Open_polyline {
326 | 	Marked_polyline(const string& m) :mark(m) { }
327 | 	void draw_lines() const;
328 | private:
329 | 	string mark;
330 | };
331 | 
332 | struct Marks : Marked_polyline {
333 | 	Marks(const string& m) :Marked_polyline(m)
334 | 	{ set_color(Color(Color::invisible)); }
335 | };
336 | 
337 | struct Mark : Marks {
338 | 	Mark(Point xy, char c) : Marks(string(1,c)) {add(xy); }
339 | };
340 | 
341 | /*
342 | 
343 | struct Marks : Shape {
344 | 	Marks(char m) : mark(string(1,m)) { }
345 | 	void add(Point p) { Shape::add(p); }
346 | 	void draw_lines() const;
347 | private:
348 | 	string mark;
349 | };
350 | */
351 | 
352 | struct Bad_image : Fl_Image {
353 | 	Bad_image(int h, int w) : Fl_Image(h,w,0) { }
354 | 	void draw(int x,int y, int, int, int, int) { draw_empty(x,y); }
355 | };
356 | 
357 | struct Suffix {
358 | 	enum Encoding { none, jpg, gif, bmp };
359 | };
360 | 
361 | Suffix::Encoding get_encoding(const string& s);
362 | 
363 | struct Image : Shape {
364 | 	Image(Point xy, string s, Suffix::Encoding e = Suffix::none);
365 | 	~Image() { delete p; }
366 | 	void draw_lines() const;
367 | 	void set_mask(Point xy, int ww, int hh) { w=ww; h=hh; cx=xy.x; cy=xy.y; }
368 | 	void move(int dx,int dy) { Shape::move(dx,dy); p->draw(point(0).x,point(0).y); }
369 | private:
370 | 	int w,h,cx,cy; // define "masking box" within image relative to position (cx,cy)
371 | 	Fl_Image* p;
372 | 	Text fn;
373 | };
374 | 
375 | }
376 | #endif
377 | 
378 | 


--------------------------------------------------------------------------------
/Gui.h:
--------------------------------------------------------------------------------
  1 | #ifndef GUI_GUARD
  2 | #define GUI_GUARD
  3 | 
  4 | #include "Point.h"
  5 | #include "fltk.h"
  6 | #include "Window.h"
  7 | #include "Graph.h"
  8 | //#include<vector>
  9 | //#include<string>
 10 | 
 11 | namespace Graph_lib {
 12 | 	
 13 | typedef void* Address;
 14 | typedef void (*Callback)(Address,Address);	// FLTK's required function type for all callbacks
 15 | 
 16 | template<class W> W& reference_to(Address pw)
 17 | 	// treat an address as a reference to a W
 18 | {
 19 | 		return *static_cast<W*>(pw);
 20 | }
 21 | 
 22 | 
 23 | class Widget {
 24 | 	// Widget is a handle to a Fl_widget - it is *not* a Fl_widget
 25 | 	// We try to keep our interface classes at arm's length from FLTK
 26 | public:
 27 | 	Widget(Point xy, int w, int h, const string& s, Callback cb)
 28 | 		:loc(xy), width(w), height(h), label(s), do_it(cb)
 29 | 	{ }
 30 | 
 31 | 	virtual void move(int dx,int dy) { hide(); pw->position(loc.x+=dx, loc.y+=dy); show(); }
 32 | 	virtual void hide() { pw->hide(); }
 33 | 	virtual void show() { pw->show(); }
 34 | 	virtual void attach(Window&) = 0;	// each Widgit define at least one action for a window
 35 | 
 36 | 	Point loc;
 37 | 	int width;
 38 | 	int height;
 39 | 	string label;
 40 | 	Callback do_it;
 41 | 
 42 | 	virtual ~Widget() { }
 43 | 
 44 | 	/*
 45 | 	Widget(const Widget& a) :loc(a.loc) { error("attempt to copy Widget by constructor"); }
 46 | 	Widget& operator=(const Widget& a)
 47 | 	{
 48 | 			error("attempt to copy Widget by cassignment");
 49 | 			return *this;
 50 | 	}
 51 | 	*/
 52 | 
 53 | protected:
 54 | 	Window* own;	// every Widget belongs to a Window
 55 | 	Fl_Widget* pw;
 56 | private:
 57 | 	Widget& operator=(const Widget&);	// don't copy Widgets
 58 | 	Widget(const Widget&);
 59 | };
 60 | 
 61 | class Button : public Widget {
 62 | public:
 63 | 	Button(Point xy, int ww, int hh, const string& s, Callback cb)
 64 | 	:Widget(xy,ww,hh,s,cb)
 65 | 	{ 
 66 | 	}
 67 | 	void attach(Window& win);
 68 | };
 69 | 
 70 | struct In_box : Widget {
 71 | 	In_box(Point xy, int w, int h, const string& s)
 72 | 		:Widget(xy,w,h,s,0)
 73 | 		{
 74 | 		}
 75 | 	int get_int();
 76 | 	string get_string();
 77 | 
 78 | 	void attach(Window& win);
 79 | };
 80 | 
 81 | struct Out_box : Widget {
 82 | 	Out_box(Point xy, int w, int h, const string& s/*, Window& win*/)
 83 | 		:Widget(xy,w,h,s,0)
 84 | 		{
 85 | 		}
 86 | 	void put(int);
 87 | 	void put(const string&);
 88 | 
 89 | 	void attach(Window& win);
 90 | };
 91 | 
 92 | struct Menu : Widget {
 93 | 	enum Kind { horizontal, vertical };
 94 | 	Menu(Point xy, int w, int h, Kind kk, const string& s);
 95 | 	Vector_ref<Button> selection;
 96 | 	Kind k;
 97 | 	int offset;
 98 | 	int attach(Button& b);	// attach button; Menu does not delete &b
 99 | 	int attach(Button* p);	// attach new button; Menu deletes p
100 | 	void show() { for (int i = 0; i<selection.size(); ++i) selection[i].show(); }
101 | 	void hide() { for (int i = 0; i<selection.size(); ++i) selection[i].hide(); }
102 | 	void move(int dx, int dy)
103 | 		{ for (int i = 0; i<selection.size(); ++i) selection[i].move(dx,dy); }
104 | //	int insert(int i, const Button& b);	// not implemented
105 | 
106 | 	void attach(Window& win)
107 | 	{
108 | 		for (int i=0; i<selection.size(); ++i) win.attach(selection[i]);
109 | 	}	
110 | 
111 | };
112 | 
113 | }
114 | #endif
115 | 
116 | 


--------------------------------------------------------------------------------
/Matrix.h:
--------------------------------------------------------------------------------
  1 | 
  2 | /*
  3 |     warning: this small multidimensional matrix library uses a few features
  4 |     not taught in ENGR112 and not explained in elementary textbooks
  5 | 
  6 |     (c) Bjarne Stroustrup, Texas A&M University. 
  7 | 
  8 |     Use as you like as long as you acknowledge the source.
  9 | */
 10 | 
 11 | #ifndef MATRIX_LIB
 12 | #define MATRIX_LIB
 13 | 
 14 | #include<string>
 15 | #include<algorithm>
 16 | //#include<iostream>
 17 | 
 18 | namespace Numeric_lib {
 19 | 
 20 | //-----------------------------------------------------------------------------
 21 | 
 22 | struct Matrix_error {
 23 |     std::string name;
 24 |     Matrix_error(const char* q) :name(q) { }
 25 |     Matrix_error(std::string n) :name(n) { }
 26 | };
 27 | 
 28 | //-----------------------------------------------------------------------------
 29 | 
 30 | inline void error(const char* p)
 31 | {
 32 |     throw Matrix_error(p);
 33 | }
 34 | 
 35 | //-----------------------------------------------------------------------------
 36 | 
 37 | typedef long Index;    // I still dislike unsigned
 38 | 
 39 | //-----------------------------------------------------------------------------
 40 | 
 41 | // The general Matrix template is simply a prop for its specializations:
 42 | template<class T = double, int D = 1> class Matrix {
 43 |     // multidimensional matrix class
 44 |     // ( ) does multidimensional subscripting
 45 |     // [ ] does C style "slicing": gives an N-1 dimensional matrix from an N dimensional one
 46 |     // row() is equivalent to [ ]
 47 |     // column() is not (yet) implemented because it requires strides.
 48 |     // = has copy semantics
 49 |     // ( ) and [ ] are range checked
 50 |     // slice() to give sub-ranges 
 51 | private:
 52 |     Matrix();    // this should never be compiled
 53 | //	template<class A> Matrix(A);
 54 | };
 55 | 
 56 | //-----------------------------------------------------------------------------
 57 | 
 58 | template<class T = double, int D = 1> class Row ;    // forward declaration
 59 | 
 60 | //-----------------------------------------------------------------------------
 61 | 
 62 | // function objects for various apply() operations:
 63 | 
 64 | template<class T> struct Assign {
 65 |     void operator()(T& a, const T& c) { a = c; }
 66 | };
 67 | 
 68 | template<class T> struct Add_assign {
 69 |     void operator()(T& a, const T& c) { a += c; }
 70 | };
 71 | template<class T> struct Mul_assign {
 72 |     void operator()(T& a, const T& c) { a *= c; }
 73 | };
 74 | template<class T> struct Minus_assign {
 75 |     void operator()(T& a, const T& c) { a -= c; }
 76 | };
 77 | template<class T> struct Div_assign {
 78 |     void operator()(T& a, const T& c) { a /= c; }
 79 | };
 80 | template<class T> struct Mod_assign {
 81 |     void operator()(T& a, const T& c) { a %= c; }
 82 | };
 83 | template<class T> struct Or_assign {
 84 |     void operator()(T& a, const T& c) { a |= c; }
 85 | };
 86 | template<class T> struct Xor_assign {
 87 |     void operator()(T& a, const T& c) { a ^= c; }
 88 | };
 89 | template<class T> struct And_assign {
 90 |     void operator()(T& a, const T& c) { a &= c; }
 91 | };
 92 | 
 93 | template<class T> struct Not_assign {
 94 |     void operator()(T& a) { a = !a; }
 95 | };
 96 | 
 97 | template<class T> struct Not {
 98 |     T operator()(T& a) { return !a; }
 99 | };
100 | 
101 | template<class T> struct Unary_minus {
102 |     T operator()(T& a) { return -a; }
103 | };
104 | 
105 | template<class T> struct Complement {
106 |     T operator()(T& a) { return ~a; }
107 | };
108 | 
109 | //-----------------------------------------------------------------------------
110 | 
111 | // Matrix_base represents the common part of the Matrix classes:
112 | template<class T> class Matrix_base {
113 |     // matrixs store their memory (elements) in Matrix_base and have copy semantics
114 |     // Matrix_base does element-wise operations
115 | protected:
116 |     T* elem;    // vector? no: we couldn't easily provide a vector for a slice
117 |     const Index sz;    
118 |     mutable bool owns;
119 |     mutable bool xfer;
120 | public:
121 |     Matrix_base(Index n) :elem(new T[n]()), sz(n), owns(true), xfer(false)
122 |         // matrix of n elements (default initialized)
123 |     {
124 |         // std::cerr << "new[" << n << "]->" << elem << "\n";
125 |     }
126 | 
127 |     Matrix_base(Index n, T* p) :elem(p), sz(n), owns(false), xfer(false)
128 |         // descriptor for matrix of n elements owned by someone else
129 |     {
130 |     }
131 | 
132 |     ~Matrix_base()
133 |     {
134 |         if (owns) {
135 |             // std::cerr << "delete[" << sz << "] " << elem << "\n";
136 |             delete[]elem;
137 |         }
138 |     }
139 | 
140 |     // if necessay, we can get to the raw matrix:
141 |           T* data()       { return elem; }
142 |     const T* data() const { return elem; }
143 |     Index    size() const { return sz; }
144 | 
145 |     void copy_elements(const Matrix_base& a)
146 |     {
147 |         if (sz!=a.sz) error("copy_elements()");
148 |         for (Index i=0; i<sz; ++i) elem[i] = a.elem[i];
149 |     }
150 | 
151 |     void base_assign(const Matrix_base& a) { copy_elements(a); }
152 | 
153 |     void base_copy(const Matrix_base& a)
154 |     {
155 |         if (a.xfer) {          // a is just about to be deleted
156 |                                // so we can transfer ownership rather than copy
157 |             // std::cerr << "xfer @" << a.elem << " [" << a.sz << "]\n";
158 |             elem = a.elem;
159 |             a.xfer = false;    // note: modifies source
160 |             a.owns = false;
161 |         }
162 |         else {
163 |             elem = new T[a.sz];
164 |             // std::cerr << "base copy @" << a.elem << " [" << a.sz << "]\n";
165 |             copy_elements(a);
166 |         }
167 |         owns = true;
168 |         xfer = false;
169 |     }
170 | 
171 |     // to get the elements of a local matrix out of a function without copying:
172 |     void base_xfer(Matrix_base& x)
173 |     {
174 |         if (owns==false) error("cannot xfer() non-owner");
175 |         owns = false;     // now the elements are safe from deletion by original owner
176 |         x.xfer = true;    // target asserts temporary ownership
177 |         x.owns = true;
178 |     }
179 | 
180 |     template<class F> void base_apply(F f) { for (Index i = 0; i<size(); ++i) f(elem[i]); }
181 |     template<class F> void base_apply(F f, const T& c) { for (Index i = 0; i<size(); ++i) f(elem[i],c); }
182 | private:
183 |     void operator=(const Matrix_base&);    // no ordinary copy of bases
184 |     Matrix_base(const Matrix_base&);
185 | };
186 | 
187 | //-----------------------------------------------------------------------------
188 | 
189 | template<class T> class Matrix<T,1> : public Matrix_base<T> {
190 |     const Index d1;
191 | 
192 | protected:
193 |     // for use by Row:
194 |     Matrix(Index n1, T* p) : Matrix_base<T>(n1,p), d1(n1)
195 |     {
196 |         // std::cerr << "construct 1D Matrix from data\n";
197 |     }
198 | 
199 | public:
200 | 
201 |     Matrix(Index n1) : Matrix_base<T>(n1), d1(n1) { }
202 | 
203 |     Matrix(Row<T,1>& a) : Matrix_base<T>(a.dim1(),a.p), d1(a.dim1()) 
204 |     { 
205 |         // std::cerr << "construct 1D Matrix from Row\n";
206 |     }
207 | 
208 |     // copy constructor: let the base do the copy:
209 |     Matrix(const Matrix& a) : Matrix_base<T>(a.size(),0), d1(a.d1)
210 |     {
211 |         // std::cerr << "copy ctor\n";
212 |         this->base_copy(a);
213 |     }
214 | 
215 |     template<int n> 
216 |     Matrix(const T (&a)[n]) : Matrix_base<T>(n), d1(n)
217 |         // deduce "n" (and "T"), Matrix_base allocates T[n]
218 |     {
219 |         // std::cerr << "matrix ctor\n";
220 |         for (Index i = 0; i<n; ++i) this->elem[i]=a[i];
221 |     }
222 | 
223 |     Matrix(const T* p, Index n) : Matrix_base<T>(n), d1(n)
224 |         // Matrix_base allocates T[n]
225 |     {
226 |         // std::cerr << "matrix ctor\n";
227 |         for (Index i = 0; i<n; ++i) this->elem[i]=p[i];
228 |     }
229 | 
230 |     template<class F> Matrix(const Matrix& a, F f) : Matrix_base<T>(a.size()), d1(a.d1)
231 |         // construct a new Matrix with element's that are functions of a's elements:
232 |         // does not modify a unless f has been specifically programmed to modify its argument
233 |         // T f(const T&) would be a typical type for f
234 |     {
235 |         for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i]); 
236 |     }
237 | 
238 |     template<class F, class Arg> Matrix(const Matrix& a, F f, const Arg& t1) : Matrix_base<T>(a.size()), d1(a.d1)
239 |         // construct a new Matrix with element's that are functions of a's elements:
240 |         // does not modify a unless f has been specifically programmed to modify its argument
241 |         // T f(const T&, const Arg&) would be a typical type for f
242 |     {
243 |         for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i],t1); 
244 |     }
245 | 
246 |     Matrix& operator=(const Matrix& a)
247 |         // copy assignment: let the base do the copy
248 |     {
249 |         // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<< ")\n";
250 |         if (d1!=a.d1) error("length error in 1D=");
251 |         this->base_assign(a);
252 |         return *this;
253 |     }
254 | 
255 |     ~Matrix() { }
256 | 
257 |     Index dim1() const { return d1; }    // number of elements in a row
258 | 
259 |     Matrix xfer()    // make an Matrix to move elements out of a scope
260 |     {
261 |         Matrix x(dim1(),this->data()); // make a descriptor
262 |         this->base_xfer(x);                  // transfer (temporary) ownership to x
263 |         return x;
264 |     }
265 | 
266 |     void range_check(Index n1) const
267 |     {
268 |         // std::cerr << "range check: (" << d1 << "): " << n1 << "\n"; 
269 |         if (n1<0 || d1<=n1) error("1D range error: dimension 1");
270 |     }
271 | 
272 |     // subscripting:
273 |           T& operator()(Index n1)       { range_check(n1); return this->elem[n1]; }
274 |     const T& operator()(Index n1) const { range_check(n1); return this->elem[n1]; }
275 | 
276 |     // slicing (the same as subscripting for 1D matrixs):
277 |           T& operator[](Index n)       { return row(n); }
278 |     const T& operator[](Index n) const { return row(n); }
279 | 
280 |           T& row(Index n)       { range_check(n); return this->elem[n]; }
281 |     const T& row(Index n) const { range_check(n); return this->elem[n]; }
282 | 
283 |     Row<T,1> slice(Index n)
284 |         // the last elements from a[n] onwards
285 |     {
286 |         if (n<0) n=0;
287 |         else if(d1<n) n=d1;// one beyond the end
288 |         return Row<T,1>(d1-n,this->elem+n);
289 |     }
290 | 
291 |     const Row<T,1> slice(Index n) const
292 |         // the last elements from a[n] onwards
293 |     {
294 |         if (n<0) n=0;
295 |         else if(d1<n) n=d1;// one beyond the end
296 |         return Row<T,1>(d1-n,this->elem+n);
297 |     }
298 | 
299 |     Row<T,1> slice(Index n, Index m)
300 |         // m elements starting with a[n]
301 |     {
302 |         if (n<0) n=0;
303 |         else if(d1<n) n=d1;    // one beyond the end
304 |         if (m<0) m = 0;
305 |         else if (d1<n+m) m=d1-n;
306 |         return Row<T,1>(m,this->elem+n);
307 |     }
308 | 
309 |     const Row<T,1> slice(Index n, Index m) const
310 |         // m elements starting with a[n]
311 |     {
312 |         if (n<0) n=0;
313 |         else if(d1<n) n=d1;    // one beyond the end
314 |         if (m<0) m = 0;
315 |         else if (d1<n+m) m=d1-n;
316 |         return Row<T,1>(m,this->elem+n);
317 |     }
318 | 
319 |     // element-wise operations:
320 |     template<class F> Matrix& apply(F f) { this->base_apply(f); return *this; }
321 |     template<class F> Matrix& apply(F f,const T& c) { this->base_apply(f,c); return *this; }
322 | 
323 |     Matrix& operator=(const T& c)  { this->base_apply(Assign<T>(),c);       return *this; }
324 | 
325 |     Matrix& operator*=(const T& c) { this->base_apply(Mul_assign<T>(),c);   return *this; }
326 |     Matrix& operator/=(const T& c) { this->base_apply(Div_assign<T>(),c);   return *this; }
327 |     Matrix& operator%=(const T& c) { this->base_apply(Mod_assign<T>(),c);   return *this; }
328 |     Matrix& operator+=(const T& c) { this->base_apply(Add_assign<T>(),c);   return *this; }
329 |     Matrix& operator-=(const T& c) { this->base_apply(Minus_assign<T>(),c); return *this; }
330 | 
331 |     Matrix& operator&=(const T& c) { this->base_apply(And_assign<T>(),c);   return *this; }
332 |     Matrix& operator|=(const T& c) { this->base_apply(Or_assign<T>(),c);    return *this; }
333 |     Matrix& operator^=(const T& c) { this->base_apply(Xor_assign<T>(),c);   return *this; }
334 | 
335 |     Matrix operator!() { return xfer(Matrix(*this,Not<T>())); }
336 |     Matrix operator-() { return xfer(Matrix(*this,Unary_minus<T>())); }
337 |     Matrix operator~() { return xfer(Matrix(*this,Complement<T>()));  }
338 | 
339 |     template<class F> Matrix apply_new(F f) { return xfer(Matrix(*this,f)); }
340 |     
341 |     void swap_rows(Index i, Index j)
342 |         // swap_rows() uses a row's worth of memory for better run-time performance
343 |         // if you want pairwise swap, just write it yourself
344 |     {
345 |         if (i == j) return;
346 |     /*
347 |         Matrix<T,1> temp = (*this)[i];
348 |         (*this)[i] = (*this)[j];
349 |         (*this)[j] = temp;
350 |     */
351 |         Index max = (*this)[i].size();
352 |         for (Index ii=0; ii<max; ++ii) std::swap((*this)(i,ii),(*this)(j,ii));
353 |     }
354 | };
355 | 
356 | //-----------------------------------------------------------------------------
357 | 
358 | template<class T> class Matrix<T,2> : public Matrix_base<T> {
359 |     const Index d1;
360 |     const Index d2;
361 | 
362 | protected:
363 |     // for use by Row:
364 |     Matrix(Index n1, Index n2, T* p) : Matrix_base<T>(n1*n2,p), d1(n1), d2(n2) 
365 |     {
366 |        //  std::cerr << "construct 3D Matrix from data\n";
367 |     }
368 | 
369 | public:
370 | 
371 |     Matrix(Index n1, Index n2) : Matrix_base<T>(n1*n2), d1(n1), d2(n2) { }
372 | 
373 |     Matrix(Row<T,2>& a) : Matrix_base<T>(a.dim1()*a.dim2(),a.p), d1(a.dim1()), d2(a.dim2())
374 |     { 
375 |        // std::cerr << "construct 2D Matrix from Row\n";
376 |     }
377 | 
378 |     // copy constructor: let the base do the copy:
379 |     Matrix(const Matrix& a) : Matrix_base<T>(a.size(),0), d1(a.d1), d2(a.d2)
380 |     {
381 |         // std::cerr << "copy ctor\n";
382 |         this->base_copy(a);
383 |     }
384 | 
385 |     template<int n1, int n2> 
386 |     Matrix(const T (&a)[n1][n2]) : Matrix_base<T>(n1*n2), d1(n1), d2(n2)
387 |         // deduce "n1", "n2" (and "T"), Matrix_base allocates T[n1*n2]
388 |     {
389 |         // std::cerr << "matrix ctor (" << n1 << "," << n2 << ")\n";
390 |         for (Index i = 0; i<n1; ++i)
391 |             for (Index j = 0; j<n2; ++j) this->elem[i*n2+j]=a[i][j];
392 |     }
393 | 
394 |     template<class F> Matrix(const Matrix& a, F f) : Matrix_base<T>(a.size()), d1(a.d1), d2(a.d2)
395 |         // construct a new Matrix with element's that are functions of a's elements:
396 |         // does not modify a unless f has been specifically programmed to modify its argument
397 |         // T f(const T&) would be a typical type for f
398 |     {
399 |         for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i]); 
400 |     }
401 | 
402 |     template<class F, class Arg> Matrix(const Matrix& a, F f, const Arg& t1) : Matrix_base<T>(a.size()), d1(a.d1), d2(a.d2)
403 |         // construct a new Matrix with element's that are functions of a's elements:
404 |         // does not modify a unless f has been specifically programmed to modify its argument
405 |         // T f(const T&, const Arg&) would be a typical type for f
406 |     {
407 |         for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i],t1); 
408 |     }
409 | 
410 |     Matrix& operator=(const Matrix& a)
411 |         // copy assignment: let the base do the copy
412 |     {
413 |         // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<< ")\n";
414 |         if (d1!=a.d1 || d2!=a.d2) error("length error in 2D =");
415 |         this->base_assign(a);
416 |         return *this;
417 |     }
418 | 
419 |     ~Matrix() { }
420 |     
421 |     Index dim1() const { return d1; }    // number of elements in a row
422 |     Index dim2() const { return d2; }    // number of elements in a column
423 | 
424 |     Matrix xfer()    // make an Matrix to move elements out of a scope
425 |     {
426 |         Matrix x(dim1(),dim2(),this->data()); // make a descriptor
427 |         this->base_xfer(x);            // transfer (temporary) ownership to x
428 |         return x;
429 |     }
430 | 
431 |     void range_check(Index n1, Index n2) const
432 |     {
433 |         // std::cerr << "range check: (" << d1 << "," << d2 << "): " << n1 << " " << n2 << "\n";
434 |         if (n1<0 || d1<=n1) error("2D range error: dimension 1");
435 |         if (n2<0 || d2<=n2) error("2D range error: dimension 2");
436 |     }
437 | 
438 |     // subscripting:
439 |           T& operator()(Index n1, Index n2)       { range_check(n1,n2); return this->elem[n1*d2+n2]; }
440 |     const T& operator()(Index n1, Index n2) const { range_check(n1,n2); return this->elem[n1*d2+n2]; }
441 | 
442 |     // slicing (return a row):
443 |           Row<T,1> operator[](Index n)       { return row(n); }
444 |     const Row<T,1> operator[](Index n) const { return row(n); }
445 | 
446 |           Row<T,1> row(Index n)       { range_check(n,0); return Row<T,1>(d2,&this->elem[n*d2]); }
447 |     const Row<T,1> row(Index n) const { range_check(n,0); return Row<T,1>(d2,&this->elem[n*d2]); }
448 | 
449 |     Row<T,2> slice(Index n)
450 |         // rows [n:d1)
451 |     {
452 |         if (n<0) n=0;
453 |         else if(d1<n) n=d1;    // one beyond the end
454 |         return Row<T,2>(d1-n,d2,this->elem+n*d2);
455 |     }
456 | 
457 |     const Row<T,2> slice(Index n) const
458 |         // rows [n:d1)
459 |     {
460 |         if (n<0) n=0;
461 |         else if(d1<n) n=d1;    // one beyond the end
462 |         return Row<T,2>(d1-n,d2,this->elem+n*d2);
463 |     }
464 | 
465 |     Row<T,2> slice(Index n, Index m)
466 |         // the rows [n:m)
467 |     {
468 |         if (n<0) n=0;
469 |         if(d1<m) m=d1;    // one beyond the end
470 |         return Row<T,2>(m-n,d2,this->elem+n*d2);
471 | 
472 |     }
473 | 
474 |     const Row<T,2> slice(Index n, Index m) const
475 |         // the rows [n:sz)
476 |     {
477 |         if (n<0) n=0;
478 |         if(d1<m) m=d1;    // one beyond the end
479 |         return Row<T,2>(m-n,d2,this->elem+n*d2);
480 |     }
481 | 
482 |     // Column<T,1> column(Index n); // not (yet) implemented: requies strides and operations on columns
483 | 
484 |     // element-wise operations:
485 |     template<class F> Matrix& apply(F f)            { this->base_apply(f);   return *this; }
486 |     template<class F> Matrix& apply(F f,const T& c) { this->base_apply(f,c); return *this; }
487 | 
488 |     Matrix& operator=(const T& c)  { this->base_apply(Assign<T>(),c);       return *this; }
489 | 
490 |     Matrix& operator*=(const T& c) { this->base_apply(Mul_assign<T>(),c);   return *this; }
491 |     Matrix& operator/=(const T& c) { this->base_apply(Div_assign<T>(),c);   return *this; }
492 |     Matrix& operator%=(const T& c) { this->base_apply(Mod_assign<T>(),c);   return *this; }
493 |     Matrix& operator+=(const T& c) { this->base_apply(Add_assign<T>(),c);   return *this; }
494 |     Matrix& operator-=(const T& c) { this->base_apply(Minus_assign<T>(),c); return *this; }
495 | 
496 |     Matrix& operator&=(const T& c) { this->base_apply(And_assign<T>(),c);   return *this; }
497 |     Matrix& operator|=(const T& c) { this->base_apply(Or_assign<T>(),c);    return *this; }
498 |     Matrix& operator^=(const T& c) { this->base_apply(Xor_assign<T>(),c);   return *this; }
499 | 
500 |     Matrix operator!() { return xfer(Matrix(*this,Not<T>())); }
501 |     Matrix operator-() { return xfer(Matrix(*this,Unary_minus<T>())); }
502 |     Matrix operator~() { return xfer(Matrix(*this,Complement<T>()));  }
503 | 
504 |     template<class F> Matrix apply_new(F f) { return xfer(Matrix(*this,f)); }
505 |     
506 |     void swap_rows(Index i, Index j)
507 |         // swap_rows() uses a row's worth of memory for better run-time performance
508 |         // if you want pairwise swap, just write it yourself
509 |     {
510 |         if (i == j) return;
511 |     /*
512 |         Matrix<T,1> temp = (*this)[i];
513 |         (*this)[i] = (*this)[j];
514 |         (*this)[j] = temp;
515 |     */
516 |         Index max = (*this)[i].size();
517 |         for (Index ii=0; ii<max; ++ii) std::swap((*this)(i,ii),(*this)(j,ii));
518 |     }
519 | };
520 | 
521 | //-----------------------------------------------------------------------------
522 | 
523 | template<class T> class Matrix<T,3> : public Matrix_base<T> {
524 |     const Index d1;
525 |     const Index d2;
526 |     const Index d3;
527 | 
528 | protected:
529 |     // for use by Row:
530 |     Matrix(Index n1, Index n2, Index n3, T* p) : Matrix_base<T>(n1*n2*n3,p), d1(n1), d2(n2), d3(n3) 
531 |     {
532 |         // std::cerr << "construct 3D Matrix from data\n";
533 |     }
534 | 
535 | public:
536 | 
537 |     Matrix(Index n1, Index n2, Index n3) : Matrix_base<T>(n1*n2*n3), d1(n1), d2(n2), d3(n3) { }
538 | 
539 |     Matrix(Row<T,3>& a) : Matrix_base<T>(a.dim1()*a.dim2()*a.dim3(),a.p), d1(a.dim1()), d2(a.dim2()), d3(a.dim3())
540 |     { 
541 |         // std::cerr << "construct 3D Matrix from Row\n";
542 |     }
543 | 
544 |     // copy constructor: let the base do the copy:
545 |     Matrix(const Matrix& a) : Matrix_base<T>(a.size(),0), d1(a.d1), d2(a.d2), d3(a.d3)
546 |     {
547 |         // std::cerr << "copy ctor\n";
548 |         this->base_copy(a);
549 |     }
550 | 
551 |     template<int n1, int n2, int n3> 
552 |     Matrix(const T (&a)[n1][n2][n3]) : Matrix_base<T>(n1*n2), d1(n1), d2(n2), d3(n3)
553 |         // deduce "n1", "n2", "n3" (and "T"), Matrix_base allocates T[n1*n2*n3]
554 |     {
555 |         // std::cerr << "matrix ctor\n";
556 |         for (Index i = 0; i<n1; ++i)
557 |             for (Index j = 0; j<n2; ++j)
558 |                 for (Index k = 0; k<n3; ++k)
559 |                     this->elem[i*n2*n3+j*n3+k]=a[i][j][k];
560 |     }
561 | 
562 |     template<class F> Matrix(const Matrix& a, F f) : Matrix_base<T>(a.size()), d1(a.d1), d2(a.d2), d3(a.d3)
563 |         // construct a new Matrix with element's that are functions of a's elements:
564 |         // does not modify a unless f has been specifically programmed to modify its argument
565 |         // T f(const T&) would be a typical type for f
566 |     {
567 |         for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i]); 
568 |     }
569 | 
570 |     template<class F, class Arg> Matrix(const Matrix& a, F f, const Arg& t1) : Matrix_base<T>(a.size()), d1(a.d1), d2(a.d2), d3(a.d3)
571 |         // construct a new Matrix with element's that are functions of a's elements:
572 |         // does not modify a unless f has been specifically programmed to modify its argument
573 |         // T f(const T&, const Arg&) would be a typical type for f
574 |     {
575 |         for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i],t1); 
576 |     }
577 | 
578 |     Matrix& operator=(const Matrix& a)
579 |         // copy assignment: let the base do the copy
580 |     {
581 |         // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<< ")\n";
582 |         if (d1!=a.d1 || d2!=a.d2 || d3!=a.d3) error("length error in 2D =");
583 |         this->base_assign(a);
584 |         return *this;
585 |     }
586 | 
587 |     ~Matrix() { }
588 | 
589 |     Index dim1() const { return d1; }    // number of elements in a row
590 |     Index dim2() const { return d2; }    // number of elements in a column
591 |     Index dim3() const { return d3; }    // number of elements in a depth
592 | 
593 |     Matrix xfer()    // make an Matrix to move elements out of a scope
594 |     {
595 |         Matrix x(dim1(),dim2(),dim3(),this->data()); // make a descriptor
596 |         this->base_xfer(x);            // transfer (temporary) ownership to x
597 |         return x;
598 |     }
599 | 
600 |     void range_check(Index n1, Index n2, Index n3) const
601 |     {
602 |         // std::cerr << "range check: (" << d1 << "," << d2 << "): " << n1 << " " << n2 << "\n";
603 |         if (n1<0 || d1<=n1) error("3D range error: dimension 1");
604 |         if (n2<0 || d2<=n2) error("3D range error: dimension 2");
605 |         if (n3<0 || d3<=n3) error("3D range error: dimension 3");
606 |     }
607 | 
608 |     // subscripting:
609 |           T& operator()(Index n1, Index n2, Index n3)       { range_check(n1,n2,n3); return this->elem[d2*d3*n1+d3*n2+n3]; }; 
610 |     const T& operator()(Index n1, Index n2, Index n3) const { range_check(n1,n2,n3); return this->elem[d2*d3*n1+d3*n2+n3]; };
611 | 
612 |     // slicing (return a row):
613 |           Row<T,2> operator[](Index n)       { return row(n); }
614 |     const Row<T,2> operator[](Index n) const { return row(n); }
615 | 
616 |           Row<T,2> row(Index n)       { range_check(n,0,0); return Row<T,2>(d2,d3,&this->elem[n*d2*d3]); }
617 |     const Row<T,2> row(Index n) const { range_check(n,0,0); return Row<T,2>(d2,d3,&this->elem[n*d2*d3]); }
618 | 
619 |     Row<T,3> slice(Index n)
620 |         // rows [n:d1)
621 |     {
622 |         if (n<0) n=0;
623 |         else if(d1<n) n=d1;    // one beyond the end
624 |         return Row<T,3>(d1-n,d2,d3,this->elem+n*d2*d3);
625 |     }
626 | 
627 |     const Row<T,3> slice(Index n) const
628 |         // rows [n:d1)
629 |     {
630 |         if (n<0) n=0;
631 |         else if(d1<n) n=d1;    // one beyond the end
632 |         return Row<T,3>(d1-n,d2,d3,this->elem+n*d2*d3);
633 |     }
634 | 
635 |     Row<T,3> slice(Index n, Index m)
636 |         // the rows [n:m)
637 |     {
638 |         if (n<0) n=0;
639 |         if(d1<m) m=d1;    // one beyond the end
640 |         return Row<T,3>(m-n,d2,d3,this->elem+n*d2*d3);
641 | 
642 |     }
643 | 
644 |     const Row<T,3> slice(Index n, Index m) const
645 |         // the rows [n:sz)
646 |     {
647 |         if (n<0) n=0;
648 |         if(d1<m) m=d1;    // one beyond the end
649 |         return Row<T,3>(m-n,d2,d3,this->elem+n*d2*d3);
650 |     }
651 | 
652 |     // Column<T,2> column(Index n); // not (yet) implemented: requies strides and operations on columns
653 | 
654 |     // element-wise operations:
655 |     template<class F> Matrix& apply(F f)            { this->base_apply(f);   return *this; }
656 |     template<class F> Matrix& apply(F f,const T& c) { this->base_apply(f,c); return *this; }
657 | 
658 |     Matrix& operator=(const T& c)  { this->base_apply(Assign<T>(),c);       return *this; }
659 |                                                                             
660 |     Matrix& operator*=(const T& c) { this->base_apply(Mul_assign<T>(),c);   return *this; }
661 |     Matrix& operator/=(const T& c) { this->base_apply(Div_assign<T>(),c);   return *this; }
662 |     Matrix& operator%=(const T& c) { this->base_apply(Mod_assign<T>(),c);   return *this; }
663 |     Matrix& operator+=(const T& c) { this->base_apply(Add_assign<T>(),c);   return *this; }
664 |     Matrix& operator-=(const T& c) { this->base_apply(Minus_assign<T>(),c); return *this; }
665 | 
666 |     Matrix& operator&=(const T& c) { this->base_apply(And_assign<T>(),c);   return *this; }
667 |     Matrix& operator|=(const T& c) { this->base_apply(Or_assign<T>(),c);    return *this; }
668 |     Matrix& operator^=(const T& c) { this->base_apply(Xor_assign<T>(),c);   return *this; }
669 | 
670 |     Matrix operator!() { return xfer(Matrix(*this,Not<T>())); }
671 |     Matrix operator-() { return xfer(Matrix(*this,Unary_minus<T>())); }
672 |     Matrix operator~() { return xfer(Matrix(*this,Complement<T>()));  }
673 | 
674 |     template<class F> Matrix apply_new(F f) { return xfer(Matrix(*this,f)); }
675 |     
676 |     void swap_rows(Index i, Index j)
677 |         // swap_rows() uses a row's worth of memory for better run-time performance
678 |         // if you want pairwise swap, just write it yourself
679 |     {
680 |         if (i == j) return;
681 |         
682 |         Matrix<T,2> temp = (*this)[i];
683 |         (*this)[i] = (*this)[j];
684 |         (*this)[j] = temp;
685 |     }
686 | };
687 | 
688 | //-----------------------------------------------------------------------------
689 | 
690 | template<class T> Matrix<T> scale_and_add(const Matrix<T>& a, T c, const Matrix<T>& b)
691 |     //  Fortran "saxpy()" ("fma" for "fused multiply-add").
692 |     // will the copy constructor be called twice and defeat the xfer optimization?
693 | {
694 |     if (a.size() != b.size()) error("sizes wrong for scale_and_add()");
695 |     Matrix<T> res(a.size());
696 |     for (Index i = 0; i<a.size(); ++i) res[i] += a[i]*c+b[i];
697 |     return res.xfer();
698 | }
699 | 
700 | //-----------------------------------------------------------------------------
701 | 
702 | template<class T> T dot_product(const Matrix<T>&a , const Matrix<T>& b)
703 | {
704 |     if (a.size() != b.size()) error("sizes wrong for dot product");
705 |     T sum = 0;
706 |     for (Index i = 0; i<a.size(); ++i) sum += a[i]*b[i];
707 |     return sum;
708 | }
709 | 
710 | //-----------------------------------------------------------------------------
711 | 
712 | template<class T, int N> Matrix<T,N> xfer(Matrix<T,N>& a)
713 | {
714 |     return a.xfer();
715 | }
716 | 
717 | //-----------------------------------------------------------------------------
718 | 
719 | template<class F, class A>            A apply(F f, A x)        { A res(x,f);   return xfer(res); }
720 | template<class F, class Arg, class A> A apply(F f, A x, Arg a) { A res(x,f,a); return xfer(res); }
721 | 
722 | //-----------------------------------------------------------------------------
723 | 
724 | // The default values for T and D have been declared before.
725 | template<class T, int D> class Row {
726 |     // general version exists only to allow specializations
727 | private:
728 |         Row();
729 | };
730 | 
731 | //-----------------------------------------------------------------------------
732 | 
733 | template<class T> class Row<T,1> : public Matrix<T,1> {
734 | public:
735 |     Row(Index n, T* p) : Matrix<T,1>(n,p)
736 |     {
737 |     }
738 | 
739 |     Matrix<T,1>& operator=(const T& c) { this->base_apply(Assign<T>(),c); return *this; }
740 | 
741 |     Matrix<T,1>& operator=(const Matrix<T,1>& a)
742 |     {
743 |         return *static_cast<Matrix<T,1>*>(this)=a;
744 |     }
745 | };
746 | 
747 | //-----------------------------------------------------------------------------
748 | 
749 | template<class T> class Row<T,2> : public Matrix<T,2> {
750 | public:
751 |     Row(Index n1, Index n2, T* p) : Matrix<T,2>(n1,n2,p)
752 |     {
753 |     }
754 |         
755 |     Matrix<T,2>& operator=(const T& c) { this->base_apply(Assign<T>(),c); return *this; }
756 | 
757 |     Matrix<T,2>& operator=(const Matrix<T,2>& a)
758 |     {
759 |         return *static_cast<Matrix<T,2>*>(this)=a;
760 |     }
761 | };
762 | 
763 | //-----------------------------------------------------------------------------
764 | 
765 | template<class T> class Row<T,3> : public Matrix<T,3> {
766 | public:
767 |     Row(Index n1, Index n2, Index n3, T* p) : Matrix<T,3>(n1,n2,n3,p)
768 |     {
769 |     }
770 | 
771 |     Matrix<T,3>& operator=(const T& c) { this->base_apply(Assign<T>(),c); return *this; }
772 | 
773 |     Matrix<T,3>& operator=(const Matrix<T,3>& a)
774 |     {
775 |         return *static_cast<Matrix<T,3>*>(this)=a;
776 |     }
777 | };
778 | 
779 | //-----------------------------------------------------------------------------
780 | 
781 | template<class T, int N> Matrix<T,N-1> scale_and_add(const Matrix<T,N>& a, const Matrix<T,N-1> c, const Matrix<T,N-1>& b)
782 | {
783 |     Matrix<T> res(a.size());
784 |     if (a.size() != b.size()) error("sizes wrong for scale_and_add");
785 |     for (Index i = 0; i<a.size(); ++i) res[i] += a[i]*c+b[i];
786 |     return res.xfer();
787 | }
788 | 
789 | //-----------------------------------------------------------------------------
790 | 
791 | template<class T, int D> Matrix<T,D> operator*(const Matrix<T,D>& m, const T& c) { Matrix<T,D> r(m); return r*=c; }
792 | template<class T, int D> Matrix<T,D> operator/(const Matrix<T,D>& m, const T& c) { Matrix<T,D> r(m); return r/=c; }
793 | template<class T, int D> Matrix<T,D> operator%(const Matrix<T,D>& m, const T& c) { Matrix<T,D> r(m); return r%=c; }
794 | template<class T, int D> Matrix<T,D> operator+(const Matrix<T,D>& m, const T& c) { Matrix<T,D> r(m); return r+=c; }
795 | template<class T, int D> Matrix<T,D> operator-(const Matrix<T,D>& m, const T& c) { Matrix<T,D> r(m); return r-=c; }
796 | 
797 | template<class T, int D> Matrix<T,D> operator&(const Matrix<T,D>& m, const T& c) { Matrix<T,D> r(m); return r&=c; }
798 | template<class T, int D> Matrix<T,D> operator|(const Matrix<T,D>& m, const T& c) { Matrix<T,D> r(m); return r|=c; }
799 | template<class T, int D> Matrix<T,D> operator^(const Matrix<T,D>& m, const T& c) { Matrix<T,D> r(m); return r^=c; }
800 | 
801 | //-----------------------------------------------------------------------------
802 | 
803 | }
804 | #endif
805 | 


--------------------------------------------------------------------------------
/Matrix11.h:
--------------------------------------------------------------------------------
  1 | 
  2 | /*
  3 |     warning: this small multidimensional matrix library uses a few features
  4 |     not taught in ENGR112 and not explained in elementary textbooks
  5 | 
  6 | 	C++11 version
  7 | 
  8 |     (c) Bjarne Stroustrup, Texas A&M University. 
  9 | 
 10 |     Use as you like as long as you acknowledge the source.
 11 | */
 12 | 
 13 | #ifndef MATRIX_LIB
 14 | #define MATRIX_LIB
 15 | 
 16 | #include<string>
 17 | #include<algorithm>
 18 | //#include<iostream>
 19 | 
 20 | namespace Numeric_lib {
 21 | 
 22 | //-----------------------------------------------------------------------------
 23 | 
 24 | struct Matrix_error {
 25 |     std::string name;
 26 |     Matrix_error(const char* q) :name(q) { }
 27 |     Matrix_error(std::string n) :name(n) { }
 28 | };
 29 | 
 30 | //-----------------------------------------------------------------------------
 31 | 
 32 | inline void error(const char* p)
 33 | {
 34 |     throw Matrix_error(p);
 35 | }
 36 | 
 37 | //-----------------------------------------------------------------------------
 38 | 
 39 | typedef long Index;    // I still dislike unsigned
 40 | 
 41 | //-----------------------------------------------------------------------------
 42 | 
 43 | // The general Matrix template is simply a prop for its specializations:
 44 | template<class T = double, int D = 1> class Matrix {
 45 |     // multidimensional matrix class
 46 |     // ( ) does multidimensional subscripting
 47 |     // [ ] does C style "slicing": gives an N-1 dimensional matrix from an N dimensional one
 48 |     // row() is equivalent to [ ]
 49 |     // column() is not (yet) implemented because it requires strides.
 50 |     // = has copy semantics
 51 |     // ( ) and [ ] are range checked
 52 |     // slice() to give sub-ranges 
 53 | private:
 54 |     Matrix();    // this should never be compiled
 55 | //	template<class A> Matrix(A);
 56 | };
 57 | 
 58 | //-----------------------------------------------------------------------------
 59 | 
 60 | template<class T = double, int D = 1> class Row ;    // forward declaration
 61 | 
 62 | //-----------------------------------------------------------------------------
 63 | 
 64 | // function objects for various apply() operations:
 65 | 
 66 | template<class T> struct Assign {
 67 |     void operator()(T& a, const T& c) { a = c; }
 68 | };
 69 | 
 70 | template<class T> struct Add_assign {
 71 |     void operator()(T& a, const T& c) { a += c; }
 72 | };
 73 | template<class T> struct Mul_assign {
 74 |     void operator()(T& a, const T& c) { a *= c; }
 75 | };
 76 | template<class T> struct Minus_assign {
 77 |     void operator()(T& a, const T& c) { a -= c; }
 78 | };
 79 | template<class T> struct Div_assign {
 80 |     void operator()(T& a, const T& c) { a /= c; }
 81 | };
 82 | template<class T> struct Mod_assign {
 83 |     void operator()(T& a, const T& c) { a %= c; }
 84 | };
 85 | template<class T> struct Or_assign {
 86 |     void operator()(T& a, const T& c) { a |= c; }
 87 | };
 88 | template<class T> struct Xor_assign {
 89 |     void operator()(T& a, const T& c) { a ^= c; }
 90 | };
 91 | template<class T> struct And_assign {
 92 |     void operator()(T& a, const T& c) { a &= c; }
 93 | };
 94 | 
 95 | template<class T> struct Not_assign {
 96 |     void operator()(T& a) { a = !a; }
 97 | };
 98 | 
 99 | template<class T> struct Not {
100 |     T operator()(T& a) { return !a; }
101 | };
102 | 
103 | template<class T> struct Unary_minus {
104 |     T operator()(T& a) { return -a; }
105 | };
106 | 
107 | template<class T> struct Complement {
108 |     T operator()(T& a) { return ~a; }
109 | };
110 | 
111 | //-----------------------------------------------------------------------------
112 | 
113 | // Matrix_base represents the common part of the Matrix classes:
114 | template<class T> class Matrix_base {
115 |     // matrixs store their memory (elements) in Matrix_base and have copy semantics
116 |     // Matrix_base does element-wise operations
117 | protected:
118 |     T* elem;    // vector? no: we couldn't easily provide a vector for a slice
119 |     const Index sz;    
120 |     mutable bool owns;
121 |     mutable bool xfer;
122 | public:
123 |     Matrix_base(Index n) :elem(new T[n]()), sz(n), owns(true), xfer(false)
124 |         // matrix of n elements (default initialized)
125 |     {
126 |         // std::cerr << "new[" << n << "]->" << elem << "\n";
127 |     }
128 | 
129 |     Matrix_base(Index n, T* p) :elem(p), sz(n), owns(false), xfer(false)
130 |         // descriptor for matrix of n elements owned by someone else
131 |     {
132 |     }
133 | 
134 |     ~Matrix_base()
135 |     {
136 |         if (owns) {
137 |             // std::cerr << "delete[" << sz << "] " << elem << "\n";
138 |             delete[]elem;
139 |         }
140 |     }
141 | 
142 |     // if necessay, we can get to the raw matrix:
143 |           T* data()       { return elem; }
144 |     const T* data() const { return elem; }
145 |     Index    size() const { return sz; }
146 | 
147 |     void copy_elements(const Matrix_base& a)
148 |     {
149 |         if (sz!=a.sz) error("copy_elements()");
150 |         for (Index i=0; i<sz; ++i) elem[i] = a.elem[i];
151 |     }
152 | 
153 |     void base_assign(const Matrix_base& a) { copy_elements(a); }
154 | 
155 |     void base_copy(const Matrix_base& a)
156 |     {
157 |         if (a.xfer) {          // a is just about to be deleted
158 |                                // so we can transfer ownership rather than copy
159 |             // std::cerr << "xfer @" << a.elem << " [" << a.sz << "]\n";
160 |             elem = a.elem;
161 |             a.xfer = false;    // note: modifies source
162 |             a.owns = false;
163 |         }
164 |         else {
165 |             elem = new T[a.sz];
166 |             // std::cerr << "base copy @" << a.elem << " [" << a.sz << "]\n";
167 |             copy_elements(a);
168 |         }
169 |         owns = true;
170 |         xfer = false;
171 |     }
172 | 
173 |     // to get the elements of a local matrix out of a function without copying:
174 |     void base_xfer(Matrix_base& x)
175 |     {
176 |         if (owns==false) error("cannot xfer() non-owner");
177 |         owns = false;     // now the elements are safe from deletion by original owner
178 |         x.xfer = true;    // target asserts temporary ownership
179 |         x.owns = true;
180 |     }
181 | 
182 |     template<class F> void base_apply(F f) { for (Index i = 0; i<size(); ++i) f(elem[i]); }
183 |     template<class F> void base_apply(F f, const T& c) { for (Index i = 0; i<size(); ++i) f(elem[i],c); }
184 | private:
185 |     void operator=(const Matrix_base&);    // no ordinary copy of bases
186 |     Matrix_base(const Matrix_base&);
187 | };
188 | 
189 | //-----------------------------------------------------------------------------
190 | 
191 | template<class T> class Matrix<T,1> : public Matrix_base<T> {
192 |     const Index d1;
193 | 
194 | protected:
195 |     // for use by Row:
196 |     Matrix(Index n1, T* p) : Matrix_base<T>(n1,p), d1(n1)
197 |     {
198 |         // std::cerr << "construct 1D Matrix from data\n";
199 |     }
200 | 
201 | public:
202 | 
203 |     Matrix(Index n1) : Matrix_base<T>(n1), d1(n1) { }
204 | 
205 |     Matrix(Row<T,1>& a) : Matrix_base<T>(a.dim1(),a.p), d1(a.dim1()) 
206 |     { 
207 |         // std::cerr << "construct 1D Matrix from Row\n";
208 |     }
209 | 
210 |     // copy constructor: let the base do the copy:
211 |     Matrix(const Matrix& a) : Matrix_base<T>(a.size(),0), d1(a.d1)
212 |     {
213 |         // std::cerr << "copy ctor\n";
214 |         this->base_copy(a);
215 |     }
216 | 
217 |     template<int n> 
218 |     Matrix(const T (&a)[n]) : Matrix_base<T>(n), d1(n)
219 |         // deduce "n" (and "T"), Matrix_base allocates T[n]
220 |     {
221 |         // std::cerr << "matrix ctor\n";
222 |         for (Index i = 0; i<n; ++i) this->elem[i]=a[i];
223 |     }
224 | 
225 |     Matrix(const T* p, Index n) : Matrix_base<T>(n), d1(n)
226 |         // Matrix_base allocates T[n]
227 |     {
228 |         // std::cerr << "matrix ctor\n";
229 |         for (Index i = 0; i<n; ++i) this->elem[i]=p[i];
230 |     }
231 | 
232 |     template<class F> Matrix(const Matrix& a, F f) : Matrix_base<T>(a.size()), d1(a.d1)
233 |         // construct a new Matrix with element's that are functions of a's elements:
234 |         // does not modify a unless f has been specifically programmed to modify its argument
235 |         // T f(const T&) would be a typical type for f
236 |     {
237 |         for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i]); 
238 |     }
239 | 
240 |     template<class F, class Arg> Matrix(const Matrix& a, F f, const Arg& t1) : Matrix_base<T>(a.size()), d1(a.d1)
241 |         // construct a new Matrix with element's that are functions of a's elements:
242 |         // does not modify a unless f has been specifically programmed to modify its argument
243 |         // T f(const T&, const Arg&) would be a typical type for f
244 |     {
245 |         for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i],t1); 
246 |     }
247 | 
248 |     Matrix& operator=(const Matrix& a)
249 |         // copy assignment: let the base do the copy
250 |     {
251 |         // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<< ")\n";
252 |         if (d1!=a.d1) error("length error in 1D=");
253 |         this->base_assign(a);
254 |         return *this;
255 |     }
256 | 
257 |     ~Matrix() { }
258 | 
259 |     Index dim1() const { return d1; }    // number of elements in a row
260 | 
261 |     Matrix xfer()    // make an Matrix to move elements out of a scope
262 |     {
263 |         Matrix x(dim1(),this->data()); // make a descriptor
264 |         this->base_xfer(x);                  // transfer (temporary) ownership to x
265 |         return x;
266 |     }
267 | 
268 |     void range_check(Index n1) const
269 |     {
270 |         // std::cerr << "range check: (" << d1 << "): " << n1 << "\n"; 
271 |         if (n1<0 || d1<=n1) error("1D range error: dimension 1");
272 |     }
273 | 
274 |     // subscripting:
275 |           T& operator()(Index n1)       { range_check(n1); return this->elem[n1]; }
276 |     const T& operator()(Index n1) const { range_check(n1); return this->elem[n1]; }
277 | 
278 |     // slicing (the same as subscripting for 1D matrixs):
279 |           T& operator[](Index n)       { return row(n); }
280 |     const T& operator[](Index n) const { return row(n); }
281 | 
282 |           T& row(Index n)       { range_check(n); return this->elem[n]; }
283 |     const T& row(Index n) const { range_check(n); return this->elem[n]; }
284 | 
285 |     Row<T,1> slice(Index n)
286 |         // the last elements from a[n] onwards
287 |     {
288 |         if (n<0) n=0;
289 |         else if(d1<n) n=d1;// one beyond the end
290 |         return Row<T,1>(d1-n,this->elem+n);
291 |     }
292 | 
293 |     const Row<T,1> slice(Index n) const
294 |         // the last elements from a[n] onwards
295 |     {
296 |         if (n<0) n=0;
297 |         else if(d1<n) n=d1;// one beyond the end
298 |         return Row<T,1>(d1-n,this->elem+n);
299 |     }
300 | 
301 |     Row<T,1> slice(Index n, Index m)
302 |         // m elements starting with a[n]
303 |     {
304 |         if (n<0) n=0;
305 |         else if(d1<n) n=d1;    // one beyond the end
306 |         if (m<0) m = 0;
307 |         else if (d1<n+m) m=d1-n;
308 |         return Row<T,1>(m,this->elem+n);
309 |     }
310 | 
311 |     const Row<T,1> slice(Index n, Index m) const
312 |         // m elements starting with a[n]
313 |     {
314 |         if (n<0) n=0;
315 |         else if(d1<n) n=d1;    // one beyond the end
316 |         if (m<0) m = 0;
317 |         else if (d1<n+m) m=d1-n;
318 |         return Row<T,1>(m,this->elem+n);
319 |     }
320 | 
321 |     // element-wise operations:
322 |     template<class F> Matrix& apply(F f) { this->base_apply(f); return *this; }
323 |     template<class F> Matrix& apply(F f,const T& c) { this->base_apply(f,c); return *this; }
324 | 
325 |     Matrix& operator=(const T& c)  { this->base_apply(Assign<T>(),c);       return *this; }
326 | 
327 |     Matrix& operator*=(const T& c) { this->base_apply(Mul_assign<T>(),c);   return *this; }
328 |     Matrix& operator/=(const T& c) { this->base_apply(Div_assign<T>(),c);   return *this; }
329 |     Matrix& operator%=(const T& c) { this->base_apply(Mod_assign<T>(),c);   return *this; }
330 |     Matrix& operator+=(const T& c) { this->base_apply(Add_assign<T>(),c);   return *this; }
331 |     Matrix& operator-=(const T& c) { this->base_apply(Minus_assign<T>(),c); return *this; }
332 | 
333 |     Matrix& operator&=(const T& c) { this->base_apply(And_assign<T>(),c);   return *this; }
334 |     Matrix& operator|=(const T& c) { this->base_apply(Or_assign<T>(),c);    return *this; }
335 |     Matrix& operator^=(const T& c) { this->base_apply(Xor_assign<T>(),c);   return *this; }
336 | 
337 |     Matrix operator!() { return xfer(Matrix(*this,Not<T>())); }
338 |     Matrix operator-() { return xfer(Matrix(*this,Unary_minus<T>())); }
339 |     Matrix operator~() { return xfer(Matrix(*this,Complement<T>()));  }
340 | 
341 |     template<class F> Matrix apply_new(F f) { return xfer(Matrix(*this,f)); }
342 |     
343 |     void swap_rows(Index i, Index j)
344 |         // swap_rows() uses a row's worth of memory for better run-time performance
345 |         // if you want pairwise swap, just write it yourself
346 |     {
347 |         if (i == j) return;
348 |     /*
349 |         Matrix<T,1> temp = (*this)[i];
350 |         (*this)[i] = (*this)[j];
351 |         (*this)[j] = temp;
352 |     */
353 |         Index max = (*this)[i].size();
354 |         for (Index ii=0; ii<max; ++ii) std::swap((*this)(i,ii),(*this)(j,ii));
355 |     }
356 | };
357 | 
358 | //-----------------------------------------------------------------------------
359 | 
360 | template<class T> class Matrix<T,2> : public Matrix_base<T> {
361 |     const Index d1;
362 |     const Index d2;
363 | 
364 | protected:
365 |     // for use by Row:
366 |     Matrix(Index n1, Index n2, T* p) : Matrix_base<T>(n1*n2,p), d1(n1), d2(n2) 
367 |     {
368 |        //  std::cerr << "construct 3D Matrix from data\n";
369 |     }
370 | 
371 | public:
372 | 
373 |     Matrix(Index n1, Index n2) : Matrix_base<T>(n1*n2), d1(n1), d2(n2) { }
374 | 
375 |     Matrix(Row<T,2>& a) : Matrix_base<T>(a.dim1()*a.dim2(),a.p), d1(a.dim1()), d2(a.dim2())
376 |     { 
377 |        // std::cerr << "construct 2D Matrix from Row\n";
378 |     }
379 | 
380 |     // copy constructor: let the base do the copy:
381 |     Matrix(const Matrix& a) : Matrix_base<T>(a.size(),0), d1(a.d1), d2(a.d2)
382 |     {
383 |         // std::cerr << "copy ctor\n";
384 |         this->base_copy(a);
385 |     }
386 | 
387 |     template<int n1, int n2> 
388 |     Matrix(const T (&a)[n1][n2]) : Matrix_base<T>(n1*n2), d1(n1), d2(n2)
389 |         // deduce "n1", "n2" (and "T"), Matrix_base allocates T[n1*n2]
390 |     {
391 |         // std::cerr << "matrix ctor (" << n1 << "," << n2 << ")\n";
392 |         for (Index i = 0; i<n1; ++i)
393 |             for (Index j = 0; j<n2; ++j) this->elem[i*n2+j]=a[i][j];
394 |     }
395 | 
396 |     template<class F> Matrix(const Matrix& a, F f) : Matrix_base<T>(a.size()), d1(a.d1), d2(a.d2)
397 |         // construct a new Matrix with element's that are functions of a's elements:
398 |         // does not modify a unless f has been specifically programmed to modify its argument
399 |         // T f(const T&) would be a typical type for f
400 |     {
401 |         for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i]); 
402 |     }
403 | 
404 |     template<class F, class Arg> Matrix(const Matrix& a, F f, const Arg& t1) : Matrix_base<T>(a.size()), d1(a.d1), d2(a.d2)
405 |         // construct a new Matrix with element's that are functions of a's elements:
406 |         // does not modify a unless f has been specifically programmed to modify its argument
407 |         // T f(const T&, const Arg&) would be a typical type for f
408 |     {
409 |         for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i],t1); 
410 |     }
411 | 
412 |     Matrix& operator=(const Matrix& a)
413 |         // copy assignment: let the base do the copy
414 |     {
415 |         // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<< ")\n";
416 |         if (d1!=a.d1 || d2!=a.d2) error("length error in 2D =");
417 |         this->base_assign(a);
418 |         return *this;
419 |     }
420 | 
421 |     ~Matrix() { }
422 |     
423 |     Index dim1() const { return d1; }    // number of elements in a row
424 |     Index dim2() const { return d2; }    // number of elements in a column
425 | 
426 |     Matrix xfer()    // make an Matrix to move elements out of a scope
427 |     {
428 |         Matrix x(dim1(),dim2(),this->data()); // make a descriptor
429 |         this->base_xfer(x);            // transfer (temporary) ownership to x
430 |         return x;
431 |     }
432 | 
433 |     void range_check(Index n1, Index n2) const
434 |     {
435 |         // std::cerr << "range check: (" << d1 << "," << d2 << "): " << n1 << " " << n2 << "\n";
436 |         if (n1<0 || d1<=n1) error("2D range error: dimension 1");
437 |         if (n2<0 || d2<=n2) error("2D range error: dimension 2");
438 |     }
439 | 
440 |     // subscripting:
441 |           T& operator()(Index n1, Index n2)       { range_check(n1,n2); return this->elem[n1*d2+n2]; }
442 |     const T& operator()(Index n1, Index n2) const { range_check(n1,n2); return this->elem[n1*d2+n2]; }
443 | 
444 |     // slicing (return a row):
445 |           Row<T,1> operator[](Index n)       { return row(n); }
446 |     const Row<T,1> operator[](Index n) const { return row(n); }
447 | 
448 |           Row<T,1> row(Index n)       { range_check(n,0); return Row<T,1>(d2,&this->elem[n*d2]); }
449 |     const Row<T,1> row(Index n) const { range_check(n,0); return Row<T,1>(d2,&this->elem[n*d2]); }
450 | 
451 |     Row<T,2> slice(Index n)
452 |         // rows [n:d1)
453 |     {
454 |         if (n<0) n=0;
455 |         else if(d1<n) n=d1;    // one beyond the end
456 |         return Row<T,2>(d1-n,d2,this->elem+n*d2);
457 |     }
458 | 
459 |     const Row<T,2> slice(Index n) const
460 |         // rows [n:d1)
461 |     {
462 |         if (n<0) n=0;
463 |         else if(d1<n) n=d1;    // one beyond the end
464 |         return Row<T,2>(d1-n,d2,this->elem+n*d2);
465 |     }
466 | 
467 |     Row<T,2> slice(Index n, Index m)
468 |         // the rows [n:m)
469 |     {
470 |         if (n<0) n=0;
471 |         if(d1<m) m=d1;    // one beyond the end
472 |         return Row<T,2>(m-n,d2,this->elem+n*d2);
473 | 
474 |     }
475 | 
476 |     const Row<T,2> slice(Index n, Index m) const
477 |         // the rows [n:sz)
478 |     {
479 |         if (n<0) n=0;
480 |         if(d1<m) m=d1;    // one beyond the end
481 |         return Row<T,2>(m-n,d2,this->elem+n*d2);
482 |     }
483 | 
484 |     // Column<T,1> column(Index n); // not (yet) implemented: requies strides and operations on columns
485 | 
486 |     // element-wise operations:
487 |     template<class F> Matrix& apply(F f)            { this->base_apply(f);   return *this; }
488 |     template<class F> Matrix& apply(F f,const T& c) { this->base_apply(f,c); return *this; }
489 | 
490 |     Matrix& operator=(const T& c)  { this->base_apply(Assign<T>(),c);       return *this; }
491 | 
492 |     Matrix& operator*=(const T& c) { this->base_apply(Mul_assign<T>(),c);   return *this; }
493 |     Matrix& operator/=(const T& c) { this->base_apply(Div_assign<T>(),c);   return *this; }
494 |     Matrix& operator%=(const T& c) { this->base_apply(Mod_assign<T>(),c);   return *this; }
495 |     Matrix& operator+=(const T& c) { this->base_apply(Add_assign<T>(),c);   return *this; }
496 |     Matrix& operator-=(const T& c) { this->base_apply(Minus_assign<T>(),c); return *this; }
497 | 
498 |     Matrix& operator&=(const T& c) { this->base_apply(And_assign<T>(),c);   return *this; }
499 |     Matrix& operator|=(const T& c) { this->base_apply(Or_assign<T>(),c);    return *this; }
500 |     Matrix& operator^=(const T& c) { this->base_apply(Xor_assign<T>(),c);   return *this; }
501 | 
502 |     Matrix operator!() { return xfer(Matrix(*this,Not<T>())); }
503 |     Matrix operator-() { return xfer(Matrix(*this,Unary_minus<T>())); }
504 |     Matrix operator~() { return xfer(Matrix(*this,Complement<T>()));  }
505 | 
506 |     template<class F> Matrix apply_new(F f) { return xfer(Matrix(*this,f)); }
507 |     
508 |     void swap_rows(Index i, Index j)
509 |         // swap_rows() uses a row's worth of memory for better run-time performance
510 |         // if you want pairwise swap, just write it yourself
511 |     {
512 |         if (i == j) return;
513 |     /*
514 |         Matrix<T,1> temp = (*this)[i];
515 |         (*this)[i] = (*this)[j];
516 |         (*this)[j] = temp;
517 |     */
518 |         Index max = (*this)[i].size();
519 |         for (Index ii=0; ii<max; ++ii) std::swap((*this)(i,ii),(*this)(j,ii));
520 |     }
521 | };
522 | 
523 | //-----------------------------------------------------------------------------
524 | 
525 | template<class T> class Matrix<T,3> : public Matrix_base<T> {
526 |     const Index d1;
527 |     const Index d2;
528 |     const Index d3;
529 | 
530 | protected:
531 |     // for use by Row:
532 |     Matrix(Index n1, Index n2, Index n3, T* p) : Matrix_base<T>(n1*n2*n3,p), d1(n1), d2(n2), d3(n3) 
533 |     {
534 |         // std::cerr << "construct 3D Matrix from data\n";
535 |     }
536 | 
537 | public:
538 | 
539 |     Matrix(Index n1, Index n2, Index n3) : Matrix_base<T>(n1*n2*n3), d1(n1), d2(n2), d3(n3) { }
540 | 
541 |     Matrix(Row<T,3>& a) : Matrix_base<T>(a.dim1()*a.dim2()*a.dim3(),a.p), d1(a.dim1()), d2(a.dim2()), d3(a.dim3())
542 |     { 
543 |         // std::cerr << "construct 3D Matrix from Row\n";
544 |     }
545 | 
546 |     // copy constructor: let the base do the copy:
547 |     Matrix(const Matrix& a) : Matrix_base<T>(a.size(),0), d1(a.d1), d2(a.d2), d3(a.d3)
548 |     {
549 |         // std::cerr << "copy ctor\n";
550 |         this->base_copy(a);
551 |     }
552 | 
553 |     template<int n1, int n2, int n3> 
554 |     Matrix(const T (&a)[n1][n2][n3]) : Matrix_base<T>(n1*n2), d1(n1), d2(n2), d3(n3)
555 |         // deduce "n1", "n2", "n3" (and "T"), Matrix_base allocates T[n1*n2*n3]
556 |     {
557 |         // std::cerr << "matrix ctor\n";
558 |         for (Index i = 0; i<n1; ++i)
559 |             for (Index j = 0; j<n2; ++j)
560 |                 for (Index k = 0; k<n3; ++k)
561 |                     this->elem[i*n2*n3+j*n3+k]=a[i][j][k];
562 |     }
563 | 
564 |     template<class F> Matrix(const Matrix& a, F f) : Matrix_base<T>(a.size()), d1(a.d1), d2(a.d2), d3(a.d3)
565 |         // construct a new Matrix with element's that are functions of a's elements:
566 |         // does not modify a unless f has been specifically programmed to modify its argument
567 |         // T f(const T&) would be a typical type for f
568 |     {
569 |         for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i]); 
570 |     }
571 | 
572 |     template<class F, class Arg> Matrix(const Matrix& a, F f, const Arg& t1) : Matrix_base<T>(a.size()), d1(a.d1), d2(a.d2), d3(a.d3)
573 |         // construct a new Matrix with element's that are functions of a's elements:
574 |         // does not modify a unless f has been specifically programmed to modify its argument
575 |         // T f(const T&, const Arg&) would be a typical type for f
576 |     {
577 |         for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i],t1); 
578 |     }
579 | 
580 |     Matrix& operator=(const Matrix& a)
581 |         // copy assignment: let the base do the copy
582 |     {
583 |         // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<< ")\n";
584 |         if (d1!=a.d1 || d2!=a.d2 || d3!=a.d3) error("length error in 2D =");
585 |         this->base_assign(a);
586 |         return *this;
587 |     }
588 | 
589 |     ~Matrix() { }
590 | 
591 |     Index dim1() const { return d1; }    // number of elements in a row
592 |     Index dim2() const { return d2; }    // number of elements in a column
593 |     Index dim3() const { return d3; }    // number of elements in a depth
594 | 
595 |     Matrix xfer()    // make an Matrix to move elements out of a scope
596 |     {
597 |         Matrix x(dim1(),dim2(),dim3(),this->data()); // make a descriptor
598 |         this->base_xfer(x);            // transfer (temporary) ownership to x
599 |         return x;
600 |     }
601 | 
602 |     void range_check(Index n1, Index n2, Index n3) const
603 |     {
604 |         // std::cerr << "range check: (" << d1 << "," << d2 << "): " << n1 << " " << n2 << "\n";
605 |         if (n1<0 || d1<=n1) error("3D range error: dimension 1");
606 |         if (n2<0 || d2<=n2) error("3D range error: dimension 2");
607 |         if (n3<0 || d3<=n3) error("3D range error: dimension 3");
608 |     }
609 | 
610 |     // subscripting:
611 |           T& operator()(Index n1, Index n2, Index n3)       { range_check(n1,n2,n3); return this->elem[d2*d3*n1+d3*n2+n3]; }; 
612 |     const T& operator()(Index n1, Index n2, Index n3) const { range_check(n1,n2,n3); return this->elem[d2*d3*n1+d3*n2+n3]; };
613 | 
614 |     // slicing (return a row):
615 |           Row<T,2> operator[](Index n)       { return row(n); }
616 |     const Row<T,2> operator[](Index n) const { return row(n); }
617 | 
618 |           Row<T,2> row(Index n)       { range_check(n,0,0); return Row<T,2>(d2,d3,&this->elem[n*d2*d3]); }
619 |     const Row<T,2> row(Index n) const { range_check(n,0,0); return Row<T,2>(d2,d3,&this->elem[n*d2*d3]); }
620 | 
621 |     Row<T,3> slice(Index n)
622 |         // rows [n:d1)
623 |     {
624 |         if (n<0) n=0;
625 |         else if(d1<n) n=d1;    // one beyond the end
626 |         return Row<T,3>(d1-n,d2,d3,this->elem+n*d2*d3);
627 |     }
628 | 
629 |     const Row<T,3> slice(Index n) const
630 |         // rows [n:d1)
631 |     {
632 |         if (n<0) n=0;
633 |         else if(d1<n) n=d1;    // one beyond the end
634 |         return Row<T,3>(d1-n,d2,d3,this->elem+n*d2*d3);
635 |     }
636 | 
637 |     Row<T,3> slice(Index n, Index m)
638 |         // the rows [n:m)
639 |     {
640 |         if (n<0) n=0;
641 |         if(d1<m) m=d1;    // one beyond the end
642 |         return Row<T,3>(m-n,d2,d3,this->elem+n*d2*d3);
643 | 
644 |     }
645 | 
646 |     const Row<T,3> slice(Index n, Index m) const
647 |         // the rows [n:sz)
648 |     {
649 |         if (n<0) n=0;
650 |         if(d1<m) m=d1;    // one beyond the end
651 |         return Row<T,3>(m-n,d2,d3,this->elem+n*d2*d3);
652 |     }
653 | 
654 |     // Column<T,2> column(Index n); // not (yet) implemented: requies strides and operations on columns
655 | 
656 |     // element-wise operations:
657 |     template<class F> Matrix& apply(F f)            { this->base_apply(f);   return *this; }
658 |     template<class F> Matrix& apply(F f,const T& c) { this->base_apply(f,c); return *this; }
659 | 
660 |     Matrix& operator=(const T& c)  { this->base_apply(Assign<T>(),c);       return *this; }
661 |                                                                             
662 |     Matrix& operator*=(const T& c) { this->base_apply(Mul_assign<T>(),c);   return *this; }
663 |     Matrix& operator/=(const T& c) { this->base_apply(Div_assign<T>(),c);   return *this; }
664 |     Matrix& operator%=(const T& c) { this->base_apply(Mod_assign<T>(),c);   return *this; }
665 |     Matrix& operator+=(const T& c) { this->base_apply(Add_assign<T>(),c);   return *this; }
666 |     Matrix& operator-=(const T& c) { this->base_apply(Minus_assign<T>(),c); return *this; }
667 | 
668 |     Matrix& operator&=(const T& c) { this->base_apply(And_assign<T>(),c);   return *this; }
669 |     Matrix& operator|=(const T& c) { this->base_apply(Or_assign<T>(),c);    return *this; }
670 |     Matrix& operator^=(const T& c) { this->base_apply(Xor_assign<T>(),c);   return *this; }
671 | 
672 |     Matrix operator!() { return xfer(Matrix(*this,Not<T>())); }
673 |     Matrix operator-() { return xfer(Matrix(*this,Unary_minus<T>())); }
674 |     Matrix operator~() { return xfer(Matrix(*this,Complement<T>()));  }
675 | 
676 |     template<class F> Matrix apply_new(F f) { return xfer(Matrix(*this,f)); }
677 |     
678 |     void swap_rows(Index i, Index j)
679 |         // swap_rows() uses a row's worth of memory for better run-time performance
680 |         // if you want pairwise swap, just write it yourself
681 |     {
682 |         if (i == j) return;
683 |         
684 |         Matrix<T,2> temp = (*this)[i];
685 |         (*this)[i] = (*this)[j];
686 |         (*this)[j] = temp;
687 |     }
688 | };
689 | 
690 | //-----------------------------------------------------------------------------
691 | 
692 | template<class T> Matrix<T> scale_and_add(const Matrix<T>& a, T c, const Matrix<T>& b)
693 |     //  Fortran "saxpy()" ("fma" for "fused multiply-add").
694 |     // will the copy constructor be called twice and defeat the xfer optimization?
695 | {
696 |     if (a.size() != b.size()) error("sizes wrong for scale_and_add()");
697 |     Matrix<T> res(a.size());
698 |     for (Index i = 0; i<a.size(); ++i) res[i] += a[i]*c+b[i];
699 |     return res.xfer();
700 | }
701 | 
702 | //-----------------------------------------------------------------------------
703 | 
704 | template<class T> T dot_product(const Matrix<T>&a , const Matrix<T>& b)
705 | {
706 |     if (a.size() != b.size()) error("sizes wrong for dot product");
707 |     T sum = 0;
708 |     for (Index i = 0; i<a.size(); ++i) sum += a[i]*b[i];
709 |     return sum;
710 | }
711 | 
712 | //-----------------------------------------------------------------------------
713 | 
714 | template<class T, int N> Matrix<T,N> xfer(Matrix<T,N>& a)
715 | {
716 |     return a.xfer();
717 | }
718 | 
719 | //-----------------------------------------------------------------------------
720 | 
721 | template<class F, class A>            A apply(F f, A x)        { A res(x,f);   return xfer(res); }
722 | template<class F, class Arg, class A> A apply(F f, A x, Arg a) { A res(x,f,a); return xfer(res); }
723 | 
724 | //-----------------------------------------------------------------------------
725 | 
726 | // The default values for T and D have been declared before.
727 | template<class T, int D> class Row {
728 |     // general version exists only to allow specializations
729 | private:
730 |         Row();
731 | };
732 | 
733 | //-----------------------------------------------------------------------------
734 | 
735 | template<class T> class Row<T,1> : public Matrix<T,1> {
736 | public:
737 |     Row(Index n, T* p) : Matrix<T,1>(n,p)
738 |     {
739 |     }
740 | 
741 |     Matrix<T,1>& operator=(const T& c) { this->base_apply(Assign<T>(),c); return *this; }
742 | 
743 |     Matrix<T,1>& operator=(const Matrix<T,1>& a)
744 |     {
745 |         return *static_cast<Matrix<T,1>*>(this)=a;
746 |     }
747 | };
748 | 
749 | //-----------------------------------------------------------------------------
750 | 
751 | template<class T> class Row<T,2> : public Matrix<T,2> {
752 | public:
753 |     Row(Index n1, Index n2, T* p) : Matrix<T,2>(n1,n2,p)
754 |     {
755 |     }
756 |         
757 |     Matrix<T,2>& operator=(const T& c) { this->base_apply(Assign<T>(),c); return *this; }
758 | 
759 |     Matrix<T,2>& operator=(const Matrix<T,2>& a)
760 |     {
761 |         return *static_cast<Matrix<T,2>*>(this)=a;
762 |     }
763 | };
764 | 
765 | //-----------------------------------------------------------------------------
766 | 
767 | template<class T> class Row<T,3> : public Matrix<T,3> {
768 | public:
769 |     Row(Index n1, Index n2, Index n3, T* p) : Matrix<T,3>(n1,n2,n3,p)
770 |     {
771 |     }
772 | 
773 |     Matrix<T,3>& operator=(const T& c) { this->base_apply(Assign<T>(),c); return *this; }
774 | 
775 |     Matrix<T,3>& operator=(const Matrix<T,3>& a)
776 |     {
777 |         return *static_cast<Matrix<T,3>*>(this)=a;
778 |     }
779 | };
780 | 
781 | //-----------------------------------------------------------------------------
782 | 
783 | template<class T, int N> Matrix<T,N-1> scale_and_add(const Matrix<T,N>& a, const Matrix<T,N-1> c, const Matrix<T,N-1>& b)
784 | {
785 |     Matrix<T> res(a.size());
786 |     if (a.size() != b.size()) error("sizes wrong for scale_and_add");
787 |     for (Index i = 0; i<a.size(); ++i) res[i] += a[i]*c+b[i];
788 |     return res.xfer();
789 | }
790 | 
791 | //-----------------------------------------------------------------------------
792 | 
793 | template<class T, int D> Matrix<T,D> operator*(const Matrix<T,D>& m, const T& c) { Matrix<T,D> r(m); return r*=c; }
794 | template<class T, int D> Matrix<T,D> operator/(const Matrix<T,D>& m, const T& c) { Matrix<T,D> r(m); return r/=c; }
795 | template<class T, int D> Matrix<T,D> operator%(const Matrix<T,D>& m, const T& c) { Matrix<T,D> r(m); return r%=c; }
796 | template<class T, int D> Matrix<T,D> operator+(const Matrix<T,D>& m, const T& c) { Matrix<T,D> r(m); return r+=c; }
797 | template<class T, int D> Matrix<T,D> operator-(const Matrix<T,D>& m, const T& c) { Matrix<T,D> r(m); return r-=c; }
798 | 
799 | template<class T, int D> Matrix<T,D> operator&(const Matrix<T,D>& m, const T& c) { Matrix<T,D> r(m); return r&=c; }
800 | template<class T, int D> Matrix<T,D> operator|(const Matrix<T,D>& m, const T& c) { Matrix<T,D> r(m); return r|=c; }
801 | template<class T, int D> Matrix<T,D> operator^(const Matrix<T,D>& m, const T& c) { Matrix<T,D> r(m); return r^=c; }
802 | 
803 | //-----------------------------------------------------------------------------
804 | 
805 | }
806 | #endif
807 | 


--------------------------------------------------------------------------------
/MatrixIO.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <iostream>
 3 | #include "Matrix.h"
 4 | 
 5 | namespace Numeric_lib {
 6 | 
 7 | //-----------------------------------------------------------------------------
 8 | 
 9 | template<class T> std::ostream& operator<<(std::ostream& os, const Matrix<T>& v)
10 | {
11 |     os << '{';
12 | 
13 |     for (Index i = 0; i<v.dim1(); ++i) {
14 |         os << "  ";
15 |         os << v(i);
16 |     }
17 | 
18 |     os << '}';
19 |     return os;
20 | }
21 | 
22 | //-----------------------------------------------------------------------------
23 | 
24 | template<class T> std::ostream& operator<<(std::ostream& os, const Matrix<T,2>& m)
25 | {
26 |     os << "{\n";
27 | 
28 |     for (Index i = 0; i<m.dim1(); ++i)
29 |         os << m[i] << '\n';
30 | 
31 |     os << '}';
32 |     return os;
33 | }
34 | 
35 | //-----------------------------------------------------------------------------
36 | 
37 | template<class T> std::istream& operator>>(std::istream& is, Matrix<T>& v)
38 | {
39 |     char ch;
40 |     is >> ch;
41 | 
42 |     if (ch!='{') error("'{' missing in Matrix<T,1> input");
43 | 
44 |     for (Index i = 0; i<v.dim1(); ++i)
45 |         is >> v(i);
46 | 
47 |     is >> ch;
48 | 
49 |     if (ch!='}') error("'}' missing in Matrix<T,1> input");
50 |   
51 |     return is;
52 | }
53 | 
54 | //-----------------------------------------------------------------------------
55 | 
56 | template<class T> std::istream& operator>>(std::istream& is, Matrix<T,2>& m)
57 | {
58 |     char ch;
59 |     is >> ch;
60 | 
61 |     if (ch!='{') error("'{' missing in Matrix<T,2> input");
62 | 
63 |     for (Index i = 0; i<m.dim1(); ++i)
64 |     {
65 |         Matrix<T,1> tmp(m.dim2());
66 |         is >> tmp;
67 |         m[i] = tmp;
68 |     }
69 | 
70 |     is >> ch;
71 | 
72 |     if (ch!='}') error("'}' missing in Matrix<T,2> input");
73 | 
74 |     return is;
75 | }
76 | 
77 | //-----------------------------------------------------------------------------
78 | 
79 | }
80 | 


--------------------------------------------------------------------------------
/MatrixIO11.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <iostream>
 3 | #include "Matrix.h"
 4 | 
 5 | namespace Numeric_lib {
 6 | 
 7 | //-----------------------------------------------------------------------------
 8 | 
 9 | template<class T> std::ostream& operator<<(std::ostream& os, const Matrix<T>& v)
10 | {
11 |     os << '{';
12 | 
13 |     for (Index i = 0; i<v.dim1(); ++i) {
14 |         os << "  ";
15 |         os << v(i);
16 |     }
17 | 
18 |     os << '}';
19 |     return os;
20 | }
21 | 
22 | //-----------------------------------------------------------------------------
23 | 
24 | template<class T> std::ostream& operator<<(std::ostream& os, const Matrix<T,2>& m)
25 | {
26 |     os << "{\n";
27 | 
28 |     for (Index i = 0; i<m.dim1(); ++i)
29 |         os << m[i] << '\n';
30 | 
31 |     os << '}';
32 |     return os;
33 | }
34 | 
35 | //-----------------------------------------------------------------------------
36 | 
37 | template<class T> std::istream& operator>>(std::istream& is, Matrix<T>& v)
38 | {
39 |     char ch;
40 |     is >> ch;
41 | 
42 |     if (ch!='{') error("'{' missing in Matrix<T,1> input");
43 | 
44 |     for (Index i = 0; i<v.dim1(); ++i)
45 |         is >> v(i);
46 | 
47 |     is >> ch;
48 | 
49 |     if (ch!='}') error("'}' missing in Matrix<T,1> input");
50 |   
51 |     return is;
52 | }
53 | 
54 | //-----------------------------------------------------------------------------
55 | 
56 | template<class T> std::istream& operator>>(std::istream& is, Matrix<T,2>& m)
57 | {
58 |     char ch;
59 |     is >> ch;
60 | 
61 |     if (ch!='{') error("'{' missing in Matrix<T,2> input");
62 | 
63 |     for (Index i = 0; i<m.dim1(); ++i)
64 |     {
65 |         Matrix<T,1> tmp(m.dim2());
66 |         is >> tmp;
67 |         m[i] = tmp;
68 |     }
69 | 
70 |     is >> ch;
71 | 
72 |     if (ch!='}') error("'}' missing in Matrix<T,2> input");
73 | 
74 |     return is;
75 | }
76 | 
77 | //-----------------------------------------------------------------------------
78 | 
79 | }
80 | 


--------------------------------------------------------------------------------
/Point.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef POINT_GUARD
 3 | #define POINT_GUARD
 4 | 
 5 | //typedef void (*Callback)(void*,void*);
 6 | 
 7 | namespace Graph_lib {
 8 | 
 9 | struct Point {
10 | 	int x,y;
11 | //	Point(int xx, int yy) : x(xx), y(yy) { }
12 | //	Point() :x(0), y(0) { }
13 | 
14 | //	Point& operator+=(Point d) { x+=d.x; y+=d.y; return *this; }
15 | };
16 | 
17 | inline bool operator==(Point a, Point b) { return a.x==b.x && a.y==b.y; }
18 | 
19 | inline bool operator!=(Point a, Point b) { return !(a==b); }
20 | 
21 | 
22 | }
23 | #endif


--------------------------------------------------------------------------------
/Simple_window.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | //
 3 | // This is a GUI support code to the chapters 12-16 of the book
 4 | // "Programming -- Principles and Practice Using C++" by Bjarne Stroustrup
 5 | //
 6 | 
 7 | #include "Simple_window.h"
 8 | 
 9 | //------------------------------------------------------------------------------
10 | 
11 | Simple_window::Simple_window(Point xy, int w, int h, const string& title) :
12 |     Window(xy,w,h,title),
13 |     next_button(Point(x_max()-70,0), 70, 20, "Next", cb_next),
14 |     button_pushed(false)
15 | {
16 |     attach(next_button);
17 | }
18 | 
19 | //------------------------------------------------------------------------------
20 | 
21 | bool Simple_window::wait_for_button()
22 | // modified event loop:
23 | // handle all events (as per default), quit when button_pushed becomes true
24 | // this allows graphics without control inversion
25 | {
26 |     show();
27 |     button_pushed = false;
28 | #if 1
29 |     // Simpler handler
30 |     while (!button_pushed) Fl::wait();
31 |     Fl::redraw();
32 | #else
33 |     // To handle the case where the user presses the X button in the window frame
34 |     // to kill the application, change the condition to 0 to enable this branch.
35 |     Fl::run();
36 | #endif
37 |     return button_pushed;
38 | }
39 | 
40 | //------------------------------------------------------------------------------
41 | 
42 | void Simple_window::cb_next(Address, Address pw)
43 | // call Simple_window::next() for the window located at pw
44 | {  
45 |     reference_to<Simple_window>(pw).next();    
46 | }
47 | 
48 | //------------------------------------------------------------------------------
49 | 
50 | void Simple_window::next()
51 | {
52 |     button_pushed = true;
53 |     hide();
54 | }
55 | 
56 | //------------------------------------------------------------------------------
57 | 


--------------------------------------------------------------------------------
/Simple_window.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #include "GUI.h"	// for Simple_window only (doesn't really belong in Window.h)
 3 | 
 4 | using namespace Graph_lib;
 5 | 
 6 | // Simple_window is basic scaffolding for ultra-simple interaction with graphics
 7 | // it provides one window with one "next" button for ultra-simple animation
 8 | 
 9 | struct Simple_window : Window {
10 | 	Simple_window(Point xy, int w, int h, const string& title )
11 | 	: Window(xy,w,h,title),
12 | 	  button_pushed(false),
13 | 	  next_button(Point(x_max()-70,0), 70, 20, "Next", cb_next) { attach(next_button); }
14 | 	
15 | 	void wait_for_button()
16 | 	// modified event loop
17 | 	// handle all events (as per default), but quit when button_pushed becomes true
18 | 	// this allows graphics without control inversion
19 | 	{
20 | 		while (!button_pushed) Fl::wait();
21 | 		button_pushed = false;
22 | 		Fl::redraw();
23 | 	}
24 | 
25 | 	Button next_button;
26 | private:
27 | 	bool button_pushed;
28 | 	
29 | 	static void cb_next(Address, Address addr) // callback for next_button
30 | 	//	{ reference_to<Simple_window>(addr).next(); }
31 | 	{
32 | 		static_cast<Simple_window*>(addr)->next();
33 | 	}
34 | 
35 | 	void next() { button_pushed = true; }
36 | 
37 | };
38 | 


--------------------------------------------------------------------------------
/Window.cpp:
--------------------------------------------------------------------------------
 1 | #include "Window.h"
 2 | #include "Graph.h"
 3 | #include "GUI.h"
 4 | 
 5 | namespace Graph_lib {
 6 | 
 7 | Window::Window(int ww, int hh, const string& title)
 8 | :Fl_Window(ww,hh,title.c_str()),w(ww),h(hh)
 9 | {
10 | 	init();
11 | }
12 | 
13 | Window::Window(Point xy, int ww, int hh, const string& title)
14 | :Fl_Window(xy.x,xy.y,ww,hh,title.c_str()),w(ww),h(hh)
15 | { 
16 | 	init();
17 | }
18 | 
19 | void Window::init()
20 | {
21 |    resizable(this);
22 |    show();
23 | } 
24 | 
25 | //---------------------------------------------------- 
26 | 
27 | void Window::draw()
28 | {
29 | 	Fl_Window::draw();
30 | 	for (unsigned int i=0; i<shapes.size(); ++i) shapes[i]->draw();
31 | }
32 | 
33 | void Window::attach(Widget& w)
34 | {
35 | 	begin();			// FTLK: begin attaching new Fl_Wigets to this window
36 | 		w.attach(*this);	// let the Widget create its Fl_Wigits
37 | 	end();				// FTLK: stop attaching new Fl_Wigets to this window
38 | }
39 | 
40 | void Window::detach(Widget& b)
41 | {
42 | 	  b.hide();
43 | }
44 | 
45 | void Window::attach(Shape& s)
46 | {
47 | 		shapes.push_back(&s);
48 | //		s.attached = this;
49 | }
50 | void Window::detach(Shape& s)
51 | {
52 | 		for (unsigned int i = shapes.size(); 0<i; --i)	// guess last attached will be first released
53 | 			if (shapes[i-1]==&s)
54 | 				shapes.erase(shapes.begin()+(i-1));//&shapes[i-1]);
55 | }
56 | 
57 | 
58 | void Window::put_on_top(Shape& p) {
59 | 	for (int i=0; i<shapes.size(); ++i) {
60 | 		if (&p==shapes[i]) {
61 | 			for (++i; i<shapes.size(); ++i)
62 | 				shapes[i-1] = shapes[i];
63 | 			shapes[shapes.size()-1] = &p;
64 | 			return;
65 | 		}
66 | 	}
67 | }
68 | 
69 | int gui_main() { return Fl::run(); }
70 | 
71 | } // Graph
72 | 


--------------------------------------------------------------------------------
/Window.h:
--------------------------------------------------------------------------------
 1 | #ifndef WINDOW_GUARD
 2 | #define WINDOW_GUARD 1
 3 | 
 4 | #include "fltk.h"
 5 | 
 6 | #include "std_lib_facilities.h"
 7 | 
 8 | #include "Point.h"
 9 | //#include "GUI.h"
10 | 
11 | namespace Graph_lib {
12 | 
13 | class Shape;	// "forward declare" Shape
14 | class Widget;
15 | 
16 | class Window : public Fl_Window { 
17 | public: 
18 | 	Window(int w, int h, const string& title );			// let the system pick the location
19 | 	Window(Point xy, int w, int h, const string& title );	// top left corner in xy
20 | 	virtual ~Window() { }
21 | 
22 | 	int x_max() const { return w; }
23 | 	int y_max() const { return h; }
24 | 
25 | 	void resize(int ww, int hh) { w=ww, h=hh; size(ww,hh); }
26 | 
27 | 	void set_label(const string& s) { label(s.c_str()); }
28 | 
29 | 	void attach(Shape& s);
30 | 	void attach(Widget& w);
31 | 
32 | 	void detach(Shape& s);	// remove s from shapes 
33 | 	void detach(Widget& w);	// remove w from window (deactivate callbacks)
34 | 
35 | 	void put_on_top(Shape& p);	// put p on top of other shapes
36 | 
37 | protected:
38 | 	void draw();
39 |      
40 | private:
41 | 	  vector<Shape*> shapes;	// shapes attached to window
42 | 	  int w,h;					// window size
43 | 
44 | 	  void init();
45 | }; 
46 | 
47 | int gui_main();	// invoke GUI library's main event loop
48 | 
49 | inline int x_max() { return Fl::w(); }	// width of screen in pixels
50 | inline int y_max() { return Fl::h(); }	// height of screen in pixels
51 | 
52 | }
53 | #endif
54 | 


--------------------------------------------------------------------------------
/fltk.h:
--------------------------------------------------------------------------------
 1 | #ifndef FLTK_GUARD
 2 | #define FLTK_GUARD 1
 3 | 
 4 | #include "FL/Fl.H"
 5 | #include "FL/Fl_Window.H" 
 6 | #include "FL/Fl_Button.H" 
 7 | #include "FL/Fl_Input.H" 
 8 | #include "FL/Fl_Output.H" 
 9 | #include <cstdlib>       // for exit(0)
10 | #include "FL/fl_draw.H"
11 | #include "FL/Enumerations.H"
12 | 
13 | #include "Fl/Fl_JPEG_Image.H"
14 | #include "Fl/Fl_GIF_Image.H"
15 | 
16 | #endif
17 | 
18 | 


--------------------------------------------------------------------------------
/std_lib_facilities.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |    std_lib_facilities.h
  3 | */
  4 | 
  5 | /*
  6 | 	simple "Programming: Principles and Practice using C++ (second edition)" course header to
  7 | 	be used for the first few weeks.
  8 | 	It provides the most common standard headers (in the global namespace)
  9 | 	and minimal exception/error support.
 10 | 
 11 | 	Students: please don't try to understand the details of headers just yet.
 12 | 	All will be explained. This header is primarily used so that you don't have
 13 | 	to understand every concept all at once.
 14 | 
 15 | 	By Chapter 10, you don't need this file and after Chapter 21, you'll understand it
 16 | 
 17 | 	Revised April 25, 2010: simple_error() added
 18 | 	
 19 | 	Revised November 25 2013: remove support for pre-C++11 compilers, use C++11: <chrono>
 20 | 	Revised November 28 2013: add a few container algorithms
 21 | 	Revised June 8 2014: added #ifndef to workaround Microsoft C++11 weakness
 22 | */
 23 | 
 24 | #ifndef H112
 25 | #define H112 251113L
 26 | 
 27 | 
 28 | #include<iostream>
 29 | #include<iomanip>
 30 | #include<fstream>
 31 | #include<sstream>
 32 | #include<cmath>
 33 | #include<cstdlib>
 34 | #include<string>
 35 | #include<list>
 36 | #include <forward_list>
 37 | #include<vector>
 38 | #include<unordered_map>
 39 | #include<algorithm>
 40 | #include <array>
 41 | #include <regex>
 42 | #include<random>
 43 | #include<stdexcept>
 44 | 
 45 | //------------------------------------------------------------------------------
 46 | 
 47 | 
 48 | //------------------------------------------------------------------------------
 49 | 
 50 | typedef long Unicode;
 51 | 
 52 | //------------------------------------------------------------------------------
 53 | 
 54 | using namespace std;
 55 | 
 56 | template<class T> string to_string(const T& t)
 57 | {
 58 | 	ostringstream os;
 59 | 	os << t;
 60 | 	return os.str();
 61 | }
 62 | 
 63 | struct Range_error : out_of_range {	// enhanced vector range error reporting
 64 | 	int index;
 65 | 	Range_error(int i) :out_of_range("Range error: "+to_string(i)), index(i) { }
 66 | };
 67 | 
 68 | 
 69 | // trivially range-checked vector (no iterator checking):
 70 | template< class T> struct Vector : public std::vector<T> {
 71 | 	using size_type = typename std::vector<T>::size_type;
 72 | 
 73 | #ifdef _MSC_VER
 74 | 	// microsoft doesn't yet support C++11 inheriting constructors
 75 | 	Vector() { }
 76 | 	explicit Vector(size_type n) :std::vector<T>(n) {}
 77 | 	Vector(size_type n, const T& v) :std::vector<T>(n,v) {}
 78 | 	template <class I>
 79 | 	Vector(I first, I last) : std::vector<T>(first, last) {}
 80 | 	Vector(initializer_list<T> list) : std::vector<T>(list) {}
 81 | #else
 82 | 	using std::vector<T>::vector;	// inheriting constructor
 83 | #endif
 84 | 
 85 | 	T& operator[](unsigned int i) // rather than return at(i);
 86 | 	{
 87 | 		if (i<0||this->size()<=i) throw Range_error(i);
 88 | 		return std::vector<T>::operator[](i);
 89 | 	}
 90 | 	const T& operator[](unsigned int i) const
 91 | 	{
 92 | 		if (i<0||this->size()<=i) throw Range_error(i);
 93 | 		return std::vector<T>::operator[](i);
 94 | 	}
 95 | };
 96 | 
 97 | // disgusting macro hack to get a range checked vector:
 98 | #define vector Vector
 99 | 
100 | // trivially range-checked string (no iterator checking):
101 | struct String : std::string {
102 | 	using size_type = std::string::size_type;
103 | //	using string::string;
104 | 
105 | 	char& operator[](unsigned int i) // rather than return at(i);
106 | 	{
107 | 		if (i<0||size()<=i) throw Range_error(i);
108 | 		return std::string::operator[](i);
109 | 	}
110 | 
111 | 	const char& operator[](unsigned int i) const
112 | 	{
113 | 		if (i<0||size()<=i) throw Range_error(i);
114 | 		return std::string::operator[](i);
115 | 	}
116 | };
117 | 
118 | 
119 | namespace std {
120 | 
121 |     template<> struct hash<String>
122 |     {
123 |         size_t operator()(const String& s) const
124 |         {
125 |             return hash<std::string>()(s);
126 |         }
127 |     };
128 | 
129 | } // of namespace std
130 | 
131 | 
132 | struct Exit : runtime_error {
133 | 	Exit(): runtime_error("Exit") {}
134 | };
135 | 
136 | // error() simply disguises throws:
137 | inline void error(const string& s)
138 | {
139 | 	throw runtime_error(s);
140 | }
141 | 
142 | inline void error(const string& s, const string& s2)
143 | {
144 | 	error(s+s2);
145 | }
146 | 
147 | inline void error(const string& s, int i)
148 | {
149 | 	ostringstream os;
150 | 	os << s <<": " << i;
151 | 	error(os.str());
152 | }
153 | 
154 | 
155 | template<class T> char* as_bytes(T& i)	// needed for binary I/O
156 | {
157 | 	void* addr = &i;	// get the address of the first byte
158 | 						// of memory used to store the object
159 | 	return static_cast<char*>(addr); // treat that memory as bytes
160 | }
161 | 
162 | 
163 | inline void keep_window_open()
164 | {
165 | 	cin.clear();
166 | 	cout << "Please enter a character to exit\n";
167 | 	char ch;
168 | 	cin >> ch;
169 | 	return;
170 | }
171 | 
172 | inline void keep_window_open(string s)
173 | {
174 | 	if (s=="") return;
175 | 	cin.clear();
176 | 	cin.ignore(120,'\n');
177 | 	for (;;) {
178 | 		cout << "Please enter " << s << " to exit\n";
179 | 		string ss;
180 | 		while (cin >> ss && ss!=s)
181 | 			cout << "Please enter " << s << " to exit\n";
182 | 		return;
183 | 	}
184 | }
185 | 
186 | 
187 | 
188 | // error function to be used (only) until error() is introduced in Chapter 5:
189 | inline void simple_error(string s)	// write ``error: s and exit program
190 | {
191 | 	cerr << "error: " << s << '\n';
192 | 	keep_window_open();		// for some Windows environments
193 | 	exit(1);
194 | }
195 | 
196 | // make std::min() and std::max() accessible on systems with antisocial macros:
197 | #undef min
198 | #undef max
199 | 
200 | 
201 | // run-time checked narrowing cast (type conversion). See ???.
202 | template<class R, class A> R narrow_cast(const A& a)
203 | {
204 | 	R r = R(a);
205 | 	if (A(r)!=a) error(string("info loss"));
206 | 	return r;
207 | }
208 | 
209 | // random number generators. See 24.7.
210 | 
211 | 
212 | 
213 | inline int randint(int min, int max) { static default_random_engine ran; return uniform_int_distribution<>{min, max}(ran); }
214 | 
215 | inline int randint(int max) { return randint(0, max); }
216 | 
217 | //inline double sqrt(int x) { return sqrt(double(x)); }	// to match C++0x
218 | 
219 | // container algorithms. See 21.9.
220 | 
221 | template<typename C>
222 | using Value_type = typename C::value_type;
223 | 
224 | template<typename C>
225 | using Iterator = typename C::iterator;
226 | 
227 | template<typename C>
228 | 	// requires Container<C>()
229 | void sort(C& c)
230 | {
231 | 	std::sort(c.begin(), c.end());
232 | }
233 | 
234 | template<typename C, typename Pred>
235 | // requires Container<C>() && Binary_Predicate<Value_type<C>>()
236 | void sort(C& c, Pred p)
237 | {
238 | 	std::sort(c.begin(), c.end(), p);
239 | }
240 | 
241 | template<typename C, typename Val>
242 | 	// requires Container<C>() && Equality_comparable<C,Val>()
243 | Iterator<C> find(C& c, Val v)
244 | {
245 | 	return std::find(c.begin(), c.end(), v);
246 | }
247 | 
248 | template<typename C, typename Pred>
249 | // requires Container<C>() && Predicate<Pred,Value_type<C>>()
250 | Iterator<C> find_if(C& c, Pred p)
251 | {
252 | 	return std::find_if(c.begin(), c.end(), p);
253 | }
254 | 
255 | #endif //H112
256 | 


--------------------------------------------------------------------------------