diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..1f3060a
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,2 @@
+BasedOnStyle: LLVM
+Language: Cpp
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..378eac2
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+build
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..95e31c6
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,38 @@
+cmake_minimum_required(VERSION 4.3.4)
+project(ppp-cpp
+  DESCRIPTION "Programming Principles and Practice using C++"
+  HOMEPAGE_URL https://github.com/wouterbeek/Programming-_Principles_and_Practice_Using_Cpp
+  LANGUAGES CXX
+  VERSION 0.1.0
+)
+
+set(cppVersion 23)
+set(CXX_EXTENSIONS OFF)
+set(CXX_STANDARD ${cppVersion})
+set(CXX_STANDARD_REQUIRED ON)
+
+add_library(base INTERFACE)
+add_library(${PROJECT_NAME}::base ALIAS base)
+target_compile_features(base INTERFACE cxx_std_${cppVersion})
+
+find_package(fltk REQUIRED)
+
+add_library(ppp STATIC)
+add_library(${PROJECT_NAME}::ppp ALIAS ppp)
+target_include_directories(ppp PUBLIC include)
+target_link_libraries(ppp PUBLIC fltk::fltk ${PROJECT_NAME}::base)
+target_sources(ppp
+  PRIVATE
+    src/Graph_lib/Graph.cpp
+    src/Graph_lib/GUI.cpp
+    src/Graph_lib/Simple_window.cpp
+    src/Graph_lib/Window.cpp
+)
+
+add_executable(chapter12)
+target_link_libraries(chapter12 PRIVATE ${PROJECT_NAME}::ppp)
+target_sources(chapter12 PRIVATE tool/chapter12.cpp)
+
+add_executable(chapter13)
+target_link_libraries(chapter13 PRIVATE ${PROJECT_NAME}::ppp)
+target_sources(chapter13 PRIVATE tool/chapter13.cpp)
diff --git a/CMakePresets.json b/CMakePresets.json
new file mode 100644
index 0000000..8b77dc1
--- /dev/null
+++ b/CMakePresets.json
@@ -0,0 +1,108 @@
+{
+  "version": 11,
+  "cmakeMinimumRequired": {
+    "major": 4,
+    "minor": 3,
+    "patch": 4
+  },
+  "configurePresets": [
+    {
+      "binaryDir": "${sourceDir}/build/${presetName}",
+      "cacheVariables": {
+        "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
+      },
+      "hidden": true,
+      "installDir": "${sourceDir}/install/${presetName}",
+      "name": "base",
+      "toolchainFile": "${sourceDir}/build/conan_toolchain.cmake"
+    },
+    {
+      "cacheVariables": {
+        "CMAKE_CXX_COMPILER": "g++"
+      },
+      "condition": {
+        "type": "equals",
+        "lhs": "${hostSystemName}",
+        "rhs": "Linux"
+      },
+      "generator": "Ninja",
+      "hidden": true,
+      "inherits": "base",
+      "name": "linux-base"
+    },
+    {
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug"
+      },
+      "displayName": "Linux Debug",
+      "inherits": "linux-base",
+      "name": "linux-debug"
+    },
+    {
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release"
+      },
+      "displayName": "Linux Release",
+      "inherits": "linux-base",
+      "name": "linux-release"
+    },
+    {
+      "cacheVariables": {
+        "CMAKE_CXX_COMPILER": "cl.exe",
+        "CMAKE_PREFIX_PATH": "${sourceDir}/build"
+      },
+      "condition": {
+        "type": "equals",
+        "lhs": "${hostSystemName}",
+        "rhs": "Windows"
+      },
+      "generator": "Ninja",
+      "hidden": true,
+      "inherits": "base",
+      "name": "windows-base",
+      "vendor": {
+        "microsoft.com/VisualStudioSettings/CMake/1.0": {
+          "hostOS": ["Windows"],
+          "intelliSenseMode": "windows-msvc-x64"
+        },
+        "microsoft.com/VisualStudioRemoteSettings/CMake/1.0": {
+          "hostOS": ["Windows"]
+        }
+      }
+    },
+    {
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug"
+      },
+      "displayName": "Windows Debug",
+      "inherits": "windows-base",
+      "name": "windows-debug"
+    },
+    {
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release"
+      },
+      "displayName": "Windows Release",
+      "inherits": "windows-base",
+      "name": "windows-release"
+    }
+  ],
+  "buildPresets": [
+    {
+      "configurePreset": "linux-debug",
+      "name": "linux-debug"
+    },
+    {
+      "configurePreset": "linux-release",
+      "name": "linux-release"
+    },
+    {
+      "configurePreset": "windows-debug",
+      "name": "windows-debug"
+    },
+    {
+      "configurePreset": "windows-release",
+      "name": "windows-release"
+    }
+  ]
+}
diff --git a/GUI.cpp b/GUI.cpp
deleted file mode 100644
index b0b2d81..0000000
--- a/GUI.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include "GUI.h"
-#include "std_lib_facilities.h"
-#include <sstream>
-
-using namespace Graph_lib;
-
-
-void Button::attach(Window& win)
-	{
-		pw = new Fl_Button(loc.x, loc.y, width, height, label.c_str());
-		pw->callback(reinterpret_cast<Fl_Callback*>(do_it), &win); // pass the window
-		own = &win;
-	}
-
-int In_box::get_int()
-{
-	Fl_Input& pi = reference_to<Fl_Input>(pw);
-//	return atoi(pi.value());
-	const char* p = pi.value();
-	if (!isdigit(p[0])) return -999999;
-	return atoi(p);
-}
-
-string In_box::get_string()
-{
-	Fl_Input& pi = reference_to<Fl_Input>(pw);
-	return string(pi.value());
-}
-
-void In_box::attach(Window& win)
-{
-	pw = new Fl_Input(loc.x, loc.y, width, height, label.c_str());
-	own = &win;
-}
-
-void Out_box::put(int i)
-{
-	Fl_Output& po = reference_to<Fl_Output>(pw);
-	std::stringstream ss;
-	ss << i;
-	po.value(ss.str().c_str());
-}
-
-void Out_box::put(const string& s)
-{
-	reference_to<Fl_Output>(pw).value(s.c_str());
-}
-
-void Out_box::attach(Window& win)
-{
-	pw = new Fl_Output(loc.x, loc.y, width, height, label.c_str());
-	own = &win;
-}
-
-Menu::Menu(Point xy, int w, int h, Kind kk, const string& s)
-:Widget(xy,w,h,s,0), k(kk), offset(0)
-{
-}
-
-int Menu::attach(Button& b)
-{
-	b.width = width;
-	b.height = height;
-
-	switch(k) {
-	case horizontal:
-		b.loc = Point(loc.x+offset,loc.y);
-		offset+=b.width;
-		break;
-	case vertical:
-		b.loc = Point(loc.x,loc.y+offset);
-		offset+=b.height;
-		break;
-	}
-	selection.push_back(&b);
-	return int(selection.size()-1);
-}
-
-int Menu::attach(Button* p)
-{
-//	owned.push_back(p);
-	return attach(*p);
-}
\ No newline at end of file
diff --git a/GUI.h b/GUI.h
deleted file mode 100644
index 0c7c78c..0000000
--- a/GUI.h
+++ /dev/null
@@ -1,133 +0,0 @@
-
-//
-// This is a GUI support code to the chapters 12-16 of the book
-// "Programming -- Principles and Practice Using C++" by Bjarne Stroustrup
-//
-
-#ifndef GUI_GUARD
-#define GUI_GUARD
-
-#include "Window.h"
-#include "Graph.h"
-
-namespace Graph_lib {
-
-//------------------------------------------------------------------------------
-
-    typedef void* Address;    // Address is a synonym for void*
-    typedef void(*Callback)(Address, Address);    // FLTK's required function type for all callbacks
-
-//------------------------------------------------------------------------------
-
-    template<class W> W& reference_to(Address pw)
-    // treat an address as a reference to a W
-    {
-        return *static_cast<W*>(pw);
-    }
-
-//------------------------------------------------------------------------------
-
-    class Widget {
-    // Widget is a handle to an Fl_widget - it is *not* an Fl_widget
-    // We try to keep our interface classes at arm's length from FLTK
-    public:
-        Widget(Point xy, int w, int h, const string& s, Callback cb)
-            : loc(xy), width(w), height(h), label(s), do_it(cb)
-        {}
-
-        virtual void move(int dx,int dy) { hide(); pw->position(loc.x+=dx, loc.y+=dy); show(); }
-        virtual void hide() { pw->hide(); }
-        virtual void show() { pw->show(); }
-        virtual void attach(Window&) = 0;
-
-        Point loc;
-        int width;
-        int height;
-        string label;
-        Callback do_it;
-
-        virtual ~Widget() { }
-
-    protected:
-        Window* own;    // every Widget belongs to a Window
-        Fl_Widget* pw;  // connection to the FLTK Widget
-    private:
-        Widget& operator=(const Widget&); // don't copy Widgets
-        Widget(const Widget&);
-    };
-
-//------------------------------------------------------------------------------
-
-    struct Button : Widget {
-        Button(Point xy, int w, int h, const string& label, Callback cb)
-            : Widget(xy,w,h,label,cb)
-        {}
-
-        void attach(Window&);
-    };
-
-//------------------------------------------------------------------------------
-
-    struct In_box : Widget {
-        In_box(Point xy, int w, int h, const string& s)
-            :Widget(xy,w,h,s,0) { }
-        int get_int();
-        string get_string();
-
-        void attach(Window& win);
-    };
-
-//------------------------------------------------------------------------------
-
-    struct Out_box : Widget {
-        Out_box(Point xy, int w, int h, const string& s)
-            :Widget(xy,w,h,s,0) { }
-        void put(int);
-        void put(const string&);
-
-        void attach(Window& win);
-    };
-
-//------------------------------------------------------------------------------
-
-    struct Menu : Widget {
-        enum Kind { horizontal, vertical };
-        Menu(Point xy, int w, int h, Kind kk, const string& label)
-            : Widget(xy,w,h,label,0), k(kk), offset(0)
-        {}
-
-        Vector_ref<Button> selection;
-        Kind k;
-        int offset;
-        int attach(Button& b);      // Menu does not delete &b
-        int attach(Button* p);      // Menu deletes p
-
-        void show()                 // show all buttons
-        {
-            for (unsigned int i = 0; i<selection.size(); ++i)
-                selection[i].show();
-        }
-        void hide()                 // hide all buttons
-        {
-            for (unsigned int i = 0; i<selection.size(); ++i) 
-                selection[i].hide(); 
-        }
-        void move(int dx, int dy)   // move all buttons
-        {
-            for (unsigned int i = 0; i<selection.size(); ++i) 
-                selection[i].move(dx,dy);
-        }
-
-        void attach(Window& win)    // attach all buttons
-        {
-            for (int i=0; i<selection.size(); ++i) win.attach(selection[i]);
-            own = &win;
-        }
-
-    };
-
-//------------------------------------------------------------------------------
-
-} // of namespace Graph_lib
-
-#endif // GUI_GUARD
diff --git a/Graph.cpp b/Graph.cpp
deleted file mode 100644
index f9cb687..0000000
--- a/Graph.cpp
+++ /dev/null
@@ -1,358 +0,0 @@
-#include "Graph.h"
-#include<map>
-
-namespace Graph_lib {
-
-void Shape::draw_lines() const
-{
-	if (color().visibility() && 1<points.size())	// draw sole pixel?
-		for (unsigned int i=1; i<points.size(); ++i)
-			fl_line(points[i-1].x,points[i-1].y,points[i].x,points[i].y);
-}
-
-void Shape::draw() const
-{
-	Fl_Color oldc = fl_color();
-	// there is no good portable way of retrieving the current style
-	fl_color(lcolor.as_int());
-	fl_line_style(ls.style(),ls.width());
-	draw_lines();
-	fl_color(oldc);	// reset color (to pevious) and style (to default)
-	fl_line_style(0);
-}
-
-
-// does two lines (p1,p2) and (p3,p4) intersect?
-// if se return the distance of the intersect point as distances from p1
-inline pair<double,double> line_intersect(Point p1, Point p2, Point p3, Point p4, bool& parallel) 
-{
-    double x1 = p1.x;
-    double x2 = p2.x;
-	double x3 = p3.x;
-	double x4 = p4.x;
-	double y1 = p1.y;
-	double y2 = p2.y;
-	double y3 = p3.y;
-	double y4 = p4.y;
-
-	double denom = ((y4 - y3)*(x2-x1) - (x4-x3)*(y2-y1));
-	if (denom == 0){
-		parallel= true;
-		return pair<double,double>(0,0);
-	}
-	parallel = false;
-	return pair<double,double>( ((x4-x3)*(y1-y3) - (y4-y3)*(x1-x3))/denom,
-								((x2-x1)*(y1-y3) - (y2-y1)*(x1-x3))/denom);
-}
-
-
-//intersection between two line segments
-//Returns true if the two segments intersect,
-//in which case intersection is set to the point of intersection
-bool line_segment_intersect(Point p1, Point p2, Point p3, Point p4, Point& intersection){
-   bool parallel;
-   pair<double,double> u = line_intersect(p1,p2,p3,p4,parallel);
-   if (parallel || u.first < 0 || u.first > 1 || u.second < 0 || u.second > 1) return false;
-   intersection.x = p1.x + u.first*(p2.x - p1.x);
-   intersection.y = p1.y + u.first*(p2.y - p1.y);
-   return true;
-} 
-
-void Polygon::add(Point p)
-{
-	int np = number_of_points();
-
-	if (1<np) {	// check that thenew line isn't parallel to the previous one
-		if (p==point(np-1)) error("polygon point equal to previous point");
-		bool parallel;
-		line_intersect(point(np-1),p,point(np-2),point(np-1),parallel);
-		if (parallel)
-			error("two polygon points lie in a straight line");
-	}
-
-	for (int i = 1; i<np-1; ++i) {	// check that new segment doesn't interset and old point
-		Point ignore(0,0);
-		if (line_segment_intersect(point(np-1),p,point(i-1),point(i),ignore))
-			error("intersect in polygon");
-	}
-	
-
-	Closed_polyline::add(p);
-}
-
-
-void Polygon::draw_lines() const
-{
-		if (number_of_points() < 3) error("less than 3 points in a Polygon");
-		Closed_polyline::draw_lines();
-}
-
-void Open_polyline::draw_lines() const
-{
-		if (fill_color().visibility()) {
-			fl_color(fill_color().as_int());
-			fl_begin_complex_polygon();
-			for(int i=0; i<number_of_points(); ++i){
-				fl_vertex(point(i).x, point(i).y);
-			}
-			fl_end_complex_polygon();
-			fl_color(color().as_int());	// reset color
-		}
-		
-		if (color().visibility())
-			Shape::draw_lines();
-}
-
-
-void Closed_polyline::draw_lines() const
-{
-	Open_polyline::draw_lines();
-		
-	if (color().visibility())	// draw closing line:
-		fl_line(point(number_of_points()-1).x,point(number_of_points()-1).y,point(0).x,point(0).y);
-}
-void Shape::move(int dx, int dy)
-{
-	for (unsigned int i = 0; i<points.size(); ++i) {
-		points[i].x+=dx;
-		points[i].y+=dy;
-	}
-}
-
-void Lines::draw_lines() const
-{
-//	if (number_of_points()%2==1) error("odd number of points in set of lines");
-	if (color().visibility())
-		for (int i=1; i<number_of_points(); i+=2)
-			fl_line(point(i-1).x,point(i-1).y,point(i).x,point(i).y);
-}
-
-void Text::draw_lines() const
-{
-	int ofnt = fl_font();
-	int osz = fl_size();
-	fl_font(fnt.as_int(),fnt_sz);
-	fl_draw(lab.c_str(), point(0).x, point(0).y);
-	fl_font(ofnt,osz);
-}
-
-Function::Function(Fct f, double r1, double r2, Point xy, int count, double xscale, double yscale)
-// graph f(x) for x in [r1:r2) using count line segments with (0,0) displayed at xy
-// x coordinates are scaled by xscale and y coordinates scaled by yscale
-{
-	if (r2-r1<=0) error("bad graphing range");
-	if (count<=0) error("non-positive graphing count");
-	double dist = (r2-r1)/count;
-	double r = r1;
-	for (int i = 0; i<count; ++i) {
-		add(Point(xy.x+int(r*xscale),xy.y-int(f(r)*yscale)));
-		r += dist;
-	}
-}
-
-void Rectangle::draw_lines() const
-{
-	if (fill_color().visibility()) {	// fill
-		fl_color(fill_color().as_int());
-		fl_rectf(point(0).x,point(0).y,w,h);
-		fl_color(color().as_int());	// reset color
-	}
-
-	if (color().visibility()) {	// edge on top of fill
-		fl_color(color().as_int());
-		fl_rect(point(0).x,point(0).y,w,h);
-	}
-}
-
-
-Axis::Axis(Orientation d, Point xy, int length, int n, string lab)
-	:label(Point(0,0),lab)
-{
-	if (length<0) error("bad axis length");
-	switch (d){
-	case Axis::x:
-		{	Shape::add(xy);	// axis line
-			Shape::add(Point(xy.x+length,xy.y));	// axis line
-			if (1<n) {
-				int dist = length/n;
-				int x = xy.x+dist;
-				for (int i = 0; i<n; ++i) {
-					notches.add(Point(x,xy.y),Point(x,xy.y-5));
-				x += dist;
-			}
-		}
-		// label under the line
-		label.move(length/3,xy.y+20);
-		break;
-	}
-	case Axis::y:
-		{	Shape::add(xy);	// a y-axis goes up
-			Shape::add(Point(xy.x,xy.y-length));
-			if (1<n) {
-			int dist = length/n;
-			int y = xy.y-dist;
-			for (int i = 0; i<n; ++i) {
-				notches.add(Point(xy.x,y),Point(xy.x+5,y));
-				y -= dist;
-			}
-		}
-		// label at top
-		label.move(xy.x-10,xy.y-length-10);
-		break;
-	}
-	case Axis::z:
-		error("z axis not implemented");
-	}
-}
-
-void Axis::draw_lines() const
-{
-	Shape::draw_lines();	// the line
-	notches.draw();	// the notches may have a different color from the line
-	label.draw();	// the label may have a different color from the line
-}
-
-
-void Axis::set_color(Color c)
-{
-	Shape::set_color(c);
-	notches.set_color(c);
-	label.set_color(c);
-}
-
-void Axis::move(int dx, int dy)
-{
-	Shape::move(dx,dy);
-	notches.move(dx,dy);
-	label.move(dx,dy);
-}
-
-void Circle::draw_lines() const
-{
-	if (fill_color().visibility()) {	// fill
-		fl_color(fill_color().as_int());
-		fl_pie(point(0).x,point(0).y,r+r-1,r+r-1,0,360);
-		fl_color(color().as_int());	// reset color
-	}
-
-	if (color().visibility()) {
-		fl_color(color().as_int());
-		fl_arc(point(0).x,point(0).y,r+r,r+r,0,360);
-	}
-}
-
-
-void Ellipse::draw_lines() const
-{
-	if (fill_color().visibility()) {	// fill
-		fl_color(fill_color().as_int());
-		fl_pie(point(0).x,point(0).y,w+w-1,h+h-1,0,360);
-		fl_color(color().as_int());	// reset color
-	}
-
-	if (color().visibility()) {
-		fl_color(color().as_int());
-		fl_arc(point(0).x,point(0).y,w+w,h+h,0,360);
-	}
-}
-
-void draw_mark(Point xy, char c)
-{
-	static const int dx = 4;
-	static const int dy = 4;
-	string m(1,c);
-	fl_draw(m.c_str(),xy.x-dx,xy.y+dy);
-}
-
-void Marked_polyline::draw_lines() const
-{
-	Open_polyline::draw_lines();
-	for (int i=0; i<number_of_points(); ++i) 
-		draw_mark(point(i),mark[i%mark.size()]);
-}
-/*
-void Marks::draw_lines() const
-{
-	for (int i=0; i<number_of_points(); ++i) 
-		fl_draw(mark.c_str(),point(i).x-4,point(i).y+4);
-}
-*/
-
-
-std::map<string,Suffix::Encoding> suffix_map;
-
-int init_suffix_map()
-{
-	suffix_map["jpg"] = Suffix::jpg;
-	suffix_map["JPG"] = Suffix::jpg;
-	suffix_map["jpeg"] = Suffix::jpg;
-	suffix_map["JPEG"] = Suffix::jpg;
-	suffix_map["gif"] = Suffix::gif;
-	suffix_map["GIF"] = Suffix::gif;
-	suffix_map["bmp"] = Suffix::bmp;
-	suffix_map["BMP"] = Suffix::bmp;
-	return 0;
-}
-
-Suffix::Encoding get_encoding(const string& s)
-		// try to deduce type from file name using a lookup table
-{
-	static int x = init_suffix_map();
-
-	string::const_iterator p = find(s.begin(),s.end(),'.');
-	if (p==s.end()) return Suffix::none;	// no suffix
-
-	string suf(p+1,s.end());
-	return suffix_map[suf];
-}
-
-bool can_open(const string& s)
-            // check if a file named s exists and can be opened for reading
-{
-	ifstream ff(s.c_str());
-	return ff;
-}
-
-
-// somewhat overelaborate constructor
-// because errors related to image files can be such a pain to debug
-Image::Image(Point xy, string s, Suffix::Encoding e)
-	:w(0), h(0), fn(xy,"")
-{
-	add(xy);
-
-	if (!can_open(s)) {
-		fn.set_label("cannot open \""+s+'\"');
-		p = new Bad_image(30,20);	// the "error image"
-		return;
-	}
-
-	if (e == Suffix::none) e = get_encoding(s);
-	
-	switch(e) {
-	case Suffix::jpg:
-		p = new Fl_JPEG_Image(s.c_str());
-		break;
-	case Suffix::gif:
-		p = new Fl_GIF_Image(s.c_str());
-		break;
-//	case Suffix::bmp:
-//		p = new Fl_BMP_Image(s.c_str());
-//		break;
-	default:	// Unsupported image encoding
-		fn.set_label("unsupported file type \""+s+'\"');
-		p = new Bad_image(30,20);	// the "error image"
-	}
-}
-
-void Image::draw_lines() const
-{
-	if (fn.label()!="") fn.draw_lines();
-
-	if (w&&h)
-		p->draw(point(0).x,point(0).y,w,h,cx,cy);
-	else
-		p->draw(point(0).x,point(0).y);
-}
-
-} // Graph
\ No newline at end of file
diff --git a/Graph.h b/Graph.h
deleted file mode 100644
index efd5d24..0000000
--- a/Graph.h
+++ /dev/null
@@ -1,377 +0,0 @@
-
-#ifndef GRAPH_GUARD
-#define GRAPH_GUARD 1
-
-#include "Point.h"
-#include<vector>
-//#include<string>
-//#include<cmath>
-#include "fltk.h"
-//#include "std_lib_facilities.h"
-
-namespace Graph_lib {
-// defense against ill-behaved Linux macros:
-#undef major
-#undef minor
-
-struct Color {
-	enum Color_type {
-		red=FL_RED, blue=FL_BLUE, green=FL_GREEN,
-		yellow=FL_YELLOW, white=FL_WHITE, black=FL_BLACK,
-		magenta=FL_MAGENTA, cyan=FL_CYAN, dark_red=FL_DARK_RED,
-		dark_green=FL_DARK_GREEN, dark_yellow=FL_DARK_YELLOW, dark_blue=FL_DARK_BLUE,
-		dark_magenta=FL_DARK_MAGENTA, dark_cyan=FL_DARK_CYAN
-	};
-	enum Transparency { invisible = 0, visible=255 };
-
-	Color(Color_type cc) :c(Fl_Color(cc)), v(visible) { }
-	Color(Color_type cc, Transparency vv) :c(Fl_Color(cc)), v(vv) { }
-	Color(int cc) :c(Fl_Color(cc)), v(visible) { }
-	Color(Transparency vv) :c(Fl_Color()), v(vv) { }
-
-	int as_int() const { return c; }
-	char visibility() const { return v; }
-	void set_visibility(Transparency vv) { v=vv; }
-private:
-	unsigned char v;	// 0 or 1 for now
-	Fl_Color c;
-};
-
-struct Line_style {
-	enum Line_style_type {
-		solid=FL_SOLID,				// -------
-		dash=FL_DASH,				// - - - -
-		dot=FL_DOT,					// ....... 
-		dashdot=FL_DASHDOT,			// - . - . 
-		dashdotdot=FL_DASHDOTDOT,	// -..-..
-	};
-	Line_style(Line_style_type ss) :s(ss), w(0) { }
-	Line_style(Line_style_type lst, int ww) :s(lst), w(ww) { }
-	Line_style(int ss) :s(ss), w(0) { }
-
-	int width() const { return w; }
-	int style() const { return s; }
-private:
-	int s;
-	int w;
-};
-
-class Font {
-public:
-	enum Font_type {
-		helvetica=FL_HELVETICA,
-		helvetica_bold=FL_HELVETICA_BOLD,
-		helvetica_italic=FL_HELVETICA_ITALIC,
-		helvetica_bold_italic=FL_HELVETICA_BOLD_ITALIC,
-		courier=FL_COURIER,
-  		courier_bold=FL_COURIER_BOLD,
-  		courier_italic=FL_COURIER_ITALIC,
-  		courier_bold_italic=FL_COURIER_BOLD_ITALIC,
-		times=FL_TIMES,
-		times_bold=FL_TIMES_BOLD,
-		times_italic=FL_TIMES_ITALIC,
-		times_bold_italic=FL_TIMES_BOLD_ITALIC,
-		symbol=FL_SYMBOL,
-		screen=FL_SCREEN,
-		screen_bold=FL_SCREEN_BOLD,
-		zapf_dingbats=FL_ZAPF_DINGBATS
-	};
-
-	Font(Font_type ff) :f(ff) { }
-	Font(int ff) :f(ff) { }
-
-	int as_int() const { return f; }
-private:
-	int f;
-};
-
-template<class T> class Vector_ref {
-	vector<T*> v;
-	vector<T*> owned;
-public:
-	Vector_ref() {}
-
-	Vector_ref(T* a, T* b=0, T* c=0, T* d=0)
-	{
-			if (a) push_back(a);
-			if (b) push_back(b);
-			if (c) push_back(c);
-			if (d) push_back(d);
-	}
-
-	~Vector_ref() { for (int i=0; i<owned.size(); ++i) delete owned[i]; }
-
-	void push_back(T& s) { v.push_back(&s); }
-	void push_back(T* p) { v.push_back(p); owned.push_back(p); }
-
-	// ???void erase(???)
-
-	T& operator[](int i) { return *v[i]; }
-	const T& operator[](int i) const { return *v[i]; }
-	int size() const { return v.size(); }
-};
-
-typedef double Fct(double);
-
-class Shape  {	// deals with color and style, and holds sequence of lines
-protected:
-	Shape() { }
-	Shape(initializer_list<Point> lst);  // add() the Points to this Shape
-
-//	Shape() : lcolor(fl_color()),
-//		ls(0),
-//		fcolor(Color::invisible) { }
-	
-	void add(Point p){ points.push_back(p); }
-	void set_point(int i, Point p) { points[i] = p; }
-public:
-	void draw() const;					// deal with color and draw_lines
-protected:
-	virtual void draw_lines() const;	// simply draw the appropriate lines
-public:
-	virtual void move(int dx, int dy);	// move the shape +=dx and +=dy
-
-	void set_color(Color col) { lcolor = col; }
-	Color color() const { return lcolor; }
-
-	void set_style(Line_style sty) { ls = sty; }
-	Line_style style() const { return ls; }
-
-	void set_fill_color(Color col) { fcolor = col; }
-	Color fill_color() const { return fcolor; }
-
-	Point point(int i) const { return points[i]; }
-	int number_of_points() const { return int(points.size()); }
-
-	virtual ~Shape() { }
-	/*
-	struct Window* attached;
-	Shape(const Shape& a)
-		:attached(a.attached), points(a.points), line_color(a.line_color), ls(a.ls)
-	{
-		if (a.attached)error("attempt to copy attached shape");
-	}
-	*/
-	Shape(const Shape&) = delete;
-	Shape& operator=(const Shape&) = delete;
-private:
-	vector<Point> points;	// not used by all shapes
-	Color lcolor {fl_color()};
-	Line_style ls {0};
-	Color fcolor {Color::invisible};
-
-//	Shape(const Shape&);
-//	Shape& operator=(const Shape&);
-};
-
-struct Function : Shape {
-	// the function parameters are not stored
-	Function(Fct f, double r1, double r2, Point orig, int count = 100, double xscale = 25, double yscale = 25);
-	//Function(Point orig, Fct f, double r1, double r2, int count, double xscale = 1, double yscale = 1);	
-};
-
-struct Fill {
-	Fill() :no_fill(true), fcolor(0) { }
-	Fill(Color c) :no_fill(false), fcolor(c) { }
-
-	void set_fill_color(Color col) { fcolor = col; }
-	Color fill_color() { return fcolor; }
-protected:
-	bool no_fill;
-	Color fcolor;
-};
-
-struct Line : Shape {
-	Line(Point p1, Point p2) { add(p1); add(p2); }
-};
-
-struct Rectangle : Shape {
-
-	Rectangle(Point xy, int ww, int hh) :w{ ww }, h{ hh }
-	{
-		if (h<=0 || w<=0) error("Bad rectangle: non-positive side");
-		add(xy);
-	}
-	Rectangle(Point x, Point y) :w{ y.x - x.x }, h{ y.y - x.y }
-	{
-		if (h<=0 || w<=0) error("Bad rectangle: first point is not top left");
-		add(x);
-	}
-	void draw_lines() const;
-
-//	void set_fill_color(Color col) { fcolor = col; }
-//	Color fill_color() { return fcolor; }
-
-	int height() const { return h; }
-	int width() const { return w; }
-private:
-	int h;			// height
-	int w;			// width
-//	Color fcolor;	// fill color; 0 means "no fill"
-};
-
-bool intersect(Point p1, Point p2, Point p3, Point p4);
-
-
-struct Open_polyline : Shape {	// open sequence of lines
-	using Shape::Shape;
-	void add(Point p) { Shape::add(p); }
-	void draw_lines() const;
-};
-
-struct Closed_polyline : Open_polyline {	// closed sequence of lines
-	using Open_polyline::Open_polyline;
-	void draw_lines() const;
-	
-//	void add(Point p) { Shape::add(p); }
-};
-
-
-struct Polygon : Closed_polyline {	// closed sequence of non-intersecting lines
-	using Closed_polyline::Closed_polyline;
-	void add(Point p);
-	void draw_lines() const;
-};
-
-struct Lines : Shape {	// indepentdent lines
-	Lines() {}
-	Lines(initializer_list<Point> lst) : Shape{lst} { if (lst.size() % 2) error("odd number of points for Lines"); }
-	void draw_lines() const;
-	void add(Point p1, Point p2) { Shape::add(p1); Shape::add(p2); }
-};
-
-struct Text : Shape {
-	// the point is the bottom left of the first letter
-	Text(Point x, const string& s) : lab{ s } { add(x); }
-
-	void draw_lines() const;
-
-	void set_label(const string& s) { lab = s; }
-	string label() const { return lab; }
-
-	void set_font(Font f) { fnt = f; }
-	Font font() const { return Font(fnt); }
-
-	void set_font_size(int s) { fnt_sz = s; }
-	int font_size() const { return fnt_sz; }
-private:
-	string lab;	// label
-	Font fnt{ fl_font() };
-	int fnt_sz{ (14<fl_size()) ? fl_size() : 14 };	// at least 14 point
-};
-
-
-struct Axis : Shape {
-	// representation left public
-	enum Orientation { x, y, z };
-	Axis(Orientation d, Point xy, int length, int nummber_of_notches=0, string label = "");
-
-	void draw_lines() const;
-	void move(int dx, int dy);
-
-	void set_color(Color c);
-
-	Text label;
-	Lines notches;
-//	Orientation orin;
-//	int notches;
-};
-
-struct Circle : Shape {
-	Circle(Point p, int rr)	// center and radius
-	:r{ rr } {
-		add(Point{ p.x - r, p.y - r });
-	}
-
-	void draw_lines() const;
-
-	Point center() const { return { point(0).x + r, point(0).y + r }; }
-
-	void set_radius(int rr) { r=rr; }
-	int radius() const { return r; }
-private:
-	int r;
-};
-
-
-struct Ellipse : Shape {
-	Ellipse(Point p, int ww, int hh)	// center, min, and max distance from center
-	:w{ ww }, h{ hh } {
-		add(Point{ p.x - ww, p.y - hh });
-	}
-
-	void draw_lines() const;
-
-	Point center() const { return{ point(0).x + w, point(0).y + h }; }
-	Point focus1() const { return{ center().x + int(sqrt(double(w*w - h*h))), center().y }; }
-	Point focus2() const { return{ center().x - int(sqrt(double(w*w - h*h))), center().y }; }
-	
-	void set_major(int ww) { w=ww; }
-	int major() const { return w; }
-	void set_minor(int hh) { h=hh; }
-	int minor() const { return h; }
-private:
-	int w;
-	int h;
-};
-/*
-struct Mark : Text {
-	static const int dw = 4;
-	static const int dh = 4;
-	Mark(Point xy, char c) : Text(Point(xy.x-dw, xy.y+dh),string(1,c)) {}
-};
-*/
-
-struct Marked_polyline : Open_polyline {
-	Marked_polyline(const string& m) :mark(m) { }
-	void draw_lines() const;
-private:
-	string mark;
-};
-
-struct Marks : Marked_polyline {
-	Marks(const string& m) :Marked_polyline(m)
-	{ set_color(Color(Color::invisible)); }
-};
-
-struct Mark : Marks {
-	Mark(Point xy, char c) : Marks(string(1,c)) {add(xy); }
-};
-
-/*
-
-struct Marks : Shape {
-	Marks(char m) : mark(string(1,m)) { }
-	void add(Point p) { Shape::add(p); }
-	void draw_lines() const;
-private:
-	string mark;
-};
-*/
-
-struct Bad_image : Fl_Image {
-	Bad_image(int h, int w) : Fl_Image(h,w,0) { }
-	void draw(int x,int y, int, int, int, int) { draw_empty(x,y); }
-};
-
-struct Suffix {
-	enum Encoding { none, jpg, gif, bmp };
-};
-
-Suffix::Encoding get_encoding(const string& s);
-
-struct Image : Shape {
-	Image(Point xy, string s, Suffix::Encoding e = Suffix::none);
-	~Image() { delete p; }
-	void draw_lines() const;
-	void set_mask(Point xy, int ww, int hh) { w=ww; h=hh; cx=xy.x; cy=xy.y; }
-	void move(int dx,int dy) { Shape::move(dx,dy); p->draw(point(0).x,point(0).y); }
-private:
-	int w,h,cx,cy; // define "masking box" within image relative to position (cx,cy)
-	Fl_Image* p;
-	Text fn;
-};
-
-}
-#endif
-
diff --git a/Gui.h b/Gui.h
deleted file mode 100644
index 23b08f2..0000000
--- a/Gui.h
+++ /dev/null
@@ -1,115 +0,0 @@
-#ifndef GUI_GUARD
-#define GUI_GUARD
-
-#include "Point.h"
-#include "fltk.h"
-#include "Window.h"
-#include "Graph.h"
-//#include<vector>
-//#include<string>
-
-namespace Graph_lib {
-	
-typedef void* Address;
-typedef void (*Callback)(Address,Address);	// FLTK's required function type for all callbacks
-
-template<class W> W& reference_to(Address pw)
-	// treat an address as a reference to a W
-{
-		return *static_cast<W*>(pw);
-}
-
-
-class Widget {
-	// Widget is a handle to a Fl_widget - it is *not* a Fl_widget
-	// We try to keep our interface classes at arm's length from FLTK
-public:
-	Widget(Point xy, int w, int h, const string& s, Callback cb)
-		:loc(xy), width(w), height(h), label(s), do_it(cb)
-	{ }
-
-	virtual void move(int dx,int dy) { hide(); pw->position(loc.x+=dx, loc.y+=dy); show(); }
-	virtual void hide() { pw->hide(); }
-	virtual void show() { pw->show(); }
-	virtual void attach(Window&) = 0;	// each Widgit define at least one action for a window
-
-	Point loc;
-	int width;
-	int height;
-	string label;
-	Callback do_it;
-
-	virtual ~Widget() { }
-
-	/*
-	Widget(const Widget& a) :loc(a.loc) { error("attempt to copy Widget by constructor"); }
-	Widget& operator=(const Widget& a)
-	{
-			error("attempt to copy Widget by cassignment");
-			return *this;
-	}
-	*/
-
-protected:
-	Window* own;	// every Widget belongs to a Window
-	Fl_Widget* pw;
-private:
-	Widget& operator=(const Widget&);	// don't copy Widgets
-	Widget(const Widget&);
-};
-
-class Button : public Widget {
-public:
-	Button(Point xy, int ww, int hh, const string& s, Callback cb)
-	:Widget(xy,ww,hh,s,cb)
-	{ 
-	}
-	void attach(Window& win);
-};
-
-struct In_box : Widget {
-	In_box(Point xy, int w, int h, const string& s)
-		:Widget(xy,w,h,s,0)
-		{
-		}
-	int get_int();
-	string get_string();
-
-	void attach(Window& win);
-};
-
-struct Out_box : Widget {
-	Out_box(Point xy, int w, int h, const string& s/*, Window& win*/)
-		:Widget(xy,w,h,s,0)
-		{
-		}
-	void put(int);
-	void put(const string&);
-
-	void attach(Window& win);
-};
-
-struct Menu : Widget {
-	enum Kind { horizontal, vertical };
-	Menu(Point xy, int w, int h, Kind kk, const string& s);
-	Vector_ref<Button> selection;
-	Kind k;
-	int offset;
-	int attach(Button& b);	// attach button; Menu does not delete &b
-	int attach(Button* p);	// attach new button; Menu deletes p
-	void show() { for (int i = 0; i<selection.size(); ++i) selection[i].show(); }
-	void hide() { for (int i = 0; i<selection.size(); ++i) selection[i].hide(); }
-	void move(int dx, int dy)
-		{ for (int i = 0; i<selection.size(); ++i) selection[i].move(dx,dy); }
-//	int insert(int i, const Button& b);	// not implemented
-
-	void attach(Window& win)
-	{
-		for (int i=0; i<selection.size(); ++i) win.attach(selection[i]);
-	}	
-
-};
-
-}
-#endif
-
diff --git a/Matrix.h b/Matrix.h
deleted file mode 100644
index 136224c..0000000
--- a/Matrix.h
+++ /dev/null
@@ -1,804 +0,0 @@
-
-/*
-    warning: this small multidimensional matrix library uses a few features
-    not taught in ENGR112 and not explained in elementary textbooks
-
-    (c) Bjarne Stroustrup, Texas A&M University. 
-
-    Use as you like as long as you acknowledge the source.
-*/
-
-#ifndef MATRIX_LIB
-#define MATRIX_LIB
-
-#include<string>
-#include<algorithm>
-//#include<iostream>
-
-namespace Numeric_lib {
-
-//-----------------------------------------------------------------------------
-
-struct Matrix_error {
-    std::string name;
-    Matrix_error(const char* q) :name(q) { }
-    Matrix_error(std::string n) :name(n) { }
-};
-
-//-----------------------------------------------------------------------------
-
-inline void error(const char* p)
-{
-    throw Matrix_error(p);
-}
-
-//-----------------------------------------------------------------------------
-
-typedef long Index;    // I still dislike unsigned
-
-//-----------------------------------------------------------------------------
-
-// The general Matrix template is simply a prop for its specializations:
-template<class T = double, int D = 1> class Matrix {
-    // multidimensional matrix class
-    // ( ) does multidimensional subscripting
-    // [ ] does C style "slicing": gives an N-1 dimensional matrix from an N dimensional one
-    // row() is equivalent to [ ]
-    // column() is not (yet) implemented because it requires strides.
-    // = has copy semantics
-    // ( ) and [ ] are range checked
-    // slice() to give sub-ranges 
-private:
-    Matrix();    // this should never be compiled
-//	template<class A> Matrix(A);
-};
-
-//-----------------------------------------------------------------------------
-
-template<class T = double, int D = 1> class Row ;    // forward declaration
-
-//-----------------------------------------------------------------------------
-
-// function objects for various apply() operations:
-
-template<class T> struct Assign {
-    void operator()(T& a, const T& c) { a = c; }
-};
-
-template<class T> struct Add_assign {
-    void operator()(T& a, const T& c) { a += c; }
-};
-template<class T> struct Mul_assign {
-    void operator()(T& a, const T& c) { a *= c; }
-};
-template<class T> struct Minus_assign {
-    void operator()(T& a, const T& c) { a -= c; }
-};
-template<class T> struct Div_assign {
-    void operator()(T& a, const T& c) { a /= c; }
-};
-template<class T> struct Mod_assign {
-    void operator()(T& a, const T& c) { a %= c; }
-};
-template<class T> struct Or_assign {
-    void operator()(T& a, const T& c) { a |= c; }
-};
-template<class T> struct Xor_assign {
-    void operator()(T& a, const T& c) { a ^= c; }
-};
-template<class T> struct And_assign {
-    void operator()(T& a, const T& c) { a &= c; }
-};
-
-template<class T> struct Not_assign {
-    void operator()(T& a) { a = !a; }
-};
-
-template<class T> struct Not {
-    T operator()(T& a) { return !a; }
-};
-
-template<class T> struct Unary_minus {
-    T operator()(T& a) { return -a; }
-};
-
-template<class T> struct Complement {
-    T operator()(T& a) { return ~a; }
-};
-
-//-----------------------------------------------------------------------------
-
-// Matrix_base represents the common part of the Matrix classes:
-template<class T> class Matrix_base {
-    // matrixs store their memory (elements) in Matrix_base and have copy semantics
-    // Matrix_base does element-wise operations
-protected:
-    T* elem;    // vector? no: we couldn't easily provide a vector for a slice
-    const Index sz;    
-    mutable bool owns;
-    mutable bool xfer;
-public:
-    Matrix_base(Index n) :elem(new T[n]()), sz(n), owns(true), xfer(false)
-        // matrix of n elements (default initialized)
-    {
-        // std::cerr << "new[" << n << "]->" << elem << "\n";
-    }
-
-    Matrix_base(Index n, T* p) :elem(p), sz(n), owns(false), xfer(false)
-        // descriptor for matrix of n elements owned by someone else
-    {
-    }
-
-    ~Matrix_base()
-    {
-        if (owns) {
-            // std::cerr << "delete[" << sz << "] " << elem << "\n";
-            delete[]elem;
-        }
-    }
-
-    // if necessay, we can get to the raw matrix:
-          T* data()       { return elem; }
-    const T* data() const { return elem; }
-    Index    size() const { return sz; }
-
-    void copy_elements(const Matrix_base& a)
-    {
-        if (sz!=a.sz) error("copy_elements()");
-        for (Index i=0; i<sz; ++i) elem[i] = a.elem[i];
-    }
-
-    void base_assign(const Matrix_base& a) { copy_elements(a); }
-
-    void base_copy(const Matrix_base& a)
-    {
-        if (a.xfer) {          // a is just about to be deleted
-                               // so we can transfer ownership rather than copy
-            // std::cerr << "xfer @" << a.elem << " [" << a.sz << "]\n";
-            elem = a.elem;
-            a.xfer = false;    // note: modifies source
-            a.owns = false;
-        }
-        else {
-            elem = new T[a.sz];
-            // std::cerr << "base copy @" << a.elem << " [" << a.sz << "]\n";
-            copy_elements(a);
-        }
-        owns = true;
-        xfer = false;
-    }
-
-    // to get the elements of a local matrix out of a function without copying:
-    void base_xfer(Matrix_base& x)
-    {
-        if (owns==false) error("cannot xfer() non-owner");
-        owns = false;     // now the elements are safe from deletion by original owner
-        x.xfer = true;    // target asserts temporary ownership
-        x.owns = true;
-    }
-
-    template<class F> void base_apply(F f) { for (Index i = 0; i<size(); ++i) f(elem[i]); }
-    template<class F> void base_apply(F f, const T& c) { for (Index i = 0; i<size(); ++i) f(elem[i],c); }
-private:
-    void operator=(const Matrix_base&);    // no ordinary copy of bases
-    Matrix_base(const Matrix_base&);
-};
-
-//-----------------------------------------------------------------------------
-
-template<class T> class Matrix<T,1> : public Matrix_base<T> {
-    const Index d1;
-
-protected:
-    // for use by Row:
-    Matrix(Index n1, T* p) : Matrix_base<T>(n1,p), d1(n1)
-    {
-        // std::cerr << "construct 1D Matrix from data\n";
-    }
-
-public:
-
-    Matrix(Index n1) : Matrix_base<T>(n1), d1(n1) { }
-
-    Matrix(Row<T,1>& a) : Matrix_base<T>(a.dim1(),a.p), d1(a.dim1()) 
-    { 
-        // std::cerr << "construct 1D Matrix from Row\n";
-    }
-
-    // copy constructor: let the base do the copy:
-    Matrix(const Matrix& a) : Matrix_base<T>(a.size(),0), d1(a.d1)
-    {
-        // std::cerr << "copy ctor\n";
-        this->base_copy(a);
-    }
-
-    template<int n> 
-    Matrix(const T (&a)[n]) : Matrix_base<T>(n), d1(n)
-        // deduce "n" (and "T"), Matrix_base allocates T[n]
-    {
-        // std::cerr << "matrix ctor\n";
-        for (Index i = 0; i<n; ++i) this->elem[i]=a[i];
-    }
-
-    Matrix(const T* p, Index n) : Matrix_base<T>(n), d1(n)
-        // Matrix_base allocates T[n]
-    {
-        // std::cerr << "matrix ctor\n";
-        for (Index i = 0; i<n; ++i) this->elem[i]=p[i];
-    }
-
-    template<class F> Matrix(const Matrix& a, F f) : Matrix_base<T>(a.size()), d1(a.d1)
-        // construct a new Matrix with element's that are functions of a's elements:
-        // does not modify a unless f has been specifically programmed to modify its argument
-        // T f(const T&) would be a typical type for f
-    {
-        for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i]); 
-    }
-
-    template<class F, class Arg> Matrix(const Matrix& a, F f, const Arg& t1) : Matrix_base<T>(a.size()), d1(a.d1)
-        // construct a new Matrix with element's that are functions of a's elements:
-        // does not modify a unless f has been specifically programmed to modify its argument
-        // T f(const T&, const Arg&) would be a typical type for f
-    {
-        for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i],t1); 
-    }
-
-    Matrix& operator=(const Matrix& a)
-        // copy assignment: let the base do the copy
-    {
-        // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<< ")\n";
-        if (d1!=a.d1) error("length error in 1D=");
-        this->base_assign(a);
-        return *this;
-    }
-
-    ~Matrix() { }
-
-    Index dim1() const { return d1; }    // number of elements in a row
-
-    Matrix xfer()    // make an Matrix to move elements out of a scope
-    {
-        Matrix x(dim1(),this->data()); // make a descriptor
-        this->base_xfer(x);                  // transfer (temporary) ownership to x
-        return x;
-    }
-
-    void range_check(Index n1) const
-    {
-        // std::cerr << "range check: (" << d1 << "): " << n1 << "\n"; 
-        if (n1<0 || d1<=n1) error("1D range error: dimension 1");
-    }
-
-    // subscripting:
-          T& operator()(Index n1)       { range_check(n1); return this->elem[n1]; }
-    const T& operator()(Index n1) const { range_check(n1); return this->elem[n1]; }
-
-    // slicing (the same as subscripting for 1D matrixs):
-          T& operator[](Index n)       { return row(n); }
-    const T& operator[](Index n) const { return row(n); }
-
-          T& row(Index n)       { range_check(n); return this->elem[n]; }
-    const T& row(Index n) const { range_check(n); return this->elem[n]; }
-
-    Row<T,1> slice(Index n)
-        // the last elements from a[n] onwards
-    {
-        if (n<0) n=0;
-        else if(d1<n) n=d1;// one beyond the end
-        return Row<T,1>(d1-n,this->elem+n);
-    }
-
-    const Row<T,1> slice(Index n) const
-        // the last elements from a[n] onwards
-    {
-        if (n<0) n=0;
-        else if(d1<n) n=d1;// one beyond the end
-        return Row<T,1>(d1-n,this->elem+n);
-    }
-
-    Row<T,1> slice(Index n, Index m)
-        // m elements starting with a[n]
-    {
-        if (n<0) n=0;
-        else if(d1<n) n=d1;    // one beyond the end
-        if (m<0) m = 0;
-        else if (d1<n+m) m=d1-n;
-        return Row<T,1>(m,this->elem+n);
-    }
-
-    const Row<T,1> slice(Index n, Index m) const
-        // m elements starting with a[n]
-    {
-        if (n<0) n=0;
-        else if(d1<n) n=d1;    // one beyond the end
-        if (m<0) m = 0;
-        else if (d1<n+m) m=d1-n;
-        return Row<T,1>(m,this->elem+n);
-    }
-
-    // element-wise operations:
-    template<class F> Matrix& apply(F f) { this->base_apply(f); return *this; }
-    template<class F> Matrix& apply(F f,const T& c) { this->base_apply(f,c); return *this; }
-
-    Matrix& operator=(const T& c)  { this->base_apply(Assign<T>(),c);       return *this; }
-
-    Matrix& operator*=(const T& c) { this->base_apply(Mul_assign<T>(),c);   return *this; }
-    Matrix& operator/=(const T& c) { this->base_apply(Div_assign<T>(),c);   return *this; }
-    Matrix& operator%=(const T& c) { this->base_apply(Mod_assign<T>(),c);   return *this; }
-    Matrix& operator+=(const T& c) { this->base_apply(Add_assign<T>(),c);   return *this; }
-    Matrix& operator-=(const T& c) { this->base_apply(Minus_assign<T>(),c); return *this; }
-
-    Matrix& operator&=(const T& c) { this->base_apply(And_assign<T>(),c);   return *this; }
-    Matrix& operator|=(const T& c) { this->base_apply(Or_assign<T>(),c);    return *this; }
-    Matrix& operator^=(const T& c) { this->base_apply(Xor_assign<T>(),c);   return *this; }
-
-    Matrix operator!() { return xfer(Matrix(*this,Not<T>())); }
-    Matrix operator-() { return xfer(Matrix(*this,Unary_minus<T>())); }
-    Matrix operator~() { return xfer(Matrix(*this,Complement<T>()));  }
-
-    template<class F> Matrix apply_new(F f) { return xfer(Matrix(*this,f)); }
-    
-    void swap_rows(Index i, Index j)
-        // swap_rows() uses a row's worth of memory for better run-time performance
-        // if you want pairwise swap, just write it yourself
-    {
-        if (i == j) return;
-    /*
-        Matrix<T,1> temp = (*this)[i];
-        (*this)[i] = (*this)[j];
-        (*this)[j] = temp;
-    */
-        Index max = (*this)[i].size();
-        for (Index ii=0; ii<max; ++ii) std::swap((*this)(i,ii),(*this)(j,ii));
-    }
-};
-
-//-----------------------------------------------------------------------------
-
-template<class T> class Matrix<T,2> : public Matrix_base<T> {
-    const Index d1;
-    const Index d2;
-
-protected:
-    // for use by Row:
-    Matrix(Index n1, Index n2, T* p) : Matrix_base<T>(n1*n2,p), d1(n1), d2(n2) 
-    {
-       //  std::cerr << "construct 3D Matrix from data\n";
-    }
-
-public:
-
-    Matrix(Index n1, Index n2) : Matrix_base<T>(n1*n2), d1(n1), d2(n2) { }
-
-    Matrix(Row<T,2>& a) : Matrix_base<T>(a.dim1()*a.dim2(),a.p), d1(a.dim1()), d2(a.dim2())
-    { 
-       // std::cerr << "construct 2D Matrix from Row\n";
-    }
-
-    // copy constructor: let the base do the copy:
-    Matrix(const Matrix& a) : Matrix_base<T>(a.size(),0), d1(a.d1), d2(a.d2)
-    {
-        // std::cerr << "copy ctor\n";
-        this->base_copy(a);
-    }
-
-    template<int n1, int n2> 
-    Matrix(const T (&a)[n1][n2]) : Matrix_base<T>(n1*n2), d1(n1), d2(n2)
-        // deduce "n1", "n2" (and "T"), Matrix_base allocates T[n1*n2]
-    {
-        // std::cerr << "matrix ctor (" << n1 << "," << n2 << ")\n";
-        for (Index i = 0; i<n1; ++i)
-            for (Index j = 0; j<n2; ++j) this->elem[i*n2+j]=a[i][j];
-    }
-
-    template<class F> Matrix(const Matrix& a, F f) : Matrix_base<T>(a.size()), d1(a.d1), d2(a.d2)
-        // construct a new Matrix with element's that are functions of a's elements:
-        // does not modify a unless f has been specifically programmed to modify its argument
-        // T f(const T&) would be a typical type for f
-    {
-        for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i]); 
-    }
-
-    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)
-        // construct a new Matrix with element's that are functions of a's elements:
-        // does not modify a unless f has been specifically programmed to modify its argument
-        // T f(const T&, const Arg&) would be a typical type for f
-    {
-        for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i],t1); 
-    }
-
-    Matrix& operator=(const Matrix& a)
-        // copy assignment: let the base do the copy
-    {
-        // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<< ")\n";
-        if (d1!=a.d1 || d2!=a.d2) error("length error in 2D =");
-        this->base_assign(a);
-        return *this;
-    }
-
-    ~Matrix() { }
-    
-    Index dim1() const { return d1; }    // number of elements in a row
-    Index dim2() const { return d2; }    // number of elements in a column
-
-    Matrix xfer()    // make an Matrix to move elements out of a scope
-    {
-        Matrix x(dim1(),dim2(),this->data()); // make a descriptor
-        this->base_xfer(x);            // transfer (temporary) ownership to x
-        return x;
-    }
-
-    void range_check(Index n1, Index n2) const
-    {
-        // std::cerr << "range check: (" << d1 << "," << d2 << "): " << n1 << " " << n2 << "\n";
-        if (n1<0 || d1<=n1) error("2D range error: dimension 1");
-        if (n2<0 || d2<=n2) error("2D range error: dimension 2");
-    }
-
-    // subscripting:
-          T& operator()(Index n1, Index n2)       { range_check(n1,n2); return this->elem[n1*d2+n2]; }
-    const T& operator()(Index n1, Index n2) const { range_check(n1,n2); return this->elem[n1*d2+n2]; }
-
-    // slicing (return a row):
-          Row<T,1> operator[](Index n)       { return row(n); }
-    const Row<T,1> operator[](Index n) const { return row(n); }
-
-          Row<T,1> row(Index n)       { range_check(n,0); return Row<T,1>(d2,&this->elem[n*d2]); }
-    const Row<T,1> row(Index n) const { range_check(n,0); return Row<T,1>(d2,&this->elem[n*d2]); }
-
-    Row<T,2> slice(Index n)
-        // rows [n:d1)
-    {
-        if (n<0) n=0;
-        else if(d1<n) n=d1;    // one beyond the end
-        return Row<T,2>(d1-n,d2,this->elem+n*d2);
-    }
-
-    const Row<T,2> slice(Index n) const
-        // rows [n:d1)
-    {
-        if (n<0) n=0;
-        else if(d1<n) n=d1;    // one beyond the end
-        return Row<T,2>(d1-n,d2,this->elem+n*d2);
-    }
-
-    Row<T,2> slice(Index n, Index m)
-        // the rows [n:m)
-    {
-        if (n<0) n=0;
-        if(d1<m) m=d1;    // one beyond the end
-        return Row<T,2>(m-n,d2,this->elem+n*d2);
-
-    }
-
-    const Row<T,2> slice(Index n, Index m) const
-        // the rows [n:sz)
-    {
-        if (n<0) n=0;
-        if(d1<m) m=d1;    // one beyond the end
-        return Row<T,2>(m-n,d2,this->elem+n*d2);
-    }
-
-    // Column<T,1> column(Index n); // not (yet) implemented: requies strides and operations on columns
-
-    // element-wise operations:
-    template<class F> Matrix& apply(F f)            { this->base_apply(f);   return *this; }
-    template<class F> Matrix& apply(F f,const T& c) { this->base_apply(f,c); return *this; }
-
-    Matrix& operator=(const T& c)  { this->base_apply(Assign<T>(),c);       return *this; }
-
-    Matrix& operator*=(const T& c) { this->base_apply(Mul_assign<T>(),c);   return *this; }
-    Matrix& operator/=(const T& c) { this->base_apply(Div_assign<T>(),c);   return *this; }
-    Matrix& operator%=(const T& c) { this->base_apply(Mod_assign<T>(),c);   return *this; }
-    Matrix& operator+=(const T& c) { this->base_apply(Add_assign<T>(),c);   return *this; }
-    Matrix& operator-=(const T& c) { this->base_apply(Minus_assign<T>(),c); return *this; }
-
-    Matrix& operator&=(const T& c) { this->base_apply(And_assign<T>(),c);   return *this; }
-    Matrix& operator|=(const T& c) { this->base_apply(Or_assign<T>(),c);    return *this; }
-    Matrix& operator^=(const T& c) { this->base_apply(Xor_assign<T>(),c);   return *this; }
-
-    Matrix operator!() { return xfer(Matrix(*this,Not<T>())); }
-    Matrix operator-() { return xfer(Matrix(*this,Unary_minus<T>())); }
-    Matrix operator~() { return xfer(Matrix(*this,Complement<T>()));  }
-
-    template<class F> Matrix apply_new(F f) { return xfer(Matrix(*this,f)); }
-    
-    void swap_rows(Index i, Index j)
-        // swap_rows() uses a row's worth of memory for better run-time performance
-        // if you want pairwise swap, just write it yourself
-    {
-        if (i == j) return;
-    /*
-        Matrix<T,1> temp = (*this)[i];
-        (*this)[i] = (*this)[j];
-        (*this)[j] = temp;
-    */
-        Index max = (*this)[i].size();
-        for (Index ii=0; ii<max; ++ii) std::swap((*this)(i,ii),(*this)(j,ii));
-    }
-};
-
-//-----------------------------------------------------------------------------
-
-template<class T> class Matrix<T,3> : public Matrix_base<T> {
-    const Index d1;
-    const Index d2;
-    const Index d3;
-
-protected:
-    // for use by Row:
-    Matrix(Index n1, Index n2, Index n3, T* p) : Matrix_base<T>(n1*n2*n3,p), d1(n1), d2(n2), d3(n3) 
-    {
-        // std::cerr << "construct 3D Matrix from data\n";
-    }
-
-public:
-
-    Matrix(Index n1, Index n2, Index n3) : Matrix_base<T>(n1*n2*n3), d1(n1), d2(n2), d3(n3) { }
-
-    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())
-    { 
-        // std::cerr << "construct 3D Matrix from Row\n";
-    }
-
-    // copy constructor: let the base do the copy:
-    Matrix(const Matrix& a) : Matrix_base<T>(a.size(),0), d1(a.d1), d2(a.d2), d3(a.d3)
-    {
-        // std::cerr << "copy ctor\n";
-        this->base_copy(a);
-    }
-
-    template<int n1, int n2, int n3> 
-    Matrix(const T (&a)[n1][n2][n3]) : Matrix_base<T>(n1*n2), d1(n1), d2(n2), d3(n3)
-        // deduce "n1", "n2", "n3" (and "T"), Matrix_base allocates T[n1*n2*n3]
-    {
-        // std::cerr << "matrix ctor\n";
-        for (Index i = 0; i<n1; ++i)
-            for (Index j = 0; j<n2; ++j)
-                for (Index k = 0; k<n3; ++k)
-                    this->elem[i*n2*n3+j*n3+k]=a[i][j][k];
-    }
-
-    template<class F> Matrix(const Matrix& a, F f) : Matrix_base<T>(a.size()), d1(a.d1), d2(a.d2), d3(a.d3)
-        // construct a new Matrix with element's that are functions of a's elements:
-        // does not modify a unless f has been specifically programmed to modify its argument
-        // T f(const T&) would be a typical type for f
-    {
-        for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i]); 
-    }
-
-    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)
-        // construct a new Matrix with element's that are functions of a's elements:
-        // does not modify a unless f has been specifically programmed to modify its argument
-        // T f(const T&, const Arg&) would be a typical type for f
-    {
-        for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i],t1); 
-    }
-
-    Matrix& operator=(const Matrix& a)
-        // copy assignment: let the base do the copy
-    {
-        // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<< ")\n";
-        if (d1!=a.d1 || d2!=a.d2 || d3!=a.d3) error("length error in 2D =");
-        this->base_assign(a);
-        return *this;
-    }
-
-    ~Matrix() { }
-
-    Index dim1() const { return d1; }    // number of elements in a row
-    Index dim2() const { return d2; }    // number of elements in a column
-    Index dim3() const { return d3; }    // number of elements in a depth
-
-    Matrix xfer()    // make an Matrix to move elements out of a scope
-    {
-        Matrix x(dim1(),dim2(),dim3(),this->data()); // make a descriptor
-        this->base_xfer(x);            // transfer (temporary) ownership to x
-        return x;
-    }
-
-    void range_check(Index n1, Index n2, Index n3) const
-    {
-        // std::cerr << "range check: (" << d1 << "," << d2 << "): " << n1 << " " << n2 << "\n";
-        if (n1<0 || d1<=n1) error("3D range error: dimension 1");
-        if (n2<0 || d2<=n2) error("3D range error: dimension 2");
-        if (n3<0 || d3<=n3) error("3D range error: dimension 3");
-    }
-
-    // subscripting:
-          T& operator()(Index n1, Index n2, Index n3)       { range_check(n1,n2,n3); return this->elem[d2*d3*n1+d3*n2+n3]; }; 
-    const T& operator()(Index n1, Index n2, Index n3) const { range_check(n1,n2,n3); return this->elem[d2*d3*n1+d3*n2+n3]; };
-
-    // slicing (return a row):
-          Row<T,2> operator[](Index n)       { return row(n); }
-    const Row<T,2> operator[](Index n) const { return row(n); }
-
-          Row<T,2> row(Index n)       { range_check(n,0,0); return Row<T,2>(d2,d3,&this->elem[n*d2*d3]); }
-    const Row<T,2> row(Index n) const { range_check(n,0,0); return Row<T,2>(d2,d3,&this->elem[n*d2*d3]); }
-
-    Row<T,3> slice(Index n)
-        // rows [n:d1)
-    {
-        if (n<0) n=0;
-        else if(d1<n) n=d1;    // one beyond the end
-        return Row<T,3>(d1-n,d2,d3,this->elem+n*d2*d3);
-    }
-
-    const Row<T,3> slice(Index n) const
-        // rows [n:d1)
-    {
-        if (n<0) n=0;
-        else if(d1<n) n=d1;    // one beyond the end
-        return Row<T,3>(d1-n,d2,d3,this->elem+n*d2*d3);
-    }
-
-    Row<T,3> slice(Index n, Index m)
-        // the rows [n:m)
-    {
-        if (n<0) n=0;
-        if(d1<m) m=d1;    // one beyond the end
-        return Row<T,3>(m-n,d2,d3,this->elem+n*d2*d3);
-
-    }
-
-    const Row<T,3> slice(Index n, Index m) const
-        // the rows [n:sz)
-    {
-        if (n<0) n=0;
-        if(d1<m) m=d1;    // one beyond the end
-        return Row<T,3>(m-n,d2,d3,this->elem+n*d2*d3);
-    }
-
-    // Column<T,2> column(Index n); // not (yet) implemented: requies strides and operations on columns
-
-    // element-wise operations:
-    template<class F> Matrix& apply(F f)            { this->base_apply(f);   return *this; }
-    template<class F> Matrix& apply(F f,const T& c) { this->base_apply(f,c); return *this; }
-
-    Matrix& operator=(const T& c)  { this->base_apply(Assign<T>(),c);       return *this; }
-                                                                            
-    Matrix& operator*=(const T& c) { this->base_apply(Mul_assign<T>(),c);   return *this; }
-    Matrix& operator/=(const T& c) { this->base_apply(Div_assign<T>(),c);   return *this; }
-    Matrix& operator%=(const T& c) { this->base_apply(Mod_assign<T>(),c);   return *this; }
-    Matrix& operator+=(const T& c) { this->base_apply(Add_assign<T>(),c);   return *this; }
-    Matrix& operator-=(const T& c) { this->base_apply(Minus_assign<T>(),c); return *this; }
-
-    Matrix& operator&=(const T& c) { this->base_apply(And_assign<T>(),c);   return *this; }
-    Matrix& operator|=(const T& c) { this->base_apply(Or_assign<T>(),c);    return *this; }
-    Matrix& operator^=(const T& c) { this->base_apply(Xor_assign<T>(),c);   return *this; }
-
-    Matrix operator!() { return xfer(Matrix(*this,Not<T>())); }
-    Matrix operator-() { return xfer(Matrix(*this,Unary_minus<T>())); }
-    Matrix operator~() { return xfer(Matrix(*this,Complement<T>()));  }
-
-    template<class F> Matrix apply_new(F f) { return xfer(Matrix(*this,f)); }
-    
-    void swap_rows(Index i, Index j)
-        // swap_rows() uses a row's worth of memory for better run-time performance
-        // if you want pairwise swap, just write it yourself
-    {
-        if (i == j) return;
-        
-        Matrix<T,2> temp = (*this)[i];
-        (*this)[i] = (*this)[j];
-        (*this)[j] = temp;
-    }
-};
-
-//-----------------------------------------------------------------------------
-
-template<class T> Matrix<T> scale_and_add(const Matrix<T>& a, T c, const Matrix<T>& b)
-    //  Fortran "saxpy()" ("fma" for "fused multiply-add").
-    // will the copy constructor be called twice and defeat the xfer optimization?
-{
-    if (a.size() != b.size()) error("sizes wrong for scale_and_add()");
-    Matrix<T> res(a.size());
-    for (Index i = 0; i<a.size(); ++i) res[i] += a[i]*c+b[i];
-    return res.xfer();
-}
-
-//-----------------------------------------------------------------------------
-
-template<class T> T dot_product(const Matrix<T>&a , const Matrix<T>& b)
-{
-    if (a.size() != b.size()) error("sizes wrong for dot product");
-    T sum = 0;
-    for (Index i = 0; i<a.size(); ++i) sum += a[i]*b[i];
-    return sum;
-}
-
-//-----------------------------------------------------------------------------
-
-template<class T, int N> Matrix<T,N> xfer(Matrix<T,N>& a)
-{
-    return a.xfer();
-}
-
-//-----------------------------------------------------------------------------
-
-template<class F, class A>            A apply(F f, A x)        { A res(x,f);   return xfer(res); }
-template<class F, class Arg, class A> A apply(F f, A x, Arg a) { A res(x,f,a); return xfer(res); }
-
-//-----------------------------------------------------------------------------
-
-// The default values for T and D have been declared before.
-template<class T, int D> class Row {
-    // general version exists only to allow specializations
-private:
-        Row();
-};
-
-//-----------------------------------------------------------------------------
-
-template<class T> class Row<T,1> : public Matrix<T,1> {
-public:
-    Row(Index n, T* p) : Matrix<T,1>(n,p)
-    {
-    }
-
-    Matrix<T,1>& operator=(const T& c) { this->base_apply(Assign<T>(),c); return *this; }
-
-    Matrix<T,1>& operator=(const Matrix<T,1>& a)
-    {
-        return *static_cast<Matrix<T,1>*>(this)=a;
-    }
-};
-
-//-----------------------------------------------------------------------------
-
-template<class T> class Row<T,2> : public Matrix<T,2> {
-public:
-    Row(Index n1, Index n2, T* p) : Matrix<T,2>(n1,n2,p)
-    {
-    }
-        
-    Matrix<T,2>& operator=(const T& c) { this->base_apply(Assign<T>(),c); return *this; }
-
-    Matrix<T,2>& operator=(const Matrix<T,2>& a)
-    {
-        return *static_cast<Matrix<T,2>*>(this)=a;
-    }
-};
-
-//-----------------------------------------------------------------------------
-
-template<class T> class Row<T,3> : public Matrix<T,3> {
-public:
-    Row(Index n1, Index n2, Index n3, T* p) : Matrix<T,3>(n1,n2,n3,p)
-    {
-    }
-
-    Matrix<T,3>& operator=(const T& c) { this->base_apply(Assign<T>(),c); return *this; }
-
-    Matrix<T,3>& operator=(const Matrix<T,3>& a)
-    {
-        return *static_cast<Matrix<T,3>*>(this)=a;
-    }
-};
-
-//-----------------------------------------------------------------------------
-
-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)
-{
-    Matrix<T> res(a.size());
-    if (a.size() != b.size()) error("sizes wrong for scale_and_add");
-    for (Index i = 0; i<a.size(); ++i) res[i] += a[i]*c+b[i];
-    return res.xfer();
-}
-
-//-----------------------------------------------------------------------------
-
-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; }
-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; }
-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; }
-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; }
-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; }
-
-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; }
-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; }
-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; }
-
-//-----------------------------------------------------------------------------
-
-}
-#endif
diff --git a/Matrix11.h b/Matrix11.h
deleted file mode 100644
index 63069d8..0000000
--- a/Matrix11.h
+++ /dev/null
@@ -1,806 +0,0 @@
-
-/*
-    warning: this small multidimensional matrix library uses a few features
-    not taught in ENGR112 and not explained in elementary textbooks
-
-	C++11 version
-
-    (c) Bjarne Stroustrup, Texas A&M University. 
-
-    Use as you like as long as you acknowledge the source.
-*/
-
-#ifndef MATRIX_LIB
-#define MATRIX_LIB
-
-#include<string>
-#include<algorithm>
-//#include<iostream>
-
-namespace Numeric_lib {
-
-//-----------------------------------------------------------------------------
-
-struct Matrix_error {
-    std::string name;
-    Matrix_error(const char* q) :name(q) { }
-    Matrix_error(std::string n) :name(n) { }
-};
-
-//-----------------------------------------------------------------------------
-
-inline void error(const char* p)
-{
-    throw Matrix_error(p);
-}
-
-//-----------------------------------------------------------------------------
-
-typedef long Index;    // I still dislike unsigned
-
-//-----------------------------------------------------------------------------
-
-// The general Matrix template is simply a prop for its specializations:
-template<class T = double, int D = 1> class Matrix {
-    // multidimensional matrix class
-    // ( ) does multidimensional subscripting
-    // [ ] does C style "slicing": gives an N-1 dimensional matrix from an N dimensional one
-    // row() is equivalent to [ ]
-    // column() is not (yet) implemented because it requires strides.
-    // = has copy semantics
-    // ( ) and [ ] are range checked
-    // slice() to give sub-ranges 
-private:
-    Matrix();    // this should never be compiled
-//	template<class A> Matrix(A);
-};
-
-//-----------------------------------------------------------------------------
-
-template<class T = double, int D = 1> class Row ;    // forward declaration
-
-//-----------------------------------------------------------------------------
-
-// function objects for various apply() operations:
-
-template<class T> struct Assign {
-    void operator()(T& a, const T& c) { a = c; }
-};
-
-template<class T> struct Add_assign {
-    void operator()(T& a, const T& c) { a += c; }
-};
-template<class T> struct Mul_assign {
-    void operator()(T& a, const T& c) { a *= c; }
-};
-template<class T> struct Minus_assign {
-    void operator()(T& a, const T& c) { a -= c; }
-};
-template<class T> struct Div_assign {
-    void operator()(T& a, const T& c) { a /= c; }
-};
-template<class T> struct Mod_assign {
-    void operator()(T& a, const T& c) { a %= c; }
-};
-template<class T> struct Or_assign {
-    void operator()(T& a, const T& c) { a |= c; }
-};
-template<class T> struct Xor_assign {
-    void operator()(T& a, const T& c) { a ^= c; }
-};
-template<class T> struct And_assign {
-    void operator()(T& a, const T& c) { a &= c; }
-};
-
-template<class T> struct Not_assign {
-    void operator()(T& a) { a = !a; }
-};
-
-template<class T> struct Not {
-    T operator()(T& a) { return !a; }
-};
-
-template<class T> struct Unary_minus {
-    T operator()(T& a) { return -a; }
-};
-
-template<class T> struct Complement {
-    T operator()(T& a) { return ~a; }
-};
-
-//-----------------------------------------------------------------------------
-
-// Matrix_base represents the common part of the Matrix classes:
-template<class T> class Matrix_base {
-    // matrixs store their memory (elements) in Matrix_base and have copy semantics
-    // Matrix_base does element-wise operations
-protected:
-    T* elem;    // vector? no: we couldn't easily provide a vector for a slice
-    const Index sz;    
-    mutable bool owns;
-    mutable bool xfer;
-public:
-    Matrix_base(Index n) :elem(new T[n]()), sz(n), owns(true), xfer(false)
-        // matrix of n elements (default initialized)
-    {
-        // std::cerr << "new[" << n << "]->" << elem << "\n";
-    }
-
-    Matrix_base(Index n, T* p) :elem(p), sz(n), owns(false), xfer(false)
-        // descriptor for matrix of n elements owned by someone else
-    {
-    }
-
-    ~Matrix_base()
-    {
-        if (owns) {
-            // std::cerr << "delete[" << sz << "] " << elem << "\n";
-            delete[]elem;
-        }
-    }
-
-    // if necessay, we can get to the raw matrix:
-          T* data()       { return elem; }
-    const T* data() const { return elem; }
-    Index    size() const { return sz; }
-
-    void copy_elements(const Matrix_base& a)
-    {
-        if (sz!=a.sz) error("copy_elements()");
-        for (Index i=0; i<sz; ++i) elem[i] = a.elem[i];
-    }
-
-    void base_assign(const Matrix_base& a) { copy_elements(a); }
-
-    void base_copy(const Matrix_base& a)
-    {
-        if (a.xfer) {          // a is just about to be deleted
-                               // so we can transfer ownership rather than copy
-            // std::cerr << "xfer @" << a.elem << " [" << a.sz << "]\n";
-            elem = a.elem;
-            a.xfer = false;    // note: modifies source
-            a.owns = false;
-        }
-        else {
-            elem = new T[a.sz];
-            // std::cerr << "base copy @" << a.elem << " [" << a.sz << "]\n";
-            copy_elements(a);
-        }
-        owns = true;
-        xfer = false;
-    }
-
-    // to get the elements of a local matrix out of a function without copying:
-    void base_xfer(Matrix_base& x)
-    {
-        if (owns==false) error("cannot xfer() non-owner");
-        owns = false;     // now the elements are safe from deletion by original owner
-        x.xfer = true;    // target asserts temporary ownership
-        x.owns = true;
-    }
-
-    template<class F> void base_apply(F f) { for (Index i = 0; i<size(); ++i) f(elem[i]); }
-    template<class F> void base_apply(F f, const T& c) { for (Index i = 0; i<size(); ++i) f(elem[i],c); }
-private:
-    void operator=(const Matrix_base&);    // no ordinary copy of bases
-    Matrix_base(const Matrix_base&);
-};
-
-//-----------------------------------------------------------------------------
-
-template<class T> class Matrix<T,1> : public Matrix_base<T> {
-    const Index d1;
-
-protected:
-    // for use by Row:
-    Matrix(Index n1, T* p) : Matrix_base<T>(n1,p), d1(n1)
-    {
-        // std::cerr << "construct 1D Matrix from data\n";
-    }
-
-public:
-
-    Matrix(Index n1) : Matrix_base<T>(n1), d1(n1) { }
-
-    Matrix(Row<T,1>& a) : Matrix_base<T>(a.dim1(),a.p), d1(a.dim1()) 
-    { 
-        // std::cerr << "construct 1D Matrix from Row\n";
-    }
-
-    // copy constructor: let the base do the copy:
-    Matrix(const Matrix& a) : Matrix_base<T>(a.size(),0), d1(a.d1)
-    {
-        // std::cerr << "copy ctor\n";
-        this->base_copy(a);
-    }
-
-    template<int n> 
-    Matrix(const T (&a)[n]) : Matrix_base<T>(n), d1(n)
-        // deduce "n" (and "T"), Matrix_base allocates T[n]
-    {
-        // std::cerr << "matrix ctor\n";
-        for (Index i = 0; i<n; ++i) this->elem[i]=a[i];
-    }
-
-    Matrix(const T* p, Index n) : Matrix_base<T>(n), d1(n)
-        // Matrix_base allocates T[n]
-    {
-        // std::cerr << "matrix ctor\n";
-        for (Index i = 0; i<n; ++i) this->elem[i]=p[i];
-    }
-
-    template<class F> Matrix(const Matrix& a, F f) : Matrix_base<T>(a.size()), d1(a.d1)
-        // construct a new Matrix with element's that are functions of a's elements:
-        // does not modify a unless f has been specifically programmed to modify its argument
-        // T f(const T&) would be a typical type for f
-    {
-        for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i]); 
-    }
-
-    template<class F, class Arg> Matrix(const Matrix& a, F f, const Arg& t1) : Matrix_base<T>(a.size()), d1(a.d1)
-        // construct a new Matrix with element's that are functions of a's elements:
-        // does not modify a unless f has been specifically programmed to modify its argument
-        // T f(const T&, const Arg&) would be a typical type for f
-    {
-        for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i],t1); 
-    }
-
-    Matrix& operator=(const Matrix& a)
-        // copy assignment: let the base do the copy
-    {
-        // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<< ")\n";
-        if (d1!=a.d1) error("length error in 1D=");
-        this->base_assign(a);
-        return *this;
-    }
-
-    ~Matrix() { }
-
-    Index dim1() const { return d1; }    // number of elements in a row
-
-    Matrix xfer()    // make an Matrix to move elements out of a scope
-    {
-        Matrix x(dim1(),this->data()); // make a descriptor
-        this->base_xfer(x);                  // transfer (temporary) ownership to x
-        return x;
-    }
-
-    void range_check(Index n1) const
-    {
-        // std::cerr << "range check: (" << d1 << "): " << n1 << "\n"; 
-        if (n1<0 || d1<=n1) error("1D range error: dimension 1");
-    }
-
-    // subscripting:
-          T& operator()(Index n1)       { range_check(n1); return this->elem[n1]; }
-    const T& operator()(Index n1) const { range_check(n1); return this->elem[n1]; }
-
-    // slicing (the same as subscripting for 1D matrixs):
-          T& operator[](Index n)       { return row(n); }
-    const T& operator[](Index n) const { return row(n); }
-
-          T& row(Index n)       { range_check(n); return this->elem[n]; }
-    const T& row(Index n) const { range_check(n); return this->elem[n]; }
-
-    Row<T,1> slice(Index n)
-        // the last elements from a[n] onwards
-    {
-        if (n<0) n=0;
-        else if(d1<n) n=d1;// one beyond the end
-        return Row<T,1>(d1-n,this->elem+n);
-    }
-
-    const Row<T,1> slice(Index n) const
-        // the last elements from a[n] onwards
-    {
-        if (n<0) n=0;
-        else if(d1<n) n=d1;// one beyond the end
-        return Row<T,1>(d1-n,this->elem+n);
-    }
-
-    Row<T,1> slice(Index n, Index m)
-        // m elements starting with a[n]
-    {
-        if (n<0) n=0;
-        else if(d1<n) n=d1;    // one beyond the end
-        if (m<0) m = 0;
-        else if (d1<n+m) m=d1-n;
-        return Row<T,1>(m,this->elem+n);
-    }
-
-    const Row<T,1> slice(Index n, Index m) const
-        // m elements starting with a[n]
-    {
-        if (n<0) n=0;
-        else if(d1<n) n=d1;    // one beyond the end
-        if (m<0) m = 0;
-        else if (d1<n+m) m=d1-n;
-        return Row<T,1>(m,this->elem+n);
-    }
-
-    // element-wise operations:
-    template<class F> Matrix& apply(F f) { this->base_apply(f); return *this; }
-    template<class F> Matrix& apply(F f,const T& c) { this->base_apply(f,c); return *this; }
-
-    Matrix& operator=(const T& c)  { this->base_apply(Assign<T>(),c);       return *this; }
-
-    Matrix& operator*=(const T& c) { this->base_apply(Mul_assign<T>(),c);   return *this; }
-    Matrix& operator/=(const T& c) { this->base_apply(Div_assign<T>(),c);   return *this; }
-    Matrix& operator%=(const T& c) { this->base_apply(Mod_assign<T>(),c);   return *this; }
-    Matrix& operator+=(const T& c) { this->base_apply(Add_assign<T>(),c);   return *this; }
-    Matrix& operator-=(const T& c) { this->base_apply(Minus_assign<T>(),c); return *this; }
-
-    Matrix& operator&=(const T& c) { this->base_apply(And_assign<T>(),c);   return *this; }
-    Matrix& operator|=(const T& c) { this->base_apply(Or_assign<T>(),c);    return *this; }
-    Matrix& operator^=(const T& c) { this->base_apply(Xor_assign<T>(),c);   return *this; }
-
-    Matrix operator!() { return xfer(Matrix(*this,Not<T>())); }
-    Matrix operator-() { return xfer(Matrix(*this,Unary_minus<T>())); }
-    Matrix operator~() { return xfer(Matrix(*this,Complement<T>()));  }
-
-    template<class F> Matrix apply_new(F f) { return xfer(Matrix(*this,f)); }
-    
-    void swap_rows(Index i, Index j)
-        // swap_rows() uses a row's worth of memory for better run-time performance
-        // if you want pairwise swap, just write it yourself
-    {
-        if (i == j) return;
-    /*
-        Matrix<T,1> temp = (*this)[i];
-        (*this)[i] = (*this)[j];
-        (*this)[j] = temp;
-    */
-        Index max = (*this)[i].size();
-        for (Index ii=0; ii<max; ++ii) std::swap((*this)(i,ii),(*this)(j,ii));
-    }
-};
-
-//-----------------------------------------------------------------------------
-
-template<class T> class Matrix<T,2> : public Matrix_base<T> {
-    const Index d1;
-    const Index d2;
-
-protected:
-    // for use by Row:
-    Matrix(Index n1, Index n2, T* p) : Matrix_base<T>(n1*n2,p), d1(n1), d2(n2) 
-    {
-       //  std::cerr << "construct 3D Matrix from data\n";
-    }
-
-public:
-
-    Matrix(Index n1, Index n2) : Matrix_base<T>(n1*n2), d1(n1), d2(n2) { }
-
-    Matrix(Row<T,2>& a) : Matrix_base<T>(a.dim1()*a.dim2(),a.p), d1(a.dim1()), d2(a.dim2())
-    { 
-       // std::cerr << "construct 2D Matrix from Row\n";
-    }
-
-    // copy constructor: let the base do the copy:
-    Matrix(const Matrix& a) : Matrix_base<T>(a.size(),0), d1(a.d1), d2(a.d2)
-    {
-        // std::cerr << "copy ctor\n";
-        this->base_copy(a);
-    }
-
-    template<int n1, int n2> 
-    Matrix(const T (&a)[n1][n2]) : Matrix_base<T>(n1*n2), d1(n1), d2(n2)
-        // deduce "n1", "n2" (and "T"), Matrix_base allocates T[n1*n2]
-    {
-        // std::cerr << "matrix ctor (" << n1 << "," << n2 << ")\n";
-        for (Index i = 0; i<n1; ++i)
-            for (Index j = 0; j<n2; ++j) this->elem[i*n2+j]=a[i][j];
-    }
-
-    template<class F> Matrix(const Matrix& a, F f) : Matrix_base<T>(a.size()), d1(a.d1), d2(a.d2)
-        // construct a new Matrix with element's that are functions of a's elements:
-        // does not modify a unless f has been specifically programmed to modify its argument
-        // T f(const T&) would be a typical type for f
-    {
-        for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i]); 
-    }
-
-    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)
-        // construct a new Matrix with element's that are functions of a's elements:
-        // does not modify a unless f has been specifically programmed to modify its argument
-        // T f(const T&, const Arg&) would be a typical type for f
-    {
-        for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i],t1); 
-    }
-
-    Matrix& operator=(const Matrix& a)
-        // copy assignment: let the base do the copy
-    {
-        // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<< ")\n";
-        if (d1!=a.d1 || d2!=a.d2) error("length error in 2D =");
-        this->base_assign(a);
-        return *this;
-    }
-
-    ~Matrix() { }
-    
-    Index dim1() const { return d1; }    // number of elements in a row
-    Index dim2() const { return d2; }    // number of elements in a column
-
-    Matrix xfer()    // make an Matrix to move elements out of a scope
-    {
-        Matrix x(dim1(),dim2(),this->data()); // make a descriptor
-        this->base_xfer(x);            // transfer (temporary) ownership to x
-        return x;
-    }
-
-    void range_check(Index n1, Index n2) const
-    {
-        // std::cerr << "range check: (" << d1 << "," << d2 << "): " << n1 << " " << n2 << "\n";
-        if (n1<0 || d1<=n1) error("2D range error: dimension 1");
-        if (n2<0 || d2<=n2) error("2D range error: dimension 2");
-    }
-
-    // subscripting:
-          T& operator()(Index n1, Index n2)       { range_check(n1,n2); return this->elem[n1*d2+n2]; }
-    const T& operator()(Index n1, Index n2) const { range_check(n1,n2); return this->elem[n1*d2+n2]; }
-
-    // slicing (return a row):
-          Row<T,1> operator[](Index n)       { return row(n); }
-    const Row<T,1> operator[](Index n) const { return row(n); }
-
-          Row<T,1> row(Index n)       { range_check(n,0); return Row<T,1>(d2,&this->elem[n*d2]); }
-    const Row<T,1> row(Index n) const { range_check(n,0); return Row<T,1>(d2,&this->elem[n*d2]); }
-
-    Row<T,2> slice(Index n)
-        // rows [n:d1)
-    {
-        if (n<0) n=0;
-        else if(d1<n) n=d1;    // one beyond the end
-        return Row<T,2>(d1-n,d2,this->elem+n*d2);
-    }
-
-    const Row<T,2> slice(Index n) const
-        // rows [n:d1)
-    {
-        if (n<0) n=0;
-        else if(d1<n) n=d1;    // one beyond the end
-        return Row<T,2>(d1-n,d2,this->elem+n*d2);
-    }
-
-    Row<T,2> slice(Index n, Index m)
-        // the rows [n:m)
-    {
-        if (n<0) n=0;
-        if(d1<m) m=d1;    // one beyond the end
-        return Row<T,2>(m-n,d2,this->elem+n*d2);
-
-    }
-
-    const Row<T,2> slice(Index n, Index m) const
-        // the rows [n:sz)
-    {
-        if (n<0) n=0;
-        if(d1<m) m=d1;    // one beyond the end
-        return Row<T,2>(m-n,d2,this->elem+n*d2);
-    }
-
-    // Column<T,1> column(Index n); // not (yet) implemented: requies strides and operations on columns
-
-    // element-wise operations:
-    template<class F> Matrix& apply(F f)            { this->base_apply(f);   return *this; }
-    template<class F> Matrix& apply(F f,const T& c) { this->base_apply(f,c); return *this; }
-
-    Matrix& operator=(const T& c)  { this->base_apply(Assign<T>(),c);       return *this; }
-
-    Matrix& operator*=(const T& c) { this->base_apply(Mul_assign<T>(),c);   return *this; }
-    Matrix& operator/=(const T& c) { this->base_apply(Div_assign<T>(),c);   return *this; }
-    Matrix& operator%=(const T& c) { this->base_apply(Mod_assign<T>(),c);   return *this; }
-    Matrix& operator+=(const T& c) { this->base_apply(Add_assign<T>(),c);   return *this; }
-    Matrix& operator-=(const T& c) { this->base_apply(Minus_assign<T>(),c); return *this; }
-
-    Matrix& operator&=(const T& c) { this->base_apply(And_assign<T>(),c);   return *this; }
-    Matrix& operator|=(const T& c) { this->base_apply(Or_assign<T>(),c);    return *this; }
-    Matrix& operator^=(const T& c) { this->base_apply(Xor_assign<T>(),c);   return *this; }
-
-    Matrix operator!() { return xfer(Matrix(*this,Not<T>())); }
-    Matrix operator-() { return xfer(Matrix(*this,Unary_minus<T>())); }
-    Matrix operator~() { return xfer(Matrix(*this,Complement<T>()));  }
-
-    template<class F> Matrix apply_new(F f) { return xfer(Matrix(*this,f)); }
-    
-    void swap_rows(Index i, Index j)
-        // swap_rows() uses a row's worth of memory for better run-time performance
-        // if you want pairwise swap, just write it yourself
-    {
-        if (i == j) return;
-    /*
-        Matrix<T,1> temp = (*this)[i];
-        (*this)[i] = (*this)[j];
-        (*this)[j] = temp;
-    */
-        Index max = (*this)[i].size();
-        for (Index ii=0; ii<max; ++ii) std::swap((*this)(i,ii),(*this)(j,ii));
-    }
-};
-
-//-----------------------------------------------------------------------------
-
-template<class T> class Matrix<T,3> : public Matrix_base<T> {
-    const Index d1;
-    const Index d2;
-    const Index d3;
-
-protected:
-    // for use by Row:
-    Matrix(Index n1, Index n2, Index n3, T* p) : Matrix_base<T>(n1*n2*n3,p), d1(n1), d2(n2), d3(n3) 
-    {
-        // std::cerr << "construct 3D Matrix from data\n";
-    }
-
-public:
-
-    Matrix(Index n1, Index n2, Index n3) : Matrix_base<T>(n1*n2*n3), d1(n1), d2(n2), d3(n3) { }
-
-    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())
-    { 
-        // std::cerr << "construct 3D Matrix from Row\n";
-    }
-
-    // copy constructor: let the base do the copy:
-    Matrix(const Matrix& a) : Matrix_base<T>(a.size(),0), d1(a.d1), d2(a.d2), d3(a.d3)
-    {
-        // std::cerr << "copy ctor\n";
-        this->base_copy(a);
-    }
-
-    template<int n1, int n2, int n3> 
-    Matrix(const T (&a)[n1][n2][n3]) : Matrix_base<T>(n1*n2), d1(n1), d2(n2), d3(n3)
-        // deduce "n1", "n2", "n3" (and "T"), Matrix_base allocates T[n1*n2*n3]
-    {
-        // std::cerr << "matrix ctor\n";
-        for (Index i = 0; i<n1; ++i)
-            for (Index j = 0; j<n2; ++j)
-                for (Index k = 0; k<n3; ++k)
-                    this->elem[i*n2*n3+j*n3+k]=a[i][j][k];
-    }
-
-    template<class F> Matrix(const Matrix& a, F f) : Matrix_base<T>(a.size()), d1(a.d1), d2(a.d2), d3(a.d3)
-        // construct a new Matrix with element's that are functions of a's elements:
-        // does not modify a unless f has been specifically programmed to modify its argument
-        // T f(const T&) would be a typical type for f
-    {
-        for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i]); 
-    }
-
-    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)
-        // construct a new Matrix with element's that are functions of a's elements:
-        // does not modify a unless f has been specifically programmed to modify its argument
-        // T f(const T&, const Arg&) would be a typical type for f
-    {
-        for (Index i = 0; i<this->sz; ++i) this->elem[i] = f(a.elem[i],t1); 
-    }
-
-    Matrix& operator=(const Matrix& a)
-        // copy assignment: let the base do the copy
-    {
-        // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<< ")\n";
-        if (d1!=a.d1 || d2!=a.d2 || d3!=a.d3) error("length error in 2D =");
-        this->base_assign(a);
-        return *this;
-    }
-
-    ~Matrix() { }
-
-    Index dim1() const { return d1; }    // number of elements in a row
-    Index dim2() const { return d2; }    // number of elements in a column
-    Index dim3() const { return d3; }    // number of elements in a depth
-
-    Matrix xfer()    // make an Matrix to move elements out of a scope
-    {
-        Matrix x(dim1(),dim2(),dim3(),this->data()); // make a descriptor
-        this->base_xfer(x);            // transfer (temporary) ownership to x
-        return x;
-    }
-
-    void range_check(Index n1, Index n2, Index n3) const
-    {
-        // std::cerr << "range check: (" << d1 << "," << d2 << "): " << n1 << " " << n2 << "\n";
-        if (n1<0 || d1<=n1) error("3D range error: dimension 1");
-        if (n2<0 || d2<=n2) error("3D range error: dimension 2");
-        if (n3<0 || d3<=n3) error("3D range error: dimension 3");
-    }
-
-    // subscripting:
-          T& operator()(Index n1, Index n2, Index n3)       { range_check(n1,n2,n3); return this->elem[d2*d3*n1+d3*n2+n3]; }; 
-    const T& operator()(Index n1, Index n2, Index n3) const { range_check(n1,n2,n3); return this->elem[d2*d3*n1+d3*n2+n3]; };
-
-    // slicing (return a row):
-          Row<T,2> operator[](Index n)       { return row(n); }
-    const Row<T,2> operator[](Index n) const { return row(n); }
-
-          Row<T,2> row(Index n)       { range_check(n,0,0); return Row<T,2>(d2,d3,&this->elem[n*d2*d3]); }
-    const Row<T,2> row(Index n) const { range_check(n,0,0); return Row<T,2>(d2,d3,&this->elem[n*d2*d3]); }
-
-    Row<T,3> slice(Index n)
-        // rows [n:d1)
-    {
-        if (n<0) n=0;
-        else if(d1<n) n=d1;    // one beyond the end
-        return Row<T,3>(d1-n,d2,d3,this->elem+n*d2*d3);
-    }
-
-    const Row<T,3> slice(Index n) const
-        // rows [n:d1)
-    {
-        if (n<0) n=0;
-        else if(d1<n) n=d1;    // one beyond the end
-        return Row<T,3>(d1-n,d2,d3,this->elem+n*d2*d3);
-    }
-
-    Row<T,3> slice(Index n, Index m)
-        // the rows [n:m)
-    {
-        if (n<0) n=0;
-        if(d1<m) m=d1;    // one beyond the end
-        return Row<T,3>(m-n,d2,d3,this->elem+n*d2*d3);
-
-    }
-
-    const Row<T,3> slice(Index n, Index m) const
-        // the rows [n:sz)
-    {
-        if (n<0) n=0;
-        if(d1<m) m=d1;    // one beyond the end
-        return Row<T,3>(m-n,d2,d3,this->elem+n*d2*d3);
-    }
-
-    // Column<T,2> column(Index n); // not (yet) implemented: requies strides and operations on columns
-
-    // element-wise operations:
-    template<class F> Matrix& apply(F f)            { this->base_apply(f);   return *this; }
-    template<class F> Matrix& apply(F f,const T& c) { this->base_apply(f,c); return *this; }
-
-    Matrix& operator=(const T& c)  { this->base_apply(Assign<T>(),c);       return *this; }
-                                                                            
-    Matrix& operator*=(const T& c) { this->base_apply(Mul_assign<T>(),c);   return *this; }
-    Matrix& operator/=(const T& c) { this->base_apply(Div_assign<T>(),c);   return *this; }
-    Matrix& operator%=(const T& c) { this->base_apply(Mod_assign<T>(),c);   return *this; }
-    Matrix& operator+=(const T& c) { this->base_apply(Add_assign<T>(),c);   return *this; }
-    Matrix& operator-=(const T& c) { this->base_apply(Minus_assign<T>(),c); return *this; }
-
-    Matrix& operator&=(const T& c) { this->base_apply(And_assign<T>(),c);   return *this; }
-    Matrix& operator|=(const T& c) { this->base_apply(Or_assign<T>(),c);    return *this; }
-    Matrix& operator^=(const T& c) { this->base_apply(Xor_assign<T>(),c);   return *this; }
-
-    Matrix operator!() { return xfer(Matrix(*this,Not<T>())); }
-    Matrix operator-() { return xfer(Matrix(*this,Unary_minus<T>())); }
-    Matrix operator~() { return xfer(Matrix(*this,Complement<T>()));  }
-
-    template<class F> Matrix apply_new(F f) { return xfer(Matrix(*this,f)); }
-    
-    void swap_rows(Index i, Index j)
-        // swap_rows() uses a row's worth of memory for better run-time performance
-        // if you want pairwise swap, just write it yourself
-    {
-        if (i == j) return;
-        
-        Matrix<T,2> temp = (*this)[i];
-        (*this)[i] = (*this)[j];
-        (*this)[j] = temp;
-    }
-};
-
-//-----------------------------------------------------------------------------
-
-template<class T> Matrix<T> scale_and_add(const Matrix<T>& a, T c, const Matrix<T>& b)
-    //  Fortran "saxpy()" ("fma" for "fused multiply-add").
-    // will the copy constructor be called twice and defeat the xfer optimization?
-{
-    if (a.size() != b.size()) error("sizes wrong for scale_and_add()");
-    Matrix<T> res(a.size());
-    for (Index i = 0; i<a.size(); ++i) res[i] += a[i]*c+b[i];
-    return res.xfer();
-}
-
-//-----------------------------------------------------------------------------
-
-template<class T> T dot_product(const Matrix<T>&a , const Matrix<T>& b)
-{
-    if (a.size() != b.size()) error("sizes wrong for dot product");
-    T sum = 0;
-    for (Index i = 0; i<a.size(); ++i) sum += a[i]*b[i];
-    return sum;
-}
-
-//-----------------------------------------------------------------------------
-
-template<class T, int N> Matrix<T,N> xfer(Matrix<T,N>& a)
-{
-    return a.xfer();
-}
-
-//-----------------------------------------------------------------------------
-
-template<class F, class A>            A apply(F f, A x)        { A res(x,f);   return xfer(res); }
-template<class F, class Arg, class A> A apply(F f, A x, Arg a) { A res(x,f,a); return xfer(res); }
-
-//-----------------------------------------------------------------------------
-
-// The default values for T and D have been declared before.
-template<class T, int D> class Row {
-    // general version exists only to allow specializations
-private:
-        Row();
-};
-
-//-----------------------------------------------------------------------------
-
-template<class T> class Row<T,1> : public Matrix<T,1> {
-public:
-    Row(Index n, T* p) : Matrix<T,1>(n,p)
-    {
-    }
-
-    Matrix<T,1>& operator=(const T& c) { this->base_apply(Assign<T>(),c); return *this; }
-
-    Matrix<T,1>& operator=(const Matrix<T,1>& a)
-    {
-        return *static_cast<Matrix<T,1>*>(this)=a;
-    }
-};
-
-//-----------------------------------------------------------------------------
-
-template<class T> class Row<T,2> : public Matrix<T,2> {
-public:
-    Row(Index n1, Index n2, T* p) : Matrix<T,2>(n1,n2,p)
-    {
-    }
-        
-    Matrix<T,2>& operator=(const T& c) { this->base_apply(Assign<T>(),c); return *this; }
-
-    Matrix<T,2>& operator=(const Matrix<T,2>& a)
-    {
-        return *static_cast<Matrix<T,2>*>(this)=a;
-    }
-};
-
-//-----------------------------------------------------------------------------
-
-template<class T> class Row<T,3> : public Matrix<T,3> {
-public:
-    Row(Index n1, Index n2, Index n3, T* p) : Matrix<T,3>(n1,n2,n3,p)
-    {
-    }
-
-    Matrix<T,3>& operator=(const T& c) { this->base_apply(Assign<T>(),c); return *this; }
-
-    Matrix<T,3>& operator=(const Matrix<T,3>& a)
-    {
-        return *static_cast<Matrix<T,3>*>(this)=a;
-    }
-};
-
-//-----------------------------------------------------------------------------
-
-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)
-{
-    Matrix<T> res(a.size());
-    if (a.size() != b.size()) error("sizes wrong for scale_and_add");
-    for (Index i = 0; i<a.size(); ++i) res[i] += a[i]*c+b[i];
-    return res.xfer();
-}
-
-//-----------------------------------------------------------------------------
-
-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; }
-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; }
-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; }
-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; }
-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; }
-
-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; }
-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; }
-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; }
-
-//-----------------------------------------------------------------------------
-
-}
-#endif
diff --git a/MatrixIO.h b/MatrixIO.h
deleted file mode 100644
index e623ba7..0000000
--- a/MatrixIO.h
+++ /dev/null
@@ -1,79 +0,0 @@
-
-#include <iostream>
-#include "Matrix.h"
-
-namespace Numeric_lib {
-
-//-----------------------------------------------------------------------------
-
-template<class T> std::ostream& operator<<(std::ostream& os, const Matrix<T>& v)
-{
-    os << '{';
-
-    for (Index i = 0; i<v.dim1(); ++i) {
-        os << "  ";
-        os << v(i);
-    }
-
-    os << '}';
-    return os;
-}
-
-//-----------------------------------------------------------------------------
-
-template<class T> std::ostream& operator<<(std::ostream& os, const Matrix<T,2>& m)
-{
-    os << "{\n";
-
-    for (Index i = 0; i<m.dim1(); ++i)
-        os << m[i] << '\n';
-
-    os << '}';
-    return os;
-}
-
-//-----------------------------------------------------------------------------
-
-template<class T> std::istream& operator>>(std::istream& is, Matrix<T>& v)
-{
-    char ch;
-    is >> ch;
-
-    if (ch!='{') error("'{' missing in Matrix<T,1> input");
-
-    for (Index i = 0; i<v.dim1(); ++i)
-        is >> v(i);
-
-    is >> ch;
-
-    if (ch!='}') error("'}' missing in Matrix<T,1> input");
-  
-    return is;
-}
-
-//-----------------------------------------------------------------------------
-
-template<class T> std::istream& operator>>(std::istream& is, Matrix<T,2>& m)
-{
-    char ch;
-    is >> ch;
-
-    if (ch!='{') error("'{' missing in Matrix<T,2> input");
-
-    for (Index i = 0; i<m.dim1(); ++i)
-    {
-        Matrix<T,1> tmp(m.dim2());
-        is >> tmp;
-        m[i] = tmp;
-    }
-
-    is >> ch;
-
-    if (ch!='}') error("'}' missing in Matrix<T,2> input");
-
-    return is;
-}
-
-//-----------------------------------------------------------------------------
-
-}
diff --git a/MatrixIO11.h b/MatrixIO11.h
deleted file mode 100644
index e623ba7..0000000
--- a/MatrixIO11.h
+++ /dev/null
@@ -1,79 +0,0 @@
-
-#include <iostream>
-#include "Matrix.h"
-
-namespace Numeric_lib {
-
-//-----------------------------------------------------------------------------
-
-template<class T> std::ostream& operator<<(std::ostream& os, const Matrix<T>& v)
-{
-    os << '{';
-
-    for (Index i = 0; i<v.dim1(); ++i) {
-        os << "  ";
-        os << v(i);
-    }
-
-    os << '}';
-    return os;
-}
-
-//-----------------------------------------------------------------------------
-
-template<class T> std::ostream& operator<<(std::ostream& os, const Matrix<T,2>& m)
-{
-    os << "{\n";
-
-    for (Index i = 0; i<m.dim1(); ++i)
-        os << m[i] << '\n';
-
-    os << '}';
-    return os;
-}
-
-//-----------------------------------------------------------------------------
-
-template<class T> std::istream& operator>>(std::istream& is, Matrix<T>& v)
-{
-    char ch;
-    is >> ch;
-
-    if (ch!='{') error("'{' missing in Matrix<T,1> input");
-
-    for (Index i = 0; i<v.dim1(); ++i)
-        is >> v(i);
-
-    is >> ch;
-
-    if (ch!='}') error("'}' missing in Matrix<T,1> input");
-  
-    return is;
-}
-
-//-----------------------------------------------------------------------------
-
-template<class T> std::istream& operator>>(std::istream& is, Matrix<T,2>& m)
-{
-    char ch;
-    is >> ch;
-
-    if (ch!='{') error("'{' missing in Matrix<T,2> input");
-
-    for (Index i = 0; i<m.dim1(); ++i)
-    {
-        Matrix<T,1> tmp(m.dim2());
-        is >> tmp;
-        m[i] = tmp;
-    }
-
-    is >> ch;
-
-    if (ch!='}') error("'}' missing in Matrix<T,2> input");
-
-    return is;
-}
-
-//-----------------------------------------------------------------------------
-
-}
diff --git a/Point.h b/Point.h
deleted file mode 100644
index 85153e2..0000000
--- a/Point.h
+++ /dev/null
@@ -1,23 +0,0 @@
-
-#ifndef POINT_GUARD
-#define POINT_GUARD
-
-//typedef void (*Callback)(void*,void*);
-
-namespace Graph_lib {
-
-struct Point {
-	int x,y;
-//	Point(int xx, int yy) : x(xx), y(yy) { }
-//	Point() :x(0), y(0) { }
-
-//	Point& operator+=(Point d) { x+=d.x; y+=d.y; return *this; }
-};
-
-inline bool operator==(Point a, Point b) { return a.x==b.x && a.y==b.y; }
-
-inline bool operator!=(Point a, Point b) { return !(a==b); }
-
-
-}
-#endif
\ No newline at end of file
diff --git a/Simple_window.h b/Simple_window.h
deleted file mode 100644
index d6071b6..0000000
--- a/Simple_window.h
+++ /dev/null
@@ -1,37 +0,0 @@
-
-#include "GUI.h"	// for Simple_window only (doesn't really belong in Window.h)
-
-using namespace Graph_lib;
-
-// Simple_window is basic scaffolding for ultra-simple interaction with graphics
-// it provides one window with one "next" button for ultra-simple animation
-
-struct Simple_window : Window {
-	Simple_window(Point xy, int w, int h, const string& title )
-	: Window(xy,w,h,title),
-	  button_pushed(false),
-	  next_button(Point(x_max()-70,0), 70, 20, "Next", cb_next) { attach(next_button); }
-	
-	void wait_for_button()
-	// modified event loop
-	// handle all events (as per default), but quit when button_pushed becomes true
-	// this allows graphics without control inversion
-	{
-		while (!button_pushed) Fl::wait();
-		button_pushed = false;
-		Fl::redraw();
-	}
-
-	Button next_button;
-private:
-	bool button_pushed;
-	
-	static void cb_next(Address, Address addr) // callback for next_button
-	//	{ reference_to<Simple_window>(addr).next(); }
-	{
-		static_cast<Simple_window*>(addr)->next();
-	}
-
-	void next() { button_pushed = true; }
-
-};
diff --git a/Window.cpp b/Window.cpp
deleted file mode 100644
index e48df57..0000000
--- a/Window.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-#include "Window.h"
-#include "Graph.h"
-#include "GUI.h"
-
-namespace Graph_lib {
-
-Window::Window(int ww, int hh, const string& title)
-:Fl_Window(ww,hh,title.c_str()),w(ww),h(hh)
-{
-	init();
-}
-
-Window::Window(Point xy, int ww, int hh, const string& title)
-:Fl_Window(xy.x,xy.y,ww,hh,title.c_str()),w(ww),h(hh)
-{ 
-	init();
-}
-
-void Window::init()
-{
-   resizable(this);
-   show();
-} 
-
-//---------------------------------------------------- 
-
-void Window::draw()
-{
-	Fl_Window::draw();
-	for (unsigned int i=0; i<shapes.size(); ++i) shapes[i]->draw();
-}
-
-void Window::attach(Widget& w)
-{
-	begin();			// FTLK: begin attaching new Fl_Wigets to this window
-		w.attach(*this);	// let the Widget create its Fl_Wigits
-	end();				// FTLK: stop attaching new Fl_Wigets to this window
-}
-
-void Window::detach(Widget& b)
-{
-	  b.hide();
-}
-
-void Window::attach(Shape& s)
-{
-		shapes.push_back(&s);
-//		s.attached = this;
-}
-void Window::detach(Shape& s)
-{
-		for (unsigned int i = shapes.size(); 0<i; --i)	// guess last attached will be first released
-			if (shapes[i-1]==&s)
-				shapes.erase(shapes.begin()+(i-1));//&shapes[i-1]);
-}
-
-
-void Window::put_on_top(Shape& p) {
-	for (int i=0; i<shapes.size(); ++i) {
-		if (&p==shapes[i]) {
-			for (++i; i<shapes.size(); ++i)
-				shapes[i-1] = shapes[i];
-			shapes[shapes.size()-1] = &p;
-			return;
-		}
-	}
-}
-
-int gui_main() { return Fl::run(); }
-
-} // Graph
diff --git a/Window.h b/Window.h
deleted file mode 100644
index fbeab4c..0000000
--- a/Window.h
+++ /dev/null
@@ -1,53 +0,0 @@
-#ifndef WINDOW_GUARD
-#define WINDOW_GUARD 1
-
-#include "fltk.h"
-
-#include "std_lib_facilities.h"
-
-#include "Point.h"
-//#include "GUI.h"
-
-namespace Graph_lib {
-
-class Shape;	// "forward declare" Shape
-class Widget;
-
-class Window : public Fl_Window { 
-public: 
-	Window(int w, int h, const string& title );			// let the system pick the location
-	Window(Point xy, int w, int h, const string& title );	// top left corner in xy
-	virtual ~Window() { }
-
-	int x_max() const { return w; }
-	int y_max() const { return h; }
-
-	void resize(int ww, int hh) { w=ww, h=hh; size(ww,hh); }
-
-	void set_label(const string& s) { label(s.c_str()); }
-
-	void attach(Shape& s);
-	void attach(Widget& w);
-
-	void detach(Shape& s);	// remove s from shapes 
-	void detach(Widget& w);	// remove w from window (deactivate callbacks)
-
-	void put_on_top(Shape& p);	// put p on top of other shapes
-
-protected:
-	void draw();
-     
-private:
-	  vector<Shape*> shapes;	// shapes attached to window
-	  int w,h;					// window size
-
-	  void init();
-}; 
-
-int gui_main();	// invoke GUI library's main event loop
-
-inline int x_max() { return Fl::w(); }	// width of screen in pixels
-inline int y_max() { return Fl::h(); }	// height of screen in pixels
-
-}
-#endif
diff --git a/conanfile.txt b/conanfile.txt
new file mode 100644
index 0000000..e86b355
--- /dev/null
+++ b/conanfile.txt
@@ -0,0 +1,6 @@
+[generators]
+CMakeDeps
+CMakeToolchain
+
+[requires]
+fltk/1.4.5
diff --git a/fltk.h b/fltk.h
deleted file mode 100644
index 3b79f8e..0000000
--- a/fltk.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef FLTK_GUARD
-#define FLTK_GUARD 1
-
-#include "FL/Fl.H"
-#include "FL/Fl_Window.H" 
-#include "FL/Fl_Button.H" 
-#include "FL/Fl_Input.H" 
-#include "FL/Fl_Output.H" 
-#include <cstdlib>       // for exit(0)
-#include "FL/fl_draw.H"
-#include "FL/Enumerations.H"
-
-#include "Fl/Fl_JPEG_Image.H"
-#include "Fl/Fl_GIF_Image.H"
-
-#endif
-
diff --git a/include/Graph_lib/GUI.hpp b/include/Graph_lib/GUI.hpp
new file mode 100644
index 0000000..50f44db
--- /dev/null
+++ b/include/Graph_lib/GUI.hpp
@@ -0,0 +1,129 @@
+//
+// This is a GUI support code to the chapters 12-16 of the book
+// "Programming -- Principles and Practice Using C++" by Bjarne Stroustrup
+//
+
+#ifndef GUI_GUARD
+#define GUI_GUARD
+
+#include <FL/Fl_Button.H>
+#include <FL/Fl_Input.H>
+#include <FL/Fl_Output.H>
+#include <Graph_lib/Graph.hpp>
+#include <Graph_lib/Point.hpp>
+#include <Graph_lib/Window.hpp>
+
+namespace Graph_lib {
+typedef void *Address; // Address is a synonym for void*
+typedef void (*Callback)(
+    Address, Address); // FLTK's required function type for all callbacks
+
+template <class W>
+W &reference_to(Address pw)
+// treat an address as a reference to a W
+{
+  return *static_cast<W *>(pw);
+}
+
+class Widget {
+  // Widget is a handle to a Fl_widget - it is *not* a Fl_widget
+  // We try to keep our interface classes at arm's length from FLTK
+public:
+  Widget(Point xy, int w, int h, const string &s, Callback cb)
+      : loc(xy), width(w), height(h), label(s), do_it(cb) {}
+
+  virtual void move(int dx, int dy) {
+    hide();
+    pw->position(loc.x += dx, loc.y += dy);
+    show();
+  }
+  virtual void hide() { pw->hide(); }
+  virtual void show() { pw->show(); }
+  virtual void
+  attach(Window &) = 0; // each Widgit define at least one action for a window
+
+  Point loc;
+  int width;
+  int height;
+  string label;
+  Callback do_it;
+
+  virtual ~Widget() {}
+
+  /*
+  Widget(const Widget& a) :loc(a.loc) { error("attempt to copy Widget by
+  constructor"); } Widget& operator=(const Widget& a)
+  {
+          error("attempt to copy Widget by cassignment");
+          return *this;
+  }
+  */
+
+protected:
+  Window *own; // every Widget belongs to a Window
+  Fl_Widget *pw;
+
+private:
+  Widget &operator=(const Widget &); // don't copy Widgets
+  Widget(const Widget &);
+};
+
+class Button : public Widget {
+public:
+  Button(Point xy, int ww, int hh, const string &label, Callback cb)
+      : Widget(xy, ww, hh, label, cb) {}
+
+  void attach(Window &win);
+};
+
+struct In_box : Widget {
+  In_box(Point xy, int w, int h, const string &s) : Widget(xy, w, h, s, 0) {}
+  int get_int();
+  string get_string();
+
+  void attach(Window &win);
+};
+
+struct Out_box : Widget {
+  Out_box(Point xy, int w, int h, const string &s) : Widget(xy, w, h, s, 0) {}
+  void put(int);
+  void put(const string &);
+
+  void attach(Window &win);
+};
+
+struct Menu : Widget {
+  enum Kind { horizontal, vertical };
+  Menu(Point xy, int w, int h, Kind kk, const string &label)
+      : Widget(xy, w, h, label, 0), k(kk), offset(0) {}
+
+  Vector_ref<Button> selection;
+  Kind k;
+  int offset;
+  int attach(Button &b); // attach button; Menu does not delete &b
+  int attach(Button *p); // attach new button; Menu deletes p
+  void show()            // show all buttons
+  {
+    for (unsigned int i = 0; i < selection.size(); ++i)
+      selection[i].show();
+  }
+  void hide() // hide all buttons
+  {
+    for (unsigned int i = 0; i < selection.size(); ++i)
+      selection[i].hide();
+  }
+  void move(int dx, int dy) // move all buttons
+  {
+    for (unsigned int i = 0; i < selection.size(); ++i)
+      selection[i].move(dx, dy);
+  }
+
+  void attach(Window &win) // attach all buttons
+  {
+    for (int i = 0; i < selection.size(); ++i)
+      win.attach(selection[i]);
+  }
+};
+} // namespace Graph_lib
+
+#endif
diff --git a/include/Graph_lib/Graph.hpp b/include/Graph_lib/Graph.hpp
new file mode 100644
index 0000000..7844acc
--- /dev/null
+++ b/include/Graph_lib/Graph.hpp
@@ -0,0 +1,428 @@
+
+#ifndef GRAPH_GUARD
+#define GRAPH_GUARD 1
+
+#include <FL/Enumerations.H>
+#include <FL/fl_draw.H>
+#include <Fl/Fl_GIF_Image.H>
+#include <Fl/Fl_JPEG_Image.H>
+#include <Graph_lib/Point.hpp>
+#include <std_lib_facilities.hpp>
+#include <vector>
+
+namespace Graph_lib {
+struct Color {
+  enum Color_type {
+    red = FL_RED,
+    blue = FL_BLUE,
+    green = FL_GREEN,
+    yellow = FL_YELLOW,
+    white = FL_WHITE,
+    black = FL_BLACK,
+    magenta = FL_MAGENTA,
+    cyan = FL_CYAN,
+    dark_red = FL_DARK_RED,
+    dark_green = FL_DARK_GREEN,
+    dark_yellow = FL_DARK_YELLOW,
+    dark_blue = FL_DARK_BLUE,
+    dark_magenta = FL_DARK_MAGENTA,
+    dark_cyan = FL_DARK_CYAN
+  };
+  enum Transparency { invisible = 0, visible = 255 };
+
+  Color(Color_type cc) : c(Fl_Color(cc)), v(visible) {}
+  Color(Color_type cc, Transparency vv) : c(Fl_Color(cc)), v(vv) {}
+  Color(int cc) : c(Fl_Color(cc)), v(visible) {}
+  Color(Transparency vv) : c(Fl_Color()), v(vv) {}
+
+  int as_int() const { return c; }
+  char visibility() const { return v; }
+  void set_visibility(Transparency vv) { v = vv; }
+
+private:
+  unsigned char v; // 0 or 1 for now
+  Fl_Color c;
+};
+
+struct Line_style {
+  enum Line_style_type {
+    solid = FL_SOLID,           // -------
+    dash = FL_DASH,             // - - - -
+    dot = FL_DOT,               // .......
+    dashdot = FL_DASHDOT,       // - . - .
+    dashdotdot = FL_DASHDOTDOT, // -..-..
+  };
+  Line_style(Line_style_type ss) : s(ss), w(0) {}
+  Line_style(Line_style_type lst, int ww) : s(lst), w(ww) {}
+  Line_style(int ss) : s(ss), w(0) {}
+
+  int width() const { return w; }
+  int style() const { return s; }
+
+private:
+  int s;
+  int w;
+};
+
+class Font {
+public:
+  enum Font_type {
+    helvetica = FL_HELVETICA,
+    helvetica_bold = FL_HELVETICA_BOLD,
+    helvetica_italic = FL_HELVETICA_ITALIC,
+    helvetica_bold_italic = FL_HELVETICA_BOLD_ITALIC,
+    courier = FL_COURIER,
+    courier_bold = FL_COURIER_BOLD,
+    courier_italic = FL_COURIER_ITALIC,
+    courier_bold_italic = FL_COURIER_BOLD_ITALIC,
+    times = FL_TIMES,
+    times_bold = FL_TIMES_BOLD,
+    times_italic = FL_TIMES_ITALIC,
+    times_bold_italic = FL_TIMES_BOLD_ITALIC,
+    symbol = FL_SYMBOL,
+    screen = FL_SCREEN,
+    screen_bold = FL_SCREEN_BOLD,
+    zapf_dingbats = FL_ZAPF_DINGBATS
+  };
+
+  Font(Font_type ff) : f(ff) {}
+  Font(int ff) : f(ff) {}
+
+  int as_int() const { return f; }
+
+private:
+  int f;
+};
+
+template <class T> class Vector_ref {
+  vector<T *> v;
+  vector<T *> owned;
+
+public:
+  Vector_ref() {}
+
+  Vector_ref(T *a, T *b = 0, T *c = 0, T *d = 0) {
+    if (a)
+      push_back(a);
+    if (b)
+      push_back(b);
+    if (c)
+      push_back(c);
+    if (d)
+      push_back(d);
+  }
+
+  ~Vector_ref() {
+    for (int i = 0; i < owned.size(); ++i)
+      delete owned[i];
+  }
+
+  void push_back(T &s) { v.push_back(&s); }
+  void push_back(T *p) {
+    v.push_back(p);
+    owned.push_back(p);
+  }
+
+  // ???void erase(???)
+
+  T &operator[](int i) { return *v[i]; }
+  const T &operator[](int i) const { return *v[i]; }
+  int size() const { return v.size(); }
+};
+
+typedef double Fct(double);
+
+class Shape { // deals with color and style, and holds sequence of lines
+protected:
+  Shape() {}
+  Shape(initializer_list<Point> lst); // add() the Points to this Shape
+
+  //	Shape() : lcolor(fl_color()),
+  //		ls(0),
+  //		fcolor(Color::invisible) { }
+
+  void add(Point p) { points.push_back(p); }
+  void set_point(int i, Point p) { points[i] = p; }
+
+public:
+  void draw() const; // deal with color and draw_lines
+protected:
+  virtual void draw_lines() const; // simply draw the appropriate lines
+public:
+  virtual void move(int dx, int dy); // move the shape +=dx and +=dy
+
+  void set_color(Color col) { lcolor = col; }
+  Color color() const { return lcolor; }
+
+  void set_style(Line_style sty) { ls = sty; }
+  Line_style style() const { return ls; }
+
+  void set_fill_color(Color col) { fcolor = col; }
+  Color fill_color() const { return fcolor; }
+
+  Point point(int i) const { return points[i]; }
+  int number_of_points() const { return int(points.size()); }
+
+  virtual ~Shape() {}
+  /*
+  struct Window* attached;
+  Shape(const Shape& a)
+          :attached(a.attached), points(a.points), line_color(a.line_color),
+  ls(a.ls)
+  {
+          if (a.attached)error("attempt to copy attached shape");
+  }
+  */
+  Shape(const Shape &) = delete;
+  Shape &operator=(const Shape &) = delete;
+
+private:
+  vector<Point> points;            // not used by all shapes
+  Color lcolor{Color(fl_color())}; // Note: List-initialization requires an
+                                   // explicit narrowing conversion
+  Line_style ls{0};
+  Color fcolor{Color::invisible};
+
+  //	Shape(const Shape&);
+  //	Shape& operator=(const Shape&);
+};
+
+struct Function : Shape {
+  // the function parameters are not stored
+  Function(Fct f, double r1, double r2, Point orig, int count = 100,
+           double xscale = 25, double yscale = 25);
+  // Function(Point orig, Fct f, double r1, double r2, int count, double xscale
+  // = 1, double yscale = 1);
+};
+
+struct Fill {
+  Fill() : no_fill(true), fcolor(0) {}
+  Fill(Color c) : no_fill(false), fcolor(c) {}
+
+  void set_fill_color(Color col) { fcolor = col; }
+  Color fill_color() { return fcolor; }
+
+protected:
+  bool no_fill;
+  Color fcolor;
+};
+
+struct Line : Shape {
+  Line(Point p1, Point p2) {
+    add(p1);
+    add(p2);
+  }
+};
+
+struct Rectangle : Shape {
+
+  Rectangle(Point xy, int ww, int hh) : w{ww}, h{hh} {
+    if (h <= 0 || w <= 0)
+      error("Bad rectangle: non-positive side");
+    add(xy);
+  }
+  Rectangle(Point x, Point y) : w{y.x - x.x}, h{y.y - x.y} {
+    if (h <= 0 || w <= 0)
+      error("Bad rectangle: first point is not top left");
+    add(x);
+  }
+  void draw_lines() const;
+
+  //	void set_fill_color(Color col) { fcolor = col; }
+  //	Color fill_color() { return fcolor; }
+
+  int height() const { return h; }
+  int width() const { return w; }
+
+private:
+  int h; // height
+  int w; // width
+  //	Color fcolor;	// fill color; 0 means "no fill"
+};
+
+bool intersect(Point p1, Point p2, Point p3, Point p4);
+
+struct Open_polyline : Shape { // open sequence of lines
+  using Shape::Shape;
+  void add(Point p) { Shape::add(p); }
+  void draw_lines() const;
+};
+
+struct Closed_polyline : Open_polyline { // closed sequence of lines
+  using Open_polyline::Open_polyline;
+  void draw_lines() const;
+
+  //	void add(Point p) { Shape::add(p); }
+};
+
+struct Polygon : Closed_polyline { // closed sequence of non-intersecting lines
+  using Closed_polyline::Closed_polyline;
+  void add(Point p);
+  void draw_lines() const;
+};
+
+struct Lines : Shape { // indepentdent lines
+  Lines() {}
+  Lines(initializer_list<Point> lst) : Shape{lst} {
+    if (lst.size() % 2)
+      error("odd number of points for Lines");
+  }
+  void draw_lines() const;
+  void add(Point p1, Point p2) {
+    Shape::add(p1);
+    Shape::add(p2);
+  }
+};
+
+struct Text : Shape {
+  // the point is the bottom left of the first letter
+  Text(Point x, const string &s) : lab{s} { add(x); }
+
+  void draw_lines() const;
+
+  void set_label(const string &s) { lab = s; }
+  string label() const { return lab; }
+
+  void set_font(Font f) { fnt = f; }
+  Font font() const { return Font(fnt); }
+
+  void set_font_size(int s) { fnt_sz = s; }
+  int font_size() const { return fnt_sz; }
+
+private:
+  string lab; // label
+  Font fnt{fl_font()};
+  int fnt_sz{(14 < fl_size()) ? fl_size() : 14}; // at least 14 point
+};
+
+struct Axis : Shape {
+  // representation left public
+  enum Orientation { x, y, z };
+  Axis(Orientation d, Point xy, int length, int nummber_of_notches = 0,
+       string label = "");
+
+  void draw_lines() const;
+  void move(int dx, int dy);
+
+  void set_color(Color c);
+
+  Text label;
+  Lines notches;
+  //	Orientation orin;
+  //	int notches;
+};
+
+struct Circle : Shape {
+  Circle(Point p, int rr) // center and radius
+      : r{rr} {
+    add(Point{p.x - r, p.y - r});
+  }
+
+  void draw_lines() const;
+
+  Point center() const { return {point(0).x + r, point(0).y + r}; }
+
+  void set_radius(int rr) { r = rr; }
+  int radius() const { return r; }
+
+private:
+  int r;
+};
+
+struct Ellipse : Shape {
+  Ellipse(Point p, int ww, int hh) // center, min, and max distance from center
+      : w{ww}, h{hh} {
+    add(Point{p.x - ww, p.y - hh});
+  }
+
+  void draw_lines() const;
+
+  Point center() const { return {point(0).x + w, point(0).y + h}; }
+  Point focus1() const {
+    return {center().x + int(sqrt(double(w * w - h * h))), center().y};
+  }
+  Point focus2() const {
+    return {center().x - int(sqrt(double(w * w - h * h))), center().y};
+  }
+
+  void set_major(int ww) { w = ww; }
+  int major() const { return w; }
+  void set_minor(int hh) { h = hh; }
+  int minor() const { return h; }
+
+private:
+  int w;
+  int h;
+};
+/*
+struct Mark : Text {
+        static const int dw = 4;
+        static const int dh = 4;
+        Mark(Point xy, char c) : Text(Point(xy.x-dw, xy.y+dh),string(1,c)) {}
+};
+*/
+
+struct Marked_polyline : Open_polyline {
+  Marked_polyline(const string &m) : mark(m) {}
+  void draw_lines() const;
+
+private:
+  string mark;
+};
+
+struct Marks : Marked_polyline {
+  Marks(const string &m) : Marked_polyline(m) {
+    set_color(Color(Color::invisible));
+  }
+};
+
+struct Mark : Marks {
+  Mark(Point xy, char c) : Marks(string(1, c)) { add(xy); }
+};
+
+/*
+
+struct Marks : Shape {
+        Marks(char m) : mark(string(1,m)) { }
+        void add(Point p) { Shape::add(p); }
+        void draw_lines() const;
+private:
+        string mark;
+};
+*/
+
+struct Bad_image : Fl_Image {
+  Bad_image(int h, int w) : Fl_Image(h, w, 0) {}
+  void draw(int x, int y, int, int, int, int) { draw_empty(x, y); }
+};
+
+struct Suffix {
+  enum Encoding { none, jpg, gif, bmp };
+};
+
+Suffix::Encoding get_encoding(const string &s);
+
+struct Image : Shape {
+  Image(Point xy, string s, Suffix::Encoding e = Suffix::none);
+  ~Image() { delete p; }
+  void draw_lines() const;
+  void set_mask(Point xy, int ww, int hh) {
+    w = ww;
+    h = hh;
+    cx = xy.x;
+    cy = xy.y;
+  }
+  void move(int dx, int dy) {
+    Shape::move(dx, dy);
+    p->draw(point(0).x, point(0).y);
+  }
+
+private:
+  int w, h, cx,
+      cy; // define "masking box" within image relative to position (cx,cy)
+  Fl_Image *p;
+  Text fn;
+};
+
+} // namespace Graph_lib
+#endif
diff --git a/include/Graph_lib/Point.hpp b/include/Graph_lib/Point.hpp
new file mode 100644
index 0000000..8d6e5d6
--- /dev/null
+++ b/include/Graph_lib/Point.hpp
@@ -0,0 +1,22 @@
+
+#ifndef POINT_GUARD
+#define POINT_GUARD
+
+// typedef void (*Callback)(void*,void*);
+
+namespace Graph_lib {
+
+struct Point {
+  int x, y;
+  //	Point(int xx, int yy) : x(xx), y(yy) { }
+  //	Point() :x(0), y(0) { }
+
+  //	Point& operator+=(Point d) { x+=d.x; y+=d.y; return *this; }
+};
+
+inline bool operator==(Point a, Point b) { return a.x == b.x && a.y == b.y; }
+
+inline bool operator!=(Point a, Point b) { return !(a == b); }
+
+} // namespace Graph_lib
+#endif
\ No newline at end of file
diff --git a/include/Graph_lib/Simple_window.hpp b/include/Graph_lib/Simple_window.hpp
new file mode 100644
index 0000000..ef26019
--- /dev/null
+++ b/include/Graph_lib/Simple_window.hpp
@@ -0,0 +1,27 @@
+
+#include <Graph_lib/GUI.hpp> // for Simple_window only (doesn't really belong in Window.hpp)
+
+using namespace Graph_lib;
+
+// Simple_window is basic scaffolding for ultra-simple interaction with graphics
+// it provides one window with one "next" button for ultra-simple animation
+
+struct Simple_window : Window {
+  Simple_window(Point xy, int w, int h, const string &title)
+      : Window(xy, w, h, title),
+        next_button(Point(x_max() - 70, 0), 70, 20, "Next", cb_next),
+        button_pushed(false) {
+    attach(next_button);
+  }
+
+  bool wait_for_button();
+
+  Button next_button;
+
+private:
+  bool button_pushed;
+
+  static void cb_next(Address, Address addr); // callback for next_button
+
+  void next();
+};
diff --git a/include/Graph_lib/Window.hpp b/include/Graph_lib/Window.hpp
new file mode 100644
index 0000000..6e69a72
--- /dev/null
+++ b/include/Graph_lib/Window.hpp
@@ -0,0 +1,53 @@
+#ifndef WINDOW_GUARD
+#define WINDOW_GUARD 1
+
+#include <FL/Fl_Window.H>
+#include <Graph_lib/Point.hpp>
+#include <std_lib_facilities.hpp>
+
+namespace Graph_lib {
+
+class Shape; // "forward declare" Shape
+class Widget;
+
+class Window : public Fl_Window {
+public:
+  Window(int w, int h, const string &title); // let the system pick the location
+  Window(Point xy, int w, int h, const string &title); // top left corner in xy
+  virtual ~Window() {}
+
+  int x_max() const { return w; }
+  int y_max() const { return h; }
+
+  void resize(int ww, int hh) {
+    w = ww, h = hh;
+    size(ww, hh);
+  }
+
+  void set_label(const string &s) { label(s.c_str()); }
+
+  void attach(Shape &s);
+  void attach(Widget &w);
+
+  void detach(Shape &s);  // remove s from shapes
+  void detach(Widget &w); // remove w from window (deactivate callbacks)
+
+  void put_on_top(Shape &p); // put p on top of other shapes
+
+protected:
+  void draw();
+
+private:
+  vector<Shape *> shapes; // shapes attached to window
+  int w, h;               // window size
+
+  void init();
+};
+
+int gui_main(); // invoke GUI library's main event loop
+
+inline int x_max() { return Fl::w(); } // width of screen in pixels
+inline int y_max() { return Fl::h(); } // height of screen in pixels
+
+} // namespace Graph_lib
+#endif
diff --git a/include/Numeric_lib/Matrix.hpp b/include/Numeric_lib/Matrix.hpp
new file mode 100644
index 0000000..489f2ac
--- /dev/null
+++ b/include/Numeric_lib/Matrix.hpp
@@ -0,0 +1,1048 @@
+
+/*
+    warning: this small multidimensional matrix library uses a few features
+    not taught in ENGR112 and not explained in elementary textbooks
+
+    (c) Bjarne Stroustrup, Texas A&M University.
+
+    Use as you like as long as you acknowledge the source.
+*/
+
+#ifndef MATRIX_LIB
+#define MATRIX_LIB
+
+#include <algorithm>
+#include <string>
+
+namespace Numeric_lib {
+
+//-----------------------------------------------------------------------------
+
+struct Matrix_error {
+  std::string name;
+  Matrix_error(const char *q) : name(q) {}
+  Matrix_error(std::string n) : name(n) {}
+};
+
+//-----------------------------------------------------------------------------
+
+inline void error(const char *p) { throw Matrix_error(p); }
+
+//-----------------------------------------------------------------------------
+
+typedef long Index; // I still dislike unsigned
+
+//-----------------------------------------------------------------------------
+
+// The general Matrix template is simply a prop for its specializations:
+template <class T = double, int D = 1> class Matrix {
+  // multidimensional matrix class
+  // ( ) does multidimensional subscripting
+  // [ ] does C style "slicing": gives an N-1 dimensional matrix from an N
+  // dimensional one row() is equivalent to [ ] column() is not (yet)
+  // implemented because it requires strides. = has copy semantics ( ) and [ ]
+  // are range checked slice() to give sub-ranges
+private:
+  Matrix(); // this should never be compiled
+  //	template<class A> Matrix(A);
+};
+
+//-----------------------------------------------------------------------------
+
+template <class T = double, int D = 1> class Row; // forward declaration
+
+//-----------------------------------------------------------------------------
+
+// function objects for various apply() operations:
+
+template <class T> struct Assign {
+  void operator()(T &a, const T &c) { a = c; }
+};
+
+template <class T> struct Add_assign {
+  void operator()(T &a, const T &c) { a += c; }
+};
+template <class T> struct Mul_assign {
+  void operator()(T &a, const T &c) { a *= c; }
+};
+template <class T> struct Minus_assign {
+  void operator()(T &a, const T &c) { a -= c; }
+};
+template <class T> struct Div_assign {
+  void operator()(T &a, const T &c) { a /= c; }
+};
+template <class T> struct Mod_assign {
+  void operator()(T &a, const T &c) { a %= c; }
+};
+template <class T> struct Or_assign {
+  void operator()(T &a, const T &c) { a |= c; }
+};
+template <class T> struct Xor_assign {
+  void operator()(T &a, const T &c) { a ^= c; }
+};
+template <class T> struct And_assign {
+  void operator()(T &a, const T &c) { a &= c; }
+};
+
+template <class T> struct Not_assign {
+  void operator()(T &a) { a = !a; }
+};
+
+template <class T> struct Not {
+  T operator()(T &a) { return !a; }
+};
+
+template <class T> struct Unary_minus {
+  T operator()(T &a) { return -a; }
+};
+
+template <class T> struct Complement {
+  T operator()(T &a) { return ~a; }
+};
+
+//-----------------------------------------------------------------------------
+
+// Matrix_base represents the common part of the Matrix classes:
+template <class T> class Matrix_base {
+  // matrixs store their memory (elements) in Matrix_base and have copy
+  // semantics Matrix_base does element-wise operations
+protected:
+  T *elem; // vector? no: we couldn't easily provide a vector for a slice
+  const Index sz;
+  mutable bool owns;
+  mutable bool xfer;
+
+public:
+  Matrix_base(Index n)
+      : elem(new T[n]()), sz(n), owns(true), xfer(false)
+  // matrix of n elements (default initialized)
+  {
+    // std::cerr << "new[" << n << "]->" << elem << "\n";
+  }
+
+  Matrix_base(Index n, T *p)
+      : elem(p), sz(n), owns(false), xfer(false)
+  // descriptor for matrix of n elements owned by someone else
+  {}
+
+  ~Matrix_base() {
+    if (owns) {
+      // std::cerr << "delete[" << sz << "] " << elem << "\n";
+      delete[] elem;
+    }
+  }
+
+  // if necessay, we can get to the raw matrix:
+  T *data() { return elem; }
+  const T *data() const { return elem; }
+  Index size() const { return sz; }
+
+  void copy_elements(const Matrix_base &a) {
+    if (sz != a.sz)
+      error("copy_elements()");
+    for (Index i = 0; i < sz; ++i)
+      elem[i] = a.elem[i];
+  }
+
+  void base_assign(const Matrix_base &a) { copy_elements(a); }
+
+  void base_copy(const Matrix_base &a) {
+    if (a.xfer) { // a is just about to be deleted
+                  // so we can transfer ownership rather than copy
+      // std::cerr << "xfer @" << a.elem << " [" << a.sz << "]\n";
+      elem = a.elem;
+      a.xfer = false; // note: modifies source
+      a.owns = false;
+    } else {
+      elem = new T[a.sz];
+      // std::cerr << "base copy @" << a.elem << " [" << a.sz << "]\n";
+      copy_elements(a);
+    }
+    owns = true;
+    xfer = false;
+  }
+
+  // to get the elements of a local matrix out of a function without copying:
+  void base_xfer(Matrix_base &x) {
+    if (owns == false)
+      error("cannot xfer() non-owner");
+    owns = false;  // now the elements are safe from deletion by original owner
+    x.xfer = true; // target asserts temporary ownership
+    x.owns = true;
+  }
+
+  template <class F> void base_apply(F f) {
+    for (Index i = 0; i < size(); ++i)
+      f(elem[i]);
+  }
+  template <class F> void base_apply(F f, const T &c) {
+    for (Index i = 0; i < size(); ++i)
+      f(elem[i], c);
+  }
+
+private:
+  void operator=(const Matrix_base &); // no ordinary copy of bases
+  Matrix_base(const Matrix_base &);
+};
+
+//-----------------------------------------------------------------------------
+
+template <class T> class Matrix<T, 1> : public Matrix_base<T> {
+  const Index d1;
+
+protected:
+  // for use by Row:
+  Matrix(Index n1, T *p) : Matrix_base<T>(n1, p), d1(n1) {
+    // std::cerr << "construct 1D Matrix from data\n";
+  }
+
+public:
+  Matrix(Index n1) : Matrix_base<T>(n1), d1(n1) {}
+
+  Matrix(Row<T, 1> &a) : Matrix_base<T>(a.dim1(), a.p), d1(a.dim1()) {
+    // std::cerr << "construct 1D Matrix from Row\n";
+  }
+
+  // copy constructor: let the base do the copy:
+  Matrix(const Matrix &a) : Matrix_base<T>(a.size(), 0), d1(a.d1) {
+    // std::cerr << "copy ctor\n";
+    this->base_copy(a);
+  }
+
+  template <int n>
+  Matrix(const T (&a)[n])
+      : Matrix_base<T>(n), d1(n)
+  // deduce "n" (and "T"), Matrix_base allocates T[n]
+  {
+    // std::cerr << "matrix ctor\n";
+    for (Index i = 0; i < n; ++i)
+      this->elem[i] = a[i];
+  }
+
+  Matrix(const T *p, Index n)
+      : Matrix_base<T>(n), d1(n)
+  // Matrix_base allocates T[n]
+  {
+    // std::cerr << "matrix ctor\n";
+    for (Index i = 0; i < n; ++i)
+      this->elem[i] = p[i];
+  }
+
+  template <class F>
+  Matrix(const Matrix &a, F f)
+      : Matrix_base<T>(a.size()), d1(a.d1)
+  // construct a new Matrix with element's that are functions of a's elements:
+  // does not modify a unless f has been specifically programmed to modify its
+  // argument T f(const T&) would be a typical type for f
+  {
+    for (Index i = 0; i < this->sz; ++i)
+      this->elem[i] = f(a.elem[i]);
+  }
+
+  template <class F, class Arg>
+  Matrix(const Matrix &a, F f, const Arg &t1)
+      : Matrix_base<T>(a.size()), d1(a.d1)
+  // construct a new Matrix with element's that are functions of a's elements:
+  // does not modify a unless f has been specifically programmed to modify its
+  // argument T f(const T&, const Arg&) would be a typical type for f
+  {
+    for (Index i = 0; i < this->sz; ++i)
+      this->elem[i] = f(a.elem[i], t1);
+  }
+
+  Matrix &operator=(const Matrix &a)
+  // copy assignment: let the base do the copy
+  {
+    // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<<
+    // ")\n";
+    if (d1 != a.d1)
+      error("length error in 1D=");
+    this->base_assign(a);
+    return *this;
+  }
+
+  ~Matrix() {}
+
+  Index dim1() const { return d1; } // number of elements in a row
+
+  Matrix xfer() // make an Matrix to move elements out of a scope
+  {
+    Matrix x(dim1(), this->data()); // make a descriptor
+    this->base_xfer(x);             // transfer (temporary) ownership to x
+    return x;
+  }
+
+  void range_check(Index n1) const {
+    // std::cerr << "range check: (" << d1 << "): " << n1 << "\n";
+    if (n1 < 0 || d1 <= n1)
+      error("1D range error: dimension 1");
+  }
+
+  // subscripting:
+  T &operator()(Index n1) {
+    range_check(n1);
+    return this->elem[n1];
+  }
+  const T &operator()(Index n1) const {
+    range_check(n1);
+    return this->elem[n1];
+  }
+
+  // slicing (the same as subscripting for 1D matrixs):
+  T &operator[](Index n) { return row(n); }
+  const T &operator[](Index n) const { return row(n); }
+
+  T &row(Index n) {
+    range_check(n);
+    return this->elem[n];
+  }
+  const T &row(Index n) const {
+    range_check(n);
+    return this->elem[n];
+  }
+
+  Row<T, 1> slice(Index n)
+  // the last elements from a[n] onwards
+  {
+    if (n < 0)
+      n = 0;
+    else if (d1 < n)
+      n = d1; // one beyond the end
+    return Row<T, 1>(d1 - n, this->elem + n);
+  }
+
+  const Row<T, 1> slice(Index n) const
+  // the last elements from a[n] onwards
+  {
+    if (n < 0)
+      n = 0;
+    else if (d1 < n)
+      n = d1; // one beyond the end
+    return Row<T, 1>(d1 - n, this->elem + n);
+  }
+
+  Row<T, 1> slice(Index n, Index m)
+  // m elements starting with a[n]
+  {
+    if (n < 0)
+      n = 0;
+    else if (d1 < n)
+      n = d1; // one beyond the end
+    if (m < 0)
+      m = 0;
+    else if (d1 < n + m)
+      m = d1 - n;
+    return Row<T, 1>(m, this->elem + n);
+  }
+
+  const Row<T, 1> slice(Index n, Index m) const
+  // m elements starting with a[n]
+  {
+    if (n < 0)
+      n = 0;
+    else if (d1 < n)
+      n = d1; // one beyond the end
+    if (m < 0)
+      m = 0;
+    else if (d1 < n + m)
+      m = d1 - n;
+    return Row<T, 1>(m, this->elem + n);
+  }
+
+  // element-wise operations:
+  template <class F> Matrix &apply(F f) {
+    this->base_apply(f);
+    return *this;
+  }
+  template <class F> Matrix &apply(F f, const T &c) {
+    this->base_apply(f, c);
+    return *this;
+  }
+
+  Matrix &operator=(const T &c) {
+    this->base_apply(Assign<T>(), c);
+    return *this;
+  }
+
+  Matrix &operator*=(const T &c) {
+    this->base_apply(Mul_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator/=(const T &c) {
+    this->base_apply(Div_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator%=(const T &c) {
+    this->base_apply(Mod_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator+=(const T &c) {
+    this->base_apply(Add_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator-=(const T &c) {
+    this->base_apply(Minus_assign<T>(), c);
+    return *this;
+  }
+
+  Matrix &operator&=(const T &c) {
+    this->base_apply(And_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator|=(const T &c) {
+    this->base_apply(Or_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator^=(const T &c) {
+    this->base_apply(Xor_assign<T>(), c);
+    return *this;
+  }
+
+  Matrix operator!() { return xfer(Matrix(*this, Not<T>())); }
+  Matrix operator-() { return xfer(Matrix(*this, Unary_minus<T>())); }
+  Matrix operator~() { return xfer(Matrix(*this, Complement<T>())); }
+
+  template <class F> Matrix apply_new(F f) { return xfer(Matrix(*this, f)); }
+
+  void swap_rows(Index i, Index j)
+  // swap_rows() uses a row's worth of memory for better run-time performance
+  // if you want pairwise swap, just write it yourself
+  {
+    if (i == j)
+      return;
+    /*
+        Matrix<T,1> temp = (*this)[i];
+        (*this)[i] = (*this)[j];
+        (*this)[j] = temp;
+    */
+    Index max = (*this)[i].size();
+    for (Index ii = 0; ii < max; ++ii)
+      std::swap((*this)(i, ii), (*this)(j, ii));
+  }
+};
+
+//-----------------------------------------------------------------------------
+
+template <class T> class Matrix<T, 2> : public Matrix_base<T> {
+  const Index d1;
+  const Index d2;
+
+protected:
+  // for use by Row:
+  Matrix(Index n1, Index n2, T *p)
+      : Matrix_base<T>(n1 * n2, p), d1(n1), d2(n2) {
+    //  std::cerr << "construct 3D Matrix from data\n";
+  }
+
+public:
+  Matrix(Index n1, Index n2) : Matrix_base<T>(n1 * n2), d1(n1), d2(n2) {}
+
+  Matrix(Row<T, 2> &a)
+      : Matrix_base<T>(a.dim1() * a.dim2(), a.p), d1(a.dim1()), d2(a.dim2()) {
+    // std::cerr << "construct 2D Matrix from Row\n";
+  }
+
+  // copy constructor: let the base do the copy:
+  Matrix(const Matrix &a) : Matrix_base<T>(a.size(), 0), d1(a.d1), d2(a.d2) {
+    // std::cerr << "copy ctor\n";
+    this->base_copy(a);
+  }
+
+  template <int n1, int n2>
+  Matrix(const T (&a)[n1][n2])
+      : Matrix_base<T>(n1 * n2), d1(n1), d2(n2)
+  // deduce "n1", "n2" (and "T"), Matrix_base allocates T[n1*n2]
+  {
+    // std::cerr << "matrix ctor (" << n1 << "," << n2 << ")\n";
+    for (Index i = 0; i < n1; ++i)
+      for (Index j = 0; j < n2; ++j)
+        this->elem[i * n2 + j] = a[i][j];
+  }
+
+  template <class F>
+  Matrix(const Matrix &a, F f)
+      : Matrix_base<T>(a.size()), d1(a.d1), d2(a.d2)
+  // construct a new Matrix with element's that are functions of a's elements:
+  // does not modify a unless f has been specifically programmed to modify its
+  // argument T f(const T&) would be a typical type for f
+  {
+    for (Index i = 0; i < this->sz; ++i)
+      this->elem[i] = f(a.elem[i]);
+  }
+
+  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)
+  // construct a new Matrix with element's that are functions of a's elements:
+  // does not modify a unless f has been specifically programmed to modify its
+  // argument T f(const T&, const Arg&) would be a typical type for f
+  {
+    for (Index i = 0; i < this->sz; ++i)
+      this->elem[i] = f(a.elem[i], t1);
+  }
+
+  Matrix &operator=(const Matrix &a)
+  // copy assignment: let the base do the copy
+  {
+    // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<<
+    // ")\n";
+    if (d1 != a.d1 || d2 != a.d2)
+      error("length error in 2D =");
+    this->base_assign(a);
+    return *this;
+  }
+
+  ~Matrix() {}
+
+  Index dim1() const { return d1; } // number of elements in a row
+  Index dim2() const { return d2; } // number of elements in a column
+
+  Matrix xfer() // make an Matrix to move elements out of a scope
+  {
+    Matrix x(dim1(), dim2(), this->data()); // make a descriptor
+    this->base_xfer(x); // transfer (temporary) ownership to x
+    return x;
+  }
+
+  void range_check(Index n1, Index n2) const {
+    // std::cerr << "range check: (" << d1 << "," << d2 << "): " << n1 << " " <<
+    // n2 << "\n";
+    if (n1 < 0 || d1 <= n1)
+      error("2D range error: dimension 1");
+    if (n2 < 0 || d2 <= n2)
+      error("2D range error: dimension 2");
+  }
+
+  // subscripting:
+  T &operator()(Index n1, Index n2) {
+    range_check(n1, n2);
+    return this->elem[n1 * d2 + n2];
+  }
+  const T &operator()(Index n1, Index n2) const {
+    range_check(n1, n2);
+    return this->elem[n1 * d2 + n2];
+  }
+
+  // slicing (return a row):
+  Row<T, 1> operator[](Index n) { return row(n); }
+  const Row<T, 1> operator[](Index n) const { return row(n); }
+
+  Row<T, 1> row(Index n) {
+    range_check(n, 0);
+    return Row<T, 1>(d2, &this->elem[n * d2]);
+  }
+  const Row<T, 1> row(Index n) const {
+    range_check(n, 0);
+    return Row<T, 1>(d2, &this->elem[n * d2]);
+  }
+
+  Row<T, 2> slice(Index n)
+  // rows [n:d1)
+  {
+    if (n < 0)
+      n = 0;
+    else if (d1 < n)
+      n = d1; // one beyond the end
+    return Row<T, 2>(d1 - n, d2, this->elem + n * d2);
+  }
+
+  const Row<T, 2> slice(Index n) const
+  // rows [n:d1)
+  {
+    if (n < 0)
+      n = 0;
+    else if (d1 < n)
+      n = d1; // one beyond the end
+    return Row<T, 2>(d1 - n, d2, this->elem + n * d2);
+  }
+
+  Row<T, 2> slice(Index n, Index m)
+  // the rows [n:m)
+  {
+    if (n < 0)
+      n = 0;
+    if (d1 < m)
+      m = d1; // one beyond the end
+    return Row<T, 2>(m - n, d2, this->elem + n * d2);
+  }
+
+  const Row<T, 2> slice(Index n, Index m) const
+  // the rows [n:sz)
+  {
+    if (n < 0)
+      n = 0;
+    if (d1 < m)
+      m = d1; // one beyond the end
+    return Row<T, 2>(m - n, d2, this->elem + n * d2);
+  }
+
+  // Column<T,1> column(Index n); // not (yet) implemented: requies strides and
+  // operations on columns
+
+  // element-wise operations:
+  template <class F> Matrix &apply(F f) {
+    this->base_apply(f);
+    return *this;
+  }
+  template <class F> Matrix &apply(F f, const T &c) {
+    this->base_apply(f, c);
+    return *this;
+  }
+
+  Matrix &operator=(const T &c) {
+    this->base_apply(Assign<T>(), c);
+    return *this;
+  }
+
+  Matrix &operator*=(const T &c) {
+    this->base_apply(Mul_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator/=(const T &c) {
+    this->base_apply(Div_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator%=(const T &c) {
+    this->base_apply(Mod_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator+=(const T &c) {
+    this->base_apply(Add_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator-=(const T &c) {
+    this->base_apply(Minus_assign<T>(), c);
+    return *this;
+  }
+
+  Matrix &operator&=(const T &c) {
+    this->base_apply(And_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator|=(const T &c) {
+    this->base_apply(Or_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator^=(const T &c) {
+    this->base_apply(Xor_assign<T>(), c);
+    return *this;
+  }
+
+  Matrix operator!() { return xfer(Matrix(*this, Not<T>())); }
+  Matrix operator-() { return xfer(Matrix(*this, Unary_minus<T>())); }
+  Matrix operator~() { return xfer(Matrix(*this, Complement<T>())); }
+
+  template <class F> Matrix apply_new(F f) { return xfer(Matrix(*this, f)); }
+
+  void swap_rows(Index i, Index j)
+  // swap_rows() uses a row's worth of memory for better run-time performance
+  // if you want pairwise swap, just write it yourself
+  {
+    if (i == j)
+      return;
+    /*
+        Matrix<T,1> temp = (*this)[i];
+        (*this)[i] = (*this)[j];
+        (*this)[j] = temp;
+    */
+    Index max = (*this)[i].size();
+    for (Index ii = 0; ii < max; ++ii)
+      std::swap((*this)(i, ii), (*this)(j, ii));
+  }
+};
+
+//-----------------------------------------------------------------------------
+
+template <class T> class Matrix<T, 3> : public Matrix_base<T> {
+  const Index d1;
+  const Index d2;
+  const Index d3;
+
+protected:
+  // for use by Row:
+  Matrix(Index n1, Index n2, Index n3, T *p)
+      : Matrix_base<T>(n1 * n2 * n3, p), d1(n1), d2(n2), d3(n3) {
+    // std::cerr << "construct 3D Matrix from data\n";
+  }
+
+public:
+  Matrix(Index n1, Index n2, Index n3)
+      : Matrix_base<T>(n1 * n2 * n3), d1(n1), d2(n2), d3(n3) {}
+
+  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()) {
+    // std::cerr << "construct 3D Matrix from Row\n";
+  }
+
+  // copy constructor: let the base do the copy:
+  Matrix(const Matrix &a)
+      : Matrix_base<T>(a.size(), 0), d1(a.d1), d2(a.d2), d3(a.d3) {
+    // std::cerr << "copy ctor\n";
+    this->base_copy(a);
+  }
+
+  template <int n1, int n2, int n3>
+  Matrix(const T (&a)[n1][n2][n3])
+      : Matrix_base<T>(n1 * n2), d1(n1), d2(n2), d3(n3)
+  // deduce "n1", "n2", "n3" (and "T"), Matrix_base allocates T[n1*n2*n3]
+  {
+    // std::cerr << "matrix ctor\n";
+    for (Index i = 0; i < n1; ++i)
+      for (Index j = 0; j < n2; ++j)
+        for (Index k = 0; k < n3; ++k)
+          this->elem[i * n2 * n3 + j * n3 + k] = a[i][j][k];
+  }
+
+  template <class F>
+  Matrix(const Matrix &a, F f)
+      : Matrix_base<T>(a.size()), d1(a.d1), d2(a.d2), d3(a.d3)
+  // construct a new Matrix with element's that are functions of a's elements:
+  // does not modify a unless f has been specifically programmed to modify its
+  // argument T f(const T&) would be a typical type for f
+  {
+    for (Index i = 0; i < this->sz; ++i)
+      this->elem[i] = f(a.elem[i]);
+  }
+
+  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)
+  // construct a new Matrix with element's that are functions of a's elements:
+  // does not modify a unless f has been specifically programmed to modify its
+  // argument T f(const T&, const Arg&) would be a typical type for f
+  {
+    for (Index i = 0; i < this->sz; ++i)
+      this->elem[i] = f(a.elem[i], t1);
+  }
+
+  Matrix &operator=(const Matrix &a)
+  // copy assignment: let the base do the copy
+  {
+    // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<<
+    // ")\n";
+    if (d1 != a.d1 || d2 != a.d2 || d3 != a.d3)
+      error("length error in 2D =");
+    this->base_assign(a);
+    return *this;
+  }
+
+  ~Matrix() {}
+
+  Index dim1() const { return d1; } // number of elements in a row
+  Index dim2() const { return d2; } // number of elements in a column
+  Index dim3() const { return d3; } // number of elements in a depth
+
+  Matrix xfer() // make an Matrix to move elements out of a scope
+  {
+    Matrix x(dim1(), dim2(), dim3(), this->data()); // make a descriptor
+    this->base_xfer(x); // transfer (temporary) ownership to x
+    return x;
+  }
+
+  void range_check(Index n1, Index n2, Index n3) const {
+    // std::cerr << "range check: (" << d1 << "," << d2 << "): " << n1 << " " <<
+    // n2 << "\n";
+    if (n1 < 0 || d1 <= n1)
+      error("3D range error: dimension 1");
+    if (n2 < 0 || d2 <= n2)
+      error("3D range error: dimension 2");
+    if (n3 < 0 || d3 <= n3)
+      error("3D range error: dimension 3");
+  }
+
+  // subscripting:
+  T &operator()(Index n1, Index n2, Index n3) {
+    range_check(n1, n2, n3);
+    return this->elem[d2 * d3 * n1 + d3 * n2 + n3];
+  };
+  const T &operator()(Index n1, Index n2, Index n3) const {
+    range_check(n1, n2, n3);
+    return this->elem[d2 * d3 * n1 + d3 * n2 + n3];
+  };
+
+  // slicing (return a row):
+  Row<T, 2> operator[](Index n) { return row(n); }
+  const Row<T, 2> operator[](Index n) const { return row(n); }
+
+  Row<T, 2> row(Index n) {
+    range_check(n, 0, 0);
+    return Row<T, 2>(d2, d3, &this->elem[n * d2 * d3]);
+  }
+  const Row<T, 2> row(Index n) const {
+    range_check(n, 0, 0);
+    return Row<T, 2>(d2, d3, &this->elem[n * d2 * d3]);
+  }
+
+  Row<T, 3> slice(Index n)
+  // rows [n:d1)
+  {
+    if (n < 0)
+      n = 0;
+    else if (d1 < n)
+      n = d1; // one beyond the end
+    return Row<T, 3>(d1 - n, d2, d3, this->elem + n * d2 * d3);
+  }
+
+  const Row<T, 3> slice(Index n) const
+  // rows [n:d1)
+  {
+    if (n < 0)
+      n = 0;
+    else if (d1 < n)
+      n = d1; // one beyond the end
+    return Row<T, 3>(d1 - n, d2, d3, this->elem + n * d2 * d3);
+  }
+
+  Row<T, 3> slice(Index n, Index m)
+  // the rows [n:m)
+  {
+    if (n < 0)
+      n = 0;
+    if (d1 < m)
+      m = d1; // one beyond the end
+    return Row<T, 3>(m - n, d2, d3, this->elem + n * d2 * d3);
+  }
+
+  const Row<T, 3> slice(Index n, Index m) const
+  // the rows [n:sz)
+  {
+    if (n < 0)
+      n = 0;
+    if (d1 < m)
+      m = d1; // one beyond the end
+    return Row<T, 3>(m - n, d2, d3, this->elem + n * d2 * d3);
+  }
+
+  // Column<T,2> column(Index n); // not (yet) implemented: requies strides and
+  // operations on columns
+
+  // element-wise operations:
+  template <class F> Matrix &apply(F f) {
+    this->base_apply(f);
+    return *this;
+  }
+  template <class F> Matrix &apply(F f, const T &c) {
+    this->base_apply(f, c);
+    return *this;
+  }
+
+  Matrix &operator=(const T &c) {
+    this->base_apply(Assign<T>(), c);
+    return *this;
+  }
+
+  Matrix &operator*=(const T &c) {
+    this->base_apply(Mul_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator/=(const T &c) {
+    this->base_apply(Div_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator%=(const T &c) {
+    this->base_apply(Mod_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator+=(const T &c) {
+    this->base_apply(Add_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator-=(const T &c) {
+    this->base_apply(Minus_assign<T>(), c);
+    return *this;
+  }
+
+  Matrix &operator&=(const T &c) {
+    this->base_apply(And_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator|=(const T &c) {
+    this->base_apply(Or_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator^=(const T &c) {
+    this->base_apply(Xor_assign<T>(), c);
+    return *this;
+  }
+
+  Matrix operator!() { return xfer(Matrix(*this, Not<T>())); }
+  Matrix operator-() { return xfer(Matrix(*this, Unary_minus<T>())); }
+  Matrix operator~() { return xfer(Matrix(*this, Complement<T>())); }
+
+  template <class F> Matrix apply_new(F f) { return xfer(Matrix(*this, f)); }
+
+  void swap_rows(Index i, Index j)
+  // swap_rows() uses a row's worth of memory for better run-time performance
+  // if you want pairwise swap, just write it yourself
+  {
+    if (i == j)
+      return;
+
+    Matrix<T, 2> temp = (*this)[i];
+    (*this)[i] = (*this)[j];
+    (*this)[j] = temp;
+  }
+};
+
+//-----------------------------------------------------------------------------
+
+template <class T>
+Matrix<T> scale_and_add(const Matrix<T> &a, T c, const Matrix<T> &b)
+//  Fortran "saxpy()" ("fma" for "fused multiply-add").
+// will the copy constructor be called twice and defeat the xfer optimization?
+{
+  if (a.size() != b.size())
+    error("sizes wrong for scale_and_add()");
+  Matrix<T> res(a.size());
+  for (Index i = 0; i < a.size(); ++i)
+    res[i] += a[i] * c + b[i];
+  return res.xfer();
+}
+
+//-----------------------------------------------------------------------------
+
+template <class T> T dot_product(const Matrix<T> &a, const Matrix<T> &b) {
+  if (a.size() != b.size())
+    error("sizes wrong for dot product");
+  T sum = 0;
+  for (Index i = 0; i < a.size(); ++i)
+    sum += a[i] * b[i];
+  return sum;
+}
+
+//-----------------------------------------------------------------------------
+
+template <class T, int N> Matrix<T, N> xfer(Matrix<T, N> &a) {
+  return a.xfer();
+}
+
+//-----------------------------------------------------------------------------
+
+template <class F, class A> A apply(F f, A x) {
+  A res(x, f);
+  return xfer(res);
+}
+template <class F, class Arg, class A> A apply(F f, A x, Arg a) {
+  A res(x, f, a);
+  return xfer(res);
+}
+
+//-----------------------------------------------------------------------------
+
+// The default values for T and D have been declared before.
+template <class T, int D> class Row {
+  // general version exists only to allow specializations
+private:
+  Row();
+};
+
+//-----------------------------------------------------------------------------
+
+template <class T> class Row<T, 1> : public Matrix<T, 1> {
+public:
+  Row(Index n, T *p) : Matrix<T, 1>(n, p) {}
+
+  Matrix<T, 1> &operator=(const T &c) {
+    this->base_apply(Assign<T>(), c);
+    return *this;
+  }
+
+  Matrix<T, 1> &operator=(const Matrix<T, 1> &a) {
+    return *static_cast<Matrix<T, 1> *>(this) = a;
+  }
+};
+
+//-----------------------------------------------------------------------------
+
+template <class T> class Row<T, 2> : public Matrix<T, 2> {
+public:
+  Row(Index n1, Index n2, T *p) : Matrix<T, 2>(n1, n2, p) {}
+
+  Matrix<T, 2> &operator=(const T &c) {
+    this->base_apply(Assign<T>(), c);
+    return *this;
+  }
+
+  Matrix<T, 2> &operator=(const Matrix<T, 2> &a) {
+    return *static_cast<Matrix<T, 2> *>(this) = a;
+  }
+};
+
+//-----------------------------------------------------------------------------
+
+template <class T> class Row<T, 3> : public Matrix<T, 3> {
+public:
+  Row(Index n1, Index n2, Index n3, T *p) : Matrix<T, 3>(n1, n2, n3, p) {}
+
+  Matrix<T, 3> &operator=(const T &c) {
+    this->base_apply(Assign<T>(), c);
+    return *this;
+  }
+
+  Matrix<T, 3> &operator=(const Matrix<T, 3> &a) {
+    return *static_cast<Matrix<T, 3> *>(this) = a;
+  }
+};
+
+//-----------------------------------------------------------------------------
+
+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) {
+  Matrix<T> res(a.size());
+  if (a.size() != b.size())
+    error("sizes wrong for scale_and_add");
+  for (Index i = 0; i < a.size(); ++i)
+    res[i] += a[i] * c + b[i];
+  return res.xfer();
+}
+
+//-----------------------------------------------------------------------------
+
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+
+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;
+}
+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;
+}
+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;
+}
+
+//-----------------------------------------------------------------------------
+
+} // namespace Numeric_lib
+#endif
diff --git a/include/Numeric_lib/Matrix11.hpp b/include/Numeric_lib/Matrix11.hpp
new file mode 100644
index 0000000..ae2d6ac
--- /dev/null
+++ b/include/Numeric_lib/Matrix11.hpp
@@ -0,0 +1,1050 @@
+
+/*
+    warning: this small multidimensional matrix library uses a few features
+    not taught in ENGR112 and not explained in elementary textbooks
+
+        C++11 version
+
+    (c) Bjarne Stroustrup, Texas A&M University.
+
+    Use as you like as long as you acknowledge the source.
+*/
+
+#ifndef MATRIX_LIB
+#define MATRIX_LIB
+
+#include <algorithm>
+#include <string>
+
+namespace Numeric_lib {
+
+//-----------------------------------------------------------------------------
+
+struct Matrix_error {
+  std::string name;
+  Matrix_error(const char *q) : name(q) {}
+  Matrix_error(std::string n) : name(n) {}
+};
+
+//-----------------------------------------------------------------------------
+
+inline void error(const char *p) { throw Matrix_error(p); }
+
+//-----------------------------------------------------------------------------
+
+typedef long Index; // I still dislike unsigned
+
+//-----------------------------------------------------------------------------
+
+// The general Matrix template is simply a prop for its specializations:
+template <class T = double, int D = 1> class Matrix {
+  // multidimensional matrix class
+  // ( ) does multidimensional subscripting
+  // [ ] does C style "slicing": gives an N-1 dimensional matrix from an N
+  // dimensional one row() is equivalent to [ ] column() is not (yet)
+  // implemented because it requires strides. = has copy semantics ( ) and [ ]
+  // are range checked slice() to give sub-ranges
+private:
+  Matrix(); // this should never be compiled
+  //	template<class A> Matrix(A);
+};
+
+//-----------------------------------------------------------------------------
+
+template <class T = double, int D = 1> class Row; // forward declaration
+
+//-----------------------------------------------------------------------------
+
+// function objects for various apply() operations:
+
+template <class T> struct Assign {
+  void operator()(T &a, const T &c) { a = c; }
+};
+
+template <class T> struct Add_assign {
+  void operator()(T &a, const T &c) { a += c; }
+};
+template <class T> struct Mul_assign {
+  void operator()(T &a, const T &c) { a *= c; }
+};
+template <class T> struct Minus_assign {
+  void operator()(T &a, const T &c) { a -= c; }
+};
+template <class T> struct Div_assign {
+  void operator()(T &a, const T &c) { a /= c; }
+};
+template <class T> struct Mod_assign {
+  void operator()(T &a, const T &c) { a %= c; }
+};
+template <class T> struct Or_assign {
+  void operator()(T &a, const T &c) { a |= c; }
+};
+template <class T> struct Xor_assign {
+  void operator()(T &a, const T &c) { a ^= c; }
+};
+template <class T> struct And_assign {
+  void operator()(T &a, const T &c) { a &= c; }
+};
+
+template <class T> struct Not_assign {
+  void operator()(T &a) { a = !a; }
+};
+
+template <class T> struct Not {
+  T operator()(T &a) { return !a; }
+};
+
+template <class T> struct Unary_minus {
+  T operator()(T &a) { return -a; }
+};
+
+template <class T> struct Complement {
+  T operator()(T &a) { return ~a; }
+};
+
+//-----------------------------------------------------------------------------
+
+// Matrix_base represents the common part of the Matrix classes:
+template <class T> class Matrix_base {
+  // matrixs store their memory (elements) in Matrix_base and have copy
+  // semantics Matrix_base does element-wise operations
+protected:
+  T *elem; // vector? no: we couldn't easily provide a vector for a slice
+  const Index sz;
+  mutable bool owns;
+  mutable bool xfer;
+
+public:
+  Matrix_base(Index n)
+      : elem(new T[n]()), sz(n), owns(true), xfer(false)
+  // matrix of n elements (default initialized)
+  {
+    // std::cerr << "new[" << n << "]->" << elem << "\n";
+  }
+
+  Matrix_base(Index n, T *p)
+      : elem(p), sz(n), owns(false), xfer(false)
+  // descriptor for matrix of n elements owned by someone else
+  {}
+
+  ~Matrix_base() {
+    if (owns) {
+      // std::cerr << "delete[" << sz << "] " << elem << "\n";
+      delete[] elem;
+    }
+  }
+
+  // if necessay, we can get to the raw matrix:
+  T *data() { return elem; }
+  const T *data() const { return elem; }
+  Index size() const { return sz; }
+
+  void copy_elements(const Matrix_base &a) {
+    if (sz != a.sz)
+      error("copy_elements()");
+    for (Index i = 0; i < sz; ++i)
+      elem[i] = a.elem[i];
+  }
+
+  void base_assign(const Matrix_base &a) { copy_elements(a); }
+
+  void base_copy(const Matrix_base &a) {
+    if (a.xfer) { // a is just about to be deleted
+                  // so we can transfer ownership rather than copy
+      // std::cerr << "xfer @" << a.elem << " [" << a.sz << "]\n";
+      elem = a.elem;
+      a.xfer = false; // note: modifies source
+      a.owns = false;
+    } else {
+      elem = new T[a.sz];
+      // std::cerr << "base copy @" << a.elem << " [" << a.sz << "]\n";
+      copy_elements(a);
+    }
+    owns = true;
+    xfer = false;
+  }
+
+  // to get the elements of a local matrix out of a function without copying:
+  void base_xfer(Matrix_base &x) {
+    if (owns == false)
+      error("cannot xfer() non-owner");
+    owns = false;  // now the elements are safe from deletion by original owner
+    x.xfer = true; // target asserts temporary ownership
+    x.owns = true;
+  }
+
+  template <class F> void base_apply(F f) {
+    for (Index i = 0; i < size(); ++i)
+      f(elem[i]);
+  }
+  template <class F> void base_apply(F f, const T &c) {
+    for (Index i = 0; i < size(); ++i)
+      f(elem[i], c);
+  }
+
+private:
+  void operator=(const Matrix_base &); // no ordinary copy of bases
+  Matrix_base(const Matrix_base &);
+};
+
+//-----------------------------------------------------------------------------
+
+template <class T> class Matrix<T, 1> : public Matrix_base<T> {
+  const Index d1;
+
+protected:
+  // for use by Row:
+  Matrix(Index n1, T *p) : Matrix_base<T>(n1, p), d1(n1) {
+    // std::cerr << "construct 1D Matrix from data\n";
+  }
+
+public:
+  Matrix(Index n1) : Matrix_base<T>(n1), d1(n1) {}
+
+  Matrix(Row<T, 1> &a) : Matrix_base<T>(a.dim1(), a.p), d1(a.dim1()) {
+    // std::cerr << "construct 1D Matrix from Row\n";
+  }
+
+  // copy constructor: let the base do the copy:
+  Matrix(const Matrix &a) : Matrix_base<T>(a.size(), 0), d1(a.d1) {
+    // std::cerr << "copy ctor\n";
+    this->base_copy(a);
+  }
+
+  template <int n>
+  Matrix(const T (&a)[n])
+      : Matrix_base<T>(n), d1(n)
+  // deduce "n" (and "T"), Matrix_base allocates T[n]
+  {
+    // std::cerr << "matrix ctor\n";
+    for (Index i = 0; i < n; ++i)
+      this->elem[i] = a[i];
+  }
+
+  Matrix(const T *p, Index n)
+      : Matrix_base<T>(n), d1(n)
+  // Matrix_base allocates T[n]
+  {
+    // std::cerr << "matrix ctor\n";
+    for (Index i = 0; i < n; ++i)
+      this->elem[i] = p[i];
+  }
+
+  template <class F>
+  Matrix(const Matrix &a, F f)
+      : Matrix_base<T>(a.size()), d1(a.d1)
+  // construct a new Matrix with element's that are functions of a's elements:
+  // does not modify a unless f has been specifically programmed to modify its
+  // argument T f(const T&) would be a typical type for f
+  {
+    for (Index i = 0; i < this->sz; ++i)
+      this->elem[i] = f(a.elem[i]);
+  }
+
+  template <class F, class Arg>
+  Matrix(const Matrix &a, F f, const Arg &t1)
+      : Matrix_base<T>(a.size()), d1(a.d1)
+  // construct a new Matrix with element's that are functions of a's elements:
+  // does not modify a unless f has been specifically programmed to modify its
+  // argument T f(const T&, const Arg&) would be a typical type for f
+  {
+    for (Index i = 0; i < this->sz; ++i)
+      this->elem[i] = f(a.elem[i], t1);
+  }
+
+  Matrix &operator=(const Matrix &a)
+  // copy assignment: let the base do the copy
+  {
+    // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<<
+    // ")\n";
+    if (d1 != a.d1)
+      error("length error in 1D=");
+    this->base_assign(a);
+    return *this;
+  }
+
+  ~Matrix() {}
+
+  Index dim1() const { return d1; } // number of elements in a row
+
+  Matrix xfer() // make an Matrix to move elements out of a scope
+  {
+    Matrix x(dim1(), this->data()); // make a descriptor
+    this->base_xfer(x);             // transfer (temporary) ownership to x
+    return x;
+  }
+
+  void range_check(Index n1) const {
+    // std::cerr << "range check: (" << d1 << "): " << n1 << "\n";
+    if (n1 < 0 || d1 <= n1)
+      error("1D range error: dimension 1");
+  }
+
+  // subscripting:
+  T &operator()(Index n1) {
+    range_check(n1);
+    return this->elem[n1];
+  }
+  const T &operator()(Index n1) const {
+    range_check(n1);
+    return this->elem[n1];
+  }
+
+  // slicing (the same as subscripting for 1D matrixs):
+  T &operator[](Index n) { return row(n); }
+  const T &operator[](Index n) const { return row(n); }
+
+  T &row(Index n) {
+    range_check(n);
+    return this->elem[n];
+  }
+  const T &row(Index n) const {
+    range_check(n);
+    return this->elem[n];
+  }
+
+  Row<T, 1> slice(Index n)
+  // the last elements from a[n] onwards
+  {
+    if (n < 0)
+      n = 0;
+    else if (d1 < n)
+      n = d1; // one beyond the end
+    return Row<T, 1>(d1 - n, this->elem + n);
+  }
+
+  const Row<T, 1> slice(Index n) const
+  // the last elements from a[n] onwards
+  {
+    if (n < 0)
+      n = 0;
+    else if (d1 < n)
+      n = d1; // one beyond the end
+    return Row<T, 1>(d1 - n, this->elem + n);
+  }
+
+  Row<T, 1> slice(Index n, Index m)
+  // m elements starting with a[n]
+  {
+    if (n < 0)
+      n = 0;
+    else if (d1 < n)
+      n = d1; // one beyond the end
+    if (m < 0)
+      m = 0;
+    else if (d1 < n + m)
+      m = d1 - n;
+    return Row<T, 1>(m, this->elem + n);
+  }
+
+  const Row<T, 1> slice(Index n, Index m) const
+  // m elements starting with a[n]
+  {
+    if (n < 0)
+      n = 0;
+    else if (d1 < n)
+      n = d1; // one beyond the end
+    if (m < 0)
+      m = 0;
+    else if (d1 < n + m)
+      m = d1 - n;
+    return Row<T, 1>(m, this->elem + n);
+  }
+
+  // element-wise operations:
+  template <class F> Matrix &apply(F f) {
+    this->base_apply(f);
+    return *this;
+  }
+  template <class F> Matrix &apply(F f, const T &c) {
+    this->base_apply(f, c);
+    return *this;
+  }
+
+  Matrix &operator=(const T &c) {
+    this->base_apply(Assign<T>(), c);
+    return *this;
+  }
+
+  Matrix &operator*=(const T &c) {
+    this->base_apply(Mul_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator/=(const T &c) {
+    this->base_apply(Div_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator%=(const T &c) {
+    this->base_apply(Mod_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator+=(const T &c) {
+    this->base_apply(Add_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator-=(const T &c) {
+    this->base_apply(Minus_assign<T>(), c);
+    return *this;
+  }
+
+  Matrix &operator&=(const T &c) {
+    this->base_apply(And_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator|=(const T &c) {
+    this->base_apply(Or_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator^=(const T &c) {
+    this->base_apply(Xor_assign<T>(), c);
+    return *this;
+  }
+
+  Matrix operator!() { return xfer(Matrix(*this, Not<T>())); }
+  Matrix operator-() { return xfer(Matrix(*this, Unary_minus<T>())); }
+  Matrix operator~() { return xfer(Matrix(*this, Complement<T>())); }
+
+  template <class F> Matrix apply_new(F f) { return xfer(Matrix(*this, f)); }
+
+  void swap_rows(Index i, Index j)
+  // swap_rows() uses a row's worth of memory for better run-time performance
+  // if you want pairwise swap, just write it yourself
+  {
+    if (i == j)
+      return;
+    /*
+        Matrix<T,1> temp = (*this)[i];
+        (*this)[i] = (*this)[j];
+        (*this)[j] = temp;
+    */
+    Index max = (*this)[i].size();
+    for (Index ii = 0; ii < max; ++ii)
+      std::swap((*this)(i, ii), (*this)(j, ii));
+  }
+};
+
+//-----------------------------------------------------------------------------
+
+template <class T> class Matrix<T, 2> : public Matrix_base<T> {
+  const Index d1;
+  const Index d2;
+
+protected:
+  // for use by Row:
+  Matrix(Index n1, Index n2, T *p)
+      : Matrix_base<T>(n1 * n2, p), d1(n1), d2(n2) {
+    //  std::cerr << "construct 3D Matrix from data\n";
+  }
+
+public:
+  Matrix(Index n1, Index n2) : Matrix_base<T>(n1 * n2), d1(n1), d2(n2) {}
+
+  Matrix(Row<T, 2> &a)
+      : Matrix_base<T>(a.dim1() * a.dim2(), a.p), d1(a.dim1()), d2(a.dim2()) {
+    // std::cerr << "construct 2D Matrix from Row\n";
+  }
+
+  // copy constructor: let the base do the copy:
+  Matrix(const Matrix &a) : Matrix_base<T>(a.size(), 0), d1(a.d1), d2(a.d2) {
+    // std::cerr << "copy ctor\n";
+    this->base_copy(a);
+  }
+
+  template <int n1, int n2>
+  Matrix(const T (&a)[n1][n2])
+      : Matrix_base<T>(n1 * n2), d1(n1), d2(n2)
+  // deduce "n1", "n2" (and "T"), Matrix_base allocates T[n1*n2]
+  {
+    // std::cerr << "matrix ctor (" << n1 << "," << n2 << ")\n";
+    for (Index i = 0; i < n1; ++i)
+      for (Index j = 0; j < n2; ++j)
+        this->elem[i * n2 + j] = a[i][j];
+  }
+
+  template <class F>
+  Matrix(const Matrix &a, F f)
+      : Matrix_base<T>(a.size()), d1(a.d1), d2(a.d2)
+  // construct a new Matrix with element's that are functions of a's elements:
+  // does not modify a unless f has been specifically programmed to modify its
+  // argument T f(const T&) would be a typical type for f
+  {
+    for (Index i = 0; i < this->sz; ++i)
+      this->elem[i] = f(a.elem[i]);
+  }
+
+  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)
+  // construct a new Matrix with element's that are functions of a's elements:
+  // does not modify a unless f has been specifically programmed to modify its
+  // argument T f(const T&, const Arg&) would be a typical type for f
+  {
+    for (Index i = 0; i < this->sz; ++i)
+      this->elem[i] = f(a.elem[i], t1);
+  }
+
+  Matrix &operator=(const Matrix &a)
+  // copy assignment: let the base do the copy
+  {
+    // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<<
+    // ")\n";
+    if (d1 != a.d1 || d2 != a.d2)
+      error("length error in 2D =");
+    this->base_assign(a);
+    return *this;
+  }
+
+  ~Matrix() {}
+
+  Index dim1() const { return d1; } // number of elements in a row
+  Index dim2() const { return d2; } // number of elements in a column
+
+  Matrix xfer() // make an Matrix to move elements out of a scope
+  {
+    Matrix x(dim1(), dim2(), this->data()); // make a descriptor
+    this->base_xfer(x); // transfer (temporary) ownership to x
+    return x;
+  }
+
+  void range_check(Index n1, Index n2) const {
+    // std::cerr << "range check: (" << d1 << "," << d2 << "): " << n1 << " " <<
+    // n2 << "\n";
+    if (n1 < 0 || d1 <= n1)
+      error("2D range error: dimension 1");
+    if (n2 < 0 || d2 <= n2)
+      error("2D range error: dimension 2");
+  }
+
+  // subscripting:
+  T &operator()(Index n1, Index n2) {
+    range_check(n1, n2);
+    return this->elem[n1 * d2 + n2];
+  }
+  const T &operator()(Index n1, Index n2) const {
+    range_check(n1, n2);
+    return this->elem[n1 * d2 + n2];
+  }
+
+  // slicing (return a row):
+  Row<T, 1> operator[](Index n) { return row(n); }
+  const Row<T, 1> operator[](Index n) const { return row(n); }
+
+  Row<T, 1> row(Index n) {
+    range_check(n, 0);
+    return Row<T, 1>(d2, &this->elem[n * d2]);
+  }
+  const Row<T, 1> row(Index n) const {
+    range_check(n, 0);
+    return Row<T, 1>(d2, &this->elem[n * d2]);
+  }
+
+  Row<T, 2> slice(Index n)
+  // rows [n:d1)
+  {
+    if (n < 0)
+      n = 0;
+    else if (d1 < n)
+      n = d1; // one beyond the end
+    return Row<T, 2>(d1 - n, d2, this->elem + n * d2);
+  }
+
+  const Row<T, 2> slice(Index n) const
+  // rows [n:d1)
+  {
+    if (n < 0)
+      n = 0;
+    else if (d1 < n)
+      n = d1; // one beyond the end
+    return Row<T, 2>(d1 - n, d2, this->elem + n * d2);
+  }
+
+  Row<T, 2> slice(Index n, Index m)
+  // the rows [n:m)
+  {
+    if (n < 0)
+      n = 0;
+    if (d1 < m)
+      m = d1; // one beyond the end
+    return Row<T, 2>(m - n, d2, this->elem + n * d2);
+  }
+
+  const Row<T, 2> slice(Index n, Index m) const
+  // the rows [n:sz)
+  {
+    if (n < 0)
+      n = 0;
+    if (d1 < m)
+      m = d1; // one beyond the end
+    return Row<T, 2>(m - n, d2, this->elem + n * d2);
+  }
+
+  // Column<T,1> column(Index n); // not (yet) implemented: requies strides and
+  // operations on columns
+
+  // element-wise operations:
+  template <class F> Matrix &apply(F f) {
+    this->base_apply(f);
+    return *this;
+  }
+  template <class F> Matrix &apply(F f, const T &c) {
+    this->base_apply(f, c);
+    return *this;
+  }
+
+  Matrix &operator=(const T &c) {
+    this->base_apply(Assign<T>(), c);
+    return *this;
+  }
+
+  Matrix &operator*=(const T &c) {
+    this->base_apply(Mul_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator/=(const T &c) {
+    this->base_apply(Div_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator%=(const T &c) {
+    this->base_apply(Mod_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator+=(const T &c) {
+    this->base_apply(Add_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator-=(const T &c) {
+    this->base_apply(Minus_assign<T>(), c);
+    return *this;
+  }
+
+  Matrix &operator&=(const T &c) {
+    this->base_apply(And_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator|=(const T &c) {
+    this->base_apply(Or_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator^=(const T &c) {
+    this->base_apply(Xor_assign<T>(), c);
+    return *this;
+  }
+
+  Matrix operator!() { return xfer(Matrix(*this, Not<T>())); }
+  Matrix operator-() { return xfer(Matrix(*this, Unary_minus<T>())); }
+  Matrix operator~() { return xfer(Matrix(*this, Complement<T>())); }
+
+  template <class F> Matrix apply_new(F f) { return xfer(Matrix(*this, f)); }
+
+  void swap_rows(Index i, Index j)
+  // swap_rows() uses a row's worth of memory for better run-time performance
+  // if you want pairwise swap, just write it yourself
+  {
+    if (i == j)
+      return;
+    /*
+        Matrix<T,1> temp = (*this)[i];
+        (*this)[i] = (*this)[j];
+        (*this)[j] = temp;
+    */
+    Index max = (*this)[i].size();
+    for (Index ii = 0; ii < max; ++ii)
+      std::swap((*this)(i, ii), (*this)(j, ii));
+  }
+};
+
+//-----------------------------------------------------------------------------
+
+template <class T> class Matrix<T, 3> : public Matrix_base<T> {
+  const Index d1;
+  const Index d2;
+  const Index d3;
+
+protected:
+  // for use by Row:
+  Matrix(Index n1, Index n2, Index n3, T *p)
+      : Matrix_base<T>(n1 * n2 * n3, p), d1(n1), d2(n2), d3(n3) {
+    // std::cerr << "construct 3D Matrix from data\n";
+  }
+
+public:
+  Matrix(Index n1, Index n2, Index n3)
+      : Matrix_base<T>(n1 * n2 * n3), d1(n1), d2(n2), d3(n3) {}
+
+  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()) {
+    // std::cerr << "construct 3D Matrix from Row\n";
+  }
+
+  // copy constructor: let the base do the copy:
+  Matrix(const Matrix &a)
+      : Matrix_base<T>(a.size(), 0), d1(a.d1), d2(a.d2), d3(a.d3) {
+    // std::cerr << "copy ctor\n";
+    this->base_copy(a);
+  }
+
+  template <int n1, int n2, int n3>
+  Matrix(const T (&a)[n1][n2][n3])
+      : Matrix_base<T>(n1 * n2), d1(n1), d2(n2), d3(n3)
+  // deduce "n1", "n2", "n3" (and "T"), Matrix_base allocates T[n1*n2*n3]
+  {
+    // std::cerr << "matrix ctor\n";
+    for (Index i = 0; i < n1; ++i)
+      for (Index j = 0; j < n2; ++j)
+        for (Index k = 0; k < n3; ++k)
+          this->elem[i * n2 * n3 + j * n3 + k] = a[i][j][k];
+  }
+
+  template <class F>
+  Matrix(const Matrix &a, F f)
+      : Matrix_base<T>(a.size()), d1(a.d1), d2(a.d2), d3(a.d3)
+  // construct a new Matrix with element's that are functions of a's elements:
+  // does not modify a unless f has been specifically programmed to modify its
+  // argument T f(const T&) would be a typical type for f
+  {
+    for (Index i = 0; i < this->sz; ++i)
+      this->elem[i] = f(a.elem[i]);
+  }
+
+  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)
+  // construct a new Matrix with element's that are functions of a's elements:
+  // does not modify a unless f has been specifically programmed to modify its
+  // argument T f(const T&, const Arg&) would be a typical type for f
+  {
+    for (Index i = 0; i < this->sz; ++i)
+      this->elem[i] = f(a.elem[i], t1);
+  }
+
+  Matrix &operator=(const Matrix &a)
+  // copy assignment: let the base do the copy
+  {
+    // std::cerr << "copy assignment (" << this->size() << ',' << a.size()<<
+    // ")\n";
+    if (d1 != a.d1 || d2 != a.d2 || d3 != a.d3)
+      error("length error in 2D =");
+    this->base_assign(a);
+    return *this;
+  }
+
+  ~Matrix() {}
+
+  Index dim1() const { return d1; } // number of elements in a row
+  Index dim2() const { return d2; } // number of elements in a column
+  Index dim3() const { return d3; } // number of elements in a depth
+
+  Matrix xfer() // make an Matrix to move elements out of a scope
+  {
+    Matrix x(dim1(), dim2(), dim3(), this->data()); // make a descriptor
+    this->base_xfer(x); // transfer (temporary) ownership to x
+    return x;
+  }
+
+  void range_check(Index n1, Index n2, Index n3) const {
+    // std::cerr << "range check: (" << d1 << "," << d2 << "): " << n1 << " " <<
+    // n2 << "\n";
+    if (n1 < 0 || d1 <= n1)
+      error("3D range error: dimension 1");
+    if (n2 < 0 || d2 <= n2)
+      error("3D range error: dimension 2");
+    if (n3 < 0 || d3 <= n3)
+      error("3D range error: dimension 3");
+  }
+
+  // subscripting:
+  T &operator()(Index n1, Index n2, Index n3) {
+    range_check(n1, n2, n3);
+    return this->elem[d2 * d3 * n1 + d3 * n2 + n3];
+  };
+  const T &operator()(Index n1, Index n2, Index n3) const {
+    range_check(n1, n2, n3);
+    return this->elem[d2 * d3 * n1 + d3 * n2 + n3];
+  };
+
+  // slicing (return a row):
+  Row<T, 2> operator[](Index n) { return row(n); }
+  const Row<T, 2> operator[](Index n) const { return row(n); }
+
+  Row<T, 2> row(Index n) {
+    range_check(n, 0, 0);
+    return Row<T, 2>(d2, d3, &this->elem[n * d2 * d3]);
+  }
+  const Row<T, 2> row(Index n) const {
+    range_check(n, 0, 0);
+    return Row<T, 2>(d2, d3, &this->elem[n * d2 * d3]);
+  }
+
+  Row<T, 3> slice(Index n)
+  // rows [n:d1)
+  {
+    if (n < 0)
+      n = 0;
+    else if (d1 < n)
+      n = d1; // one beyond the end
+    return Row<T, 3>(d1 - n, d2, d3, this->elem + n * d2 * d3);
+  }
+
+  const Row<T, 3> slice(Index n) const
+  // rows [n:d1)
+  {
+    if (n < 0)
+      n = 0;
+    else if (d1 < n)
+      n = d1; // one beyond the end
+    return Row<T, 3>(d1 - n, d2, d3, this->elem + n * d2 * d3);
+  }
+
+  Row<T, 3> slice(Index n, Index m)
+  // the rows [n:m)
+  {
+    if (n < 0)
+      n = 0;
+    if (d1 < m)
+      m = d1; // one beyond the end
+    return Row<T, 3>(m - n, d2, d3, this->elem + n * d2 * d3);
+  }
+
+  const Row<T, 3> slice(Index n, Index m) const
+  // the rows [n:sz)
+  {
+    if (n < 0)
+      n = 0;
+    if (d1 < m)
+      m = d1; // one beyond the end
+    return Row<T, 3>(m - n, d2, d3, this->elem + n * d2 * d3);
+  }
+
+  // Column<T,2> column(Index n); // not (yet) implemented: requies strides and
+  // operations on columns
+
+  // element-wise operations:
+  template <class F> Matrix &apply(F f) {
+    this->base_apply(f);
+    return *this;
+  }
+  template <class F> Matrix &apply(F f, const T &c) {
+    this->base_apply(f, c);
+    return *this;
+  }
+
+  Matrix &operator=(const T &c) {
+    this->base_apply(Assign<T>(), c);
+    return *this;
+  }
+
+  Matrix &operator*=(const T &c) {
+    this->base_apply(Mul_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator/=(const T &c) {
+    this->base_apply(Div_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator%=(const T &c) {
+    this->base_apply(Mod_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator+=(const T &c) {
+    this->base_apply(Add_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator-=(const T &c) {
+    this->base_apply(Minus_assign<T>(), c);
+    return *this;
+  }
+
+  Matrix &operator&=(const T &c) {
+    this->base_apply(And_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator|=(const T &c) {
+    this->base_apply(Or_assign<T>(), c);
+    return *this;
+  }
+  Matrix &operator^=(const T &c) {
+    this->base_apply(Xor_assign<T>(), c);
+    return *this;
+  }
+
+  Matrix operator!() { return xfer(Matrix(*this, Not<T>())); }
+  Matrix operator-() { return xfer(Matrix(*this, Unary_minus<T>())); }
+  Matrix operator~() { return xfer(Matrix(*this, Complement<T>())); }
+
+  template <class F> Matrix apply_new(F f) { return xfer(Matrix(*this, f)); }
+
+  void swap_rows(Index i, Index j)
+  // swap_rows() uses a row's worth of memory for better run-time performance
+  // if you want pairwise swap, just write it yourself
+  {
+    if (i == j)
+      return;
+
+    Matrix<T, 2> temp = (*this)[i];
+    (*this)[i] = (*this)[j];
+    (*this)[j] = temp;
+  }
+};
+
+//-----------------------------------------------------------------------------
+
+template <class T>
+Matrix<T> scale_and_add(const Matrix<T> &a, T c, const Matrix<T> &b)
+//  Fortran "saxpy()" ("fma" for "fused multiply-add").
+// will the copy constructor be called twice and defeat the xfer optimization?
+{
+  if (a.size() != b.size())
+    error("sizes wrong for scale_and_add()");
+  Matrix<T> res(a.size());
+  for (Index i = 0; i < a.size(); ++i)
+    res[i] += a[i] * c + b[i];
+  return res.xfer();
+}
+
+//-----------------------------------------------------------------------------
+
+template <class T> T dot_product(const Matrix<T> &a, const Matrix<T> &b) {
+  if (a.size() != b.size())
+    error("sizes wrong for dot product");
+  T sum = 0;
+  for (Index i = 0; i < a.size(); ++i)
+    sum += a[i] * b[i];
+  return sum;
+}
+
+//-----------------------------------------------------------------------------
+
+template <class T, int N> Matrix<T, N> xfer(Matrix<T, N> &a) {
+  return a.xfer();
+}
+
+//-----------------------------------------------------------------------------
+
+template <class F, class A> A apply(F f, A x) {
+  A res(x, f);
+  return xfer(res);
+}
+template <class F, class Arg, class A> A apply(F f, A x, Arg a) {
+  A res(x, f, a);
+  return xfer(res);
+}
+
+//-----------------------------------------------------------------------------
+
+// The default values for T and D have been declared before.
+template <class T, int D> class Row {
+  // general version exists only to allow specializations
+private:
+  Row();
+};
+
+//-----------------------------------------------------------------------------
+
+template <class T> class Row<T, 1> : public Matrix<T, 1> {
+public:
+  Row(Index n, T *p) : Matrix<T, 1>(n, p) {}
+
+  Matrix<T, 1> &operator=(const T &c) {
+    this->base_apply(Assign<T>(), c);
+    return *this;
+  }
+
+  Matrix<T, 1> &operator=(const Matrix<T, 1> &a) {
+    return *static_cast<Matrix<T, 1> *>(this) = a;
+  }
+};
+
+//-----------------------------------------------------------------------------
+
+template <class T> class Row<T, 2> : public Matrix<T, 2> {
+public:
+  Row(Index n1, Index n2, T *p) : Matrix<T, 2>(n1, n2, p) {}
+
+  Matrix<T, 2> &operator=(const T &c) {
+    this->base_apply(Assign<T>(), c);
+    return *this;
+  }
+
+  Matrix<T, 2> &operator=(const Matrix<T, 2> &a) {
+    return *static_cast<Matrix<T, 2> *>(this) = a;
+  }
+};
+
+//-----------------------------------------------------------------------------
+
+template <class T> class Row<T, 3> : public Matrix<T, 3> {
+public:
+  Row(Index n1, Index n2, Index n3, T *p) : Matrix<T, 3>(n1, n2, n3, p) {}
+
+  Matrix<T, 3> &operator=(const T &c) {
+    this->base_apply(Assign<T>(), c);
+    return *this;
+  }
+
+  Matrix<T, 3> &operator=(const Matrix<T, 3> &a) {
+    return *static_cast<Matrix<T, 3> *>(this) = a;
+  }
+};
+
+//-----------------------------------------------------------------------------
+
+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) {
+  Matrix<T> res(a.size());
+  if (a.size() != b.size())
+    error("sizes wrong for scale_and_add");
+  for (Index i = 0; i < a.size(); ++i)
+    res[i] += a[i] * c + b[i];
+  return res.xfer();
+}
+
+//-----------------------------------------------------------------------------
+
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+
+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;
+}
+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;
+}
+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;
+}
+
+//-----------------------------------------------------------------------------
+
+} // namespace Numeric_lib
+#endif
diff --git a/include/Numeric_lib/MatrixIO.hpp b/include/Numeric_lib/MatrixIO.hpp
new file mode 100644
index 0000000..8fe222d
--- /dev/null
+++ b/include/Numeric_lib/MatrixIO.hpp
@@ -0,0 +1,80 @@
+
+#include <Numeric_lib/Matrix.hpp>
+#include <iostream>
+
+namespace Numeric_lib {
+
+//-----------------------------------------------------------------------------
+
+template <class T>
+std::ostream &operator<<(std::ostream &os, const Matrix<T> &v) {
+  os << '{';
+
+  for (Index i = 0; i < v.dim1(); ++i) {
+    os << "  ";
+    os << v(i);
+  }
+
+  os << '}';
+  return os;
+}
+
+//-----------------------------------------------------------------------------
+
+template <class T>
+std::ostream &operator<<(std::ostream &os, const Matrix<T, 2> &m) {
+  os << "{\n";
+
+  for (Index i = 0; i < m.dim1(); ++i)
+    os << m[i] << '\n';
+
+  os << '}';
+  return os;
+}
+
+//-----------------------------------------------------------------------------
+
+template <class T> std::istream &operator>>(std::istream &is, Matrix<T> &v) {
+  char ch;
+  is >> ch;
+
+  if (ch != '{')
+    error("'{' missing in Matrix<T,1> input");
+
+  for (Index i = 0; i < v.dim1(); ++i)
+    is >> v(i);
+
+  is >> ch;
+
+  if (ch != '}')
+    error("'}' missing in Matrix<T,1> input");
+
+  return is;
+}
+
+//-----------------------------------------------------------------------------
+
+template <class T> std::istream &operator>>(std::istream &is, Matrix<T, 2> &m) {
+  char ch;
+  is >> ch;
+
+  if (ch != '{')
+    error("'{' missing in Matrix<T,2> input");
+
+  for (Index i = 0; i < m.dim1(); ++i) {
+    Matrix<T, 1> tmp(m.dim2());
+    is >> tmp;
+    m[i] = tmp;
+  }
+
+  is >> ch;
+
+  if (ch != '}')
+    error("'}' missing in Matrix<T,2> input");
+
+  return is;
+}
+
+//-----------------------------------------------------------------------------
+
+} // namespace Numeric_lib
diff --git a/include/Numeric_lib/MatrixIO11.hpp b/include/Numeric_lib/MatrixIO11.hpp
new file mode 100644
index 0000000..8fe222d
--- /dev/null
+++ b/include/Numeric_lib/MatrixIO11.hpp
@@ -0,0 +1,80 @@
+
+#include <Numeric_lib/Matrix.hpp>
+#include <iostream>
+
+namespace Numeric_lib {
+
+//-----------------------------------------------------------------------------
+
+template <class T>
+std::ostream &operator<<(std::ostream &os, const Matrix<T> &v) {
+  os << '{';
+
+  for (Index i = 0; i < v.dim1(); ++i) {
+    os << "  ";
+    os << v(i);
+  }
+
+  os << '}';
+  return os;
+}
+
+//-----------------------------------------------------------------------------
+
+template <class T>
+std::ostream &operator<<(std::ostream &os, const Matrix<T, 2> &m) {
+  os << "{\n";
+
+  for (Index i = 0; i < m.dim1(); ++i)
+    os << m[i] << '\n';
+
+  os << '}';
+  return os;
+}
+
+//-----------------------------------------------------------------------------
+
+template <class T> std::istream &operator>>(std::istream &is, Matrix<T> &v) {
+  char ch;
+  is >> ch;
+
+  if (ch != '{')
+    error("'{' missing in Matrix<T,1> input");
+
+  for (Index i = 0; i < v.dim1(); ++i)
+    is >> v(i);
+
+  is >> ch;
+
+  if (ch != '}')
+    error("'}' missing in Matrix<T,1> input");
+
+  return is;
+}
+
+//-----------------------------------------------------------------------------
+
+template <class T> std::istream &operator>>(std::istream &is, Matrix<T, 2> &m) {
+  char ch;
+  is >> ch;
+
+  if (ch != '{')
+    error("'{' missing in Matrix<T,2> input");
+
+  for (Index i = 0; i < m.dim1(); ++i) {
+    Matrix<T, 1> tmp(m.dim2());
+    is >> tmp;
+    m[i] = tmp;
+  }
+
+  is >> ch;
+
+  if (ch != '}')
+    error("'}' missing in Matrix<T,2> input");
+
+  return is;
+}
+
+//-----------------------------------------------------------------------------
+
+} // namespace Numeric_lib
diff --git a/include/std_lib_facilities.hpp b/include/std_lib_facilities.hpp
new file mode 100644
index 0000000..a119197
--- /dev/null
+++ b/include/std_lib_facilities.hpp
@@ -0,0 +1,220 @@
+/*
+   std_lib_facilities.hpp
+*/
+
+/*
+        simple "Programming: Principles and Practice using C++ (second edition)"
+   course header to be used for the first few weeks. It provides the most common
+   standard headers (in the global namespace) and minimal exception/error
+   support.
+
+        Students: please don't try to understand the details of headers just
+   yet. All will be explained. This header is primarily used so that you don't
+   have to understand every concept all at once.
+
+        By Chapter 10, you don't need this file and after Chapter 21, you'll
+   understand it
+
+        Revised April 25, 2010: simple_error() added
+
+        Revised November 25 2013: remove support for pre-C++11 compilers, use
+   C++11: <chrono> Revised November 28 2013: add a few container algorithms
+        Revised June 8 2014: added #ifndef to workaround Microsoft C++11
+   weakness
+*/
+
+#ifndef H112
+#define H112 251113L
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstdlib>
+#include <forward_list>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <list>
+#include <random>
+#include <regex>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+
+typedef long Unicode;
+
+//------------------------------------------------------------------------------
+
+using namespace std;
+
+template <class T> string to_string(const T &t) {
+  ostringstream os;
+  os << t;
+  return os.str();
+}
+
+struct Range_error : out_of_range { // enhanced vector range error reporting
+  int index;
+  Range_error(int i) : out_of_range("Range error: " + to_string(i)), index(i) {}
+};
+
+// trivially range-checked vector (no iterator checking):
+template <class T> struct Vector : public std::vector<T> {
+  using size_type = typename std::vector<T>::size_type;
+  using std::vector<T>::vector; // inheriting constructor
+  T &operator[](unsigned int i) // rather than return at(i);
+  {
+    if (i < 0 || this->size() <= i)
+      throw Range_error(i);
+    return std::vector<T>::operator[](i);
+  }
+  const T &operator[](unsigned int i) const {
+    if (i < 0 || this->size() <= i)
+      throw Range_error(i);
+    return std::vector<T>::operator[](i);
+  }
+};
+// disgusting macro hack to get a range checked vector:
+#define vector Vector
+
+// trivially range-checked string (no iterator checking):
+struct String : std::string {
+  using size_type = std::string::size_type;
+  //	using string::string;
+
+  char &operator[](unsigned int i) // rather than return at(i);
+  {
+    if (i < 0 || size() <= i)
+      throw Range_error(i);
+    return std::string::operator[](i);
+  }
+
+  const char &operator[](unsigned int i) const {
+    if (i < 0 || size() <= i)
+      throw Range_error(i);
+    return std::string::operator[](i);
+  }
+};
+
+namespace std {
+
+template <> struct hash<String> {
+  size_t operator()(const String &s) const { return hash<std::string>()(s); }
+};
+
+} // namespace std
+
+struct Exit : runtime_error {
+  Exit() : runtime_error("Exit") {}
+};
+
+// error() simply disguises throws:
+inline void error(const string &s) { throw runtime_error(s); }
+
+inline void error(const string &s, const string &s2) { error(s + s2); }
+
+inline void error(const string &s, int i) {
+  ostringstream os;
+  os << s << ": " << i;
+  error(os.str());
+}
+
+template <class T>
+char *as_bytes(T &i) // needed for binary I/O
+{
+  void *addr = &i;                  // get the address of the first byte
+                                    // of memory used to store the object
+  return static_cast<char *>(addr); // treat that memory as bytes
+}
+
+inline void keep_window_open() {
+  cin.clear();
+  cout << "Please enter a character to exit\n";
+  char ch;
+  cin >> ch;
+  return;
+}
+
+inline void keep_window_open(string s) {
+  if (s == "")
+    return;
+  cin.clear();
+  cin.ignore(120, '\n');
+  for (;;) {
+    cout << "Please enter " << s << " to exit\n";
+    string ss;
+    while (cin >> ss && ss != s)
+      cout << "Please enter " << s << " to exit\n";
+    return;
+  }
+}
+
+// error function to be used (only) until error() is introduced in Chapter 5:
+inline void simple_error(string s) // write ``error: s and exit program
+{
+  cerr << "error: " << s << '\n';
+  keep_window_open(); // for some Windows environments
+  std::exit(1);
+}
+
+// make std::min() and std::max() accessible on systems with antisocial macros:
+#undef min
+#undef max
+
+// run-time checked narrowing cast (type conversion). See ???.
+template <class R, class A> R narrow_cast(const A &a) {
+  R r = R(a);
+  if (A(r) != a)
+    error(string("info loss"));
+  return r;
+}
+
+// random number generators. See 24.7.
+
+inline int randint(int min, int max) {
+  static default_random_engine ran;
+  return uniform_int_distribution<>{min, max}(ran);
+}
+
+inline int randint(int max) { return randint(0, max); }
+
+// inline double sqrt(int x) { return sqrt(double(x)); }	// to match
+// C++0x
+
+// container algorithms. See 21.9.
+
+template <typename C> using Value_type = typename C::value_type;
+
+template <typename C> using Iterator = typename C::iterator;
+
+template <typename C>
+// requires Container<C>()
+void sort(C &c) {
+  std::sort(c.begin(), c.end());
+}
+
+template <typename C, typename Pred>
+// requires Container<C>() && Binary_Predicate<Value_type<C>>()
+void sort(C &c, Pred p) {
+  std::sort(c.begin(), c.end(), p);
+}
+
+template <typename C, typename Val>
+// requires Container<C>() && Equality_comparable<C,Val>()
+Iterator<C> find(C &c, Val v) {
+  return std::find(c.begin(), c.end(), v);
+}
+
+template <typename C, typename Pred>
+// requires Container<C>() && Predicate<Pred,Value_type<C>>()
+Iterator<C> find_if(C &c, Pred p) {
+  return std::find_if(c.begin(), c.end(), p);
+}
+
+#endif // H112
diff --git a/readme.md b/readme.md
new file mode 100644
index 0000000..665bc04
--- /dev/null
+++ b/readme.md
@@ -0,0 +1,369 @@
+# Programming Principles and Practice
+
+This repository contains an up-to-date version of the code that goes along with the book Programming, Principles and Practices by Bjarne Stroustrup.  When I was reading the book, I was surprised to find that the orignal code does not compile and contains many issues (see Appendix A).  I have also tried to make the setup for the code easier, by including standard configuration for the build process and dependency management.
+
+# Building
+
+This repository uses [my boilerplate for building C++ projects](https://github.com/wouterbeek/cpp-boilerplate). You can read the detailed instructions in that repository, or run the following TLDR-summary:
+
+  - `${buildType}` is `Debug` or `Release`.
+  - `${presetName}` is `linux-debug` or `linux-release` or `windows-debug` or `windows-release`.
+
+```sh
+conan install . -b missing -of build -s build_type=${buildType}
+cmake --preset ${presetName}
+cmake --build --preset ${presetName}
+./build/${presetName}/main
+```
+
+Notice that the forward slashes (Linux) should be backward slashes on Windows.
+
+# Fixes
+
+This section documents the fixes that were applied relative to the original code.
+
+## Fix 1 - Case-sensitivity of file names
+
+The original Git repository cannot be cloned on Windows, because the filesystem there does not distinguish between the files 'GUI.h' and 'Gui.h':
+
+```
+Cloning into 'Programming-_Principles_and_Practice_Using_Cpp'...
+remote: Enumerating objects: 2357, done.
+remote: Total 2357 (delta 0), reused 0 (delta 0), pack-reused 2357 (from 1)
+Receiving objects: 100% (2357/2357), 22.75 MiB | 8.69 MiB/s, done.
+Resolving deltas: 100% (1088/1088), done.
+warning: the following paths have collided (e.g. case-sensitive paths
+on a case-insensitive filesystem) and only one from the same
+colliding group is in the working tree:
+
+  'GUI.h'
+  'Gui.h'
+```
+
+## Fix 2 - Duplicate implementations
+
+The original Git repository could not compile, because some methods had duplicate declarations and/or duplicate definitions (e.g. both in the '*.h' and in the '*.cpp' file).  These duplicates were removed.
+
+## Fix 3 - Missing imports
+
+The original Git repository could not compile, because some imports were missing.  These missing imports were added.
+
+## Fix 4 - Reliance on implicit conversions
+
+The original Git repository could not compile, because it relied on implicit conversions, some of which had been removed from the C++ language.  An example is a return of std::ifstream, which used to return void* which implicitly casts to bool.
+
+# Changes
+
+This section documents the changes that were applied replative to the original code.
+
+## Change 1 - Added chapter 12 examples
+
+The running text of Chapter 12 of the PPP book includes a lot of examples that use `Simple_window` and `Graph`.  These examples were added in the executable 'main.exe'.
+
+## Change 2 - Added build system and dependency management
+
+The original Git repository did not detail how the code was built, or how the FLTK-dependency was pulled in and configured.  This repository automates these things with CMake and Conan.
+
+## Change 3 - Only include headers that are needed
+
+The original Git repository used to include a lot of header files pro-actively (e.g. fltk.h).  This included a lot of header files that were not specifically used for particular compilation units.  This repository only imports headers that are specifically needed for compiling any compilation unit.
+
+## Change 4 - Include and source directories
+
+The original Git repository used to store all files in a flat directory.  This repository places headers in an 'include'-directory, library source files in a 'src'-directory, and executable source files in a 'tool'-directory.
+
+## Change 5 - Assume a modern build environment
+
+The original Git repository included workarounds for known limitations that existed in 2014.  This repository assumes that you are using a more modern build environment.  For example, the following workarounds were removed:
+
+  - A workaround for MSVC-versions that do not support C++11.
+  - A workaround for glibc libraries prior to 2.28 (2018).
+
+# Appendices
+
+## Appendix A: Compiler output of the original code
+
+This appendix includes the original compiler output (MSVC) when trying to build the original code.  Notice that there are many errors and warnings.
+
+```sh
+$ cmake --build --preset windows-debug
+[6/10] Building CXX object CMakeFiles\ppp.dir\Graph.cpp.obj
+FAILED: [code=2] CMakeFiles/ppp.dir/Graph.cpp.obj
+C:\PROGRA~1\MIB055~1\18\COMMUN~1\VC\Tools\MSVC\1451~1.362\bin\Hostx86\x64\cl.exe  /nologo /TP -DLIBJPEG_STATIC -DXML_STATIC -D_MBCS -IC:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp -external:IC:\Users\WouterBeek\.conan2\p\b\fltk69eccc2d4492e\p\include -external:W0 /DWIN32 /D_WINDOWS /EHsc /Ob0 /Od -std:c++latest -MDd -RTC1 -Zi /showIncludes @CMakeFiles\ppp.dir\Graph.cpp.obj.modmap /FoCMakeFiles\ppp.dir\Graph.cpp.obj /FdCMakeFiles\ppp.dir\ppp.pdb /FS -c C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(89): error C7568: argument list missing after assumed function template 'vector'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(89): note: the template instantiation context (the oldest one first) is
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(88): note: while compiling class template 'Graph_lib::Vector_ref'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(90): error C7568: argument list missing after assumed function template 'vector'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(119): error C7568: argument list missing after assumed function template 'initializer_list'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(158): error C7568: argument list missing after assumed function template 'vector'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(159): error C2398: Element '1': conversion from 'Fl_Color' to 'int' requires a narrowing conversion
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(192): error C3861: 'error': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(197): error C3861: 'error': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(238): error C7568: argument list missing after assumed function template 'initializer_list'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(238): error C2280: 'Graph_lib::Shape::Shape(const Graph_lib::Shape &)': attempting to reference a deleted function
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(155): note: see declaration of 'Graph_lib::Shape::Shape'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(155): note: 'Graph_lib::Shape::Shape(const Graph_lib::Shape &)': function was explicitly deleted
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(238): error C3861: 'error': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(245): error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(245): error C2143: syntax error: missing ',' before '&'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(249): error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(249): error C2143: syntax error: missing ',' before '&'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(250): error C3646: 'label': unknown override specifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(250): error C2059: syntax error: '('
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(250): error C2334: unexpected token(s) preceding '{'; skipping apparent function body
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(258): error C3646: 'lab': unknown override specifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(258): error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(245): error C2065: 's': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(245): error C2614: 'Graph_lib::Text': illegal member initialization: 'lab' is not a base or member
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(249): error C2065: 'lab': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(249): error C2065: 's': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(267): error C2061: syntax error: identifier 'string'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(326): error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(326): error C2143: syntax error: missing ',' before '&'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(329): error C3646: 'mark': unknown override specifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(329): error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(326): error C2065: 'm': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(326): error C2614: 'Graph_lib::Marked_polyline': illegal member initialization: 'mark' is not a base or member
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(333): error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(333): error C2143: syntax error: missing ',' before '&'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(333): error C2065: 'm': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(338): error C3861: 'string': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(338): error C2280: 'Graph_lib::Marks::Marks(const Graph_lib::Marks &)': attempting to reference a deleted function
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(335): note: compiler has generated 'Graph_lib::Marks::Marks' here
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(335): note: 'Graph_lib::Marks::Marks(const Graph_lib::Marks &)': function was implicitly deleted because a base class invokes a deleted or inaccessible function 'Graph_lib::Marked_polyline::Marked_polyline(const Graph_lib::Marked_polyline &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(330): note: 'Graph_lib::Marked_polyline::Marked_polyline(const Graph_lib::Marked_polyline &)': function was implicitly deleted because a base class invokes a deleted or inaccessible function 'Graph_lib::Open_polyline::Open_polyline(const Graph_lib::Open_polyline &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(220): note: 'Graph_lib::Open_polyline::Open_polyline(const Graph_lib::Open_polyline &)': function was implicitly deleted because a base class invokes a deleted or inaccessible function 'Graph_lib::Shape::Shape(const Graph_lib::Shape &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(155): note: 'Graph_lib::Shape::Shape(const Graph_lib::Shape &)': function was explicitly deleted
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(361): error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(361): error C2143: syntax error: missing ',' before '&'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(364): error C2061: syntax error: identifier 'string'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(10): error C2661: 'fl_line': no overloaded function takes 1 arguments
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(10): note: while trying to match the argument list '()'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(27): error C7568: argument list missing after assumed function template 'pair'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(27): error C2062: type '<error>' unexpected
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(28): error C2143: syntax error: missing ';' before '{'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(28): error C2447: '{': missing function header (old-style formal list?)
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(54): error C7568: argument list missing after assumed function template 'pair'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(54): error C3861: 'line_intersect': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(66): error C3861: 'error': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(68): error C3861: 'line_intersect': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(70): error C3861: 'error': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(76): error C3861: 'error': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(86): error C3861: 'error': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(135): error C2065: 'lab': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(143): error C3861: 'error': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(144): error C3861: 'error': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(168): error C2061: syntax error: identifier 'string'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(169): error C2065: 'lab': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(171): error C3861: 'error': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(204): error C3861: 'error': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(263): error C2065: 'string': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(263): error C2146: syntax error: missing ';' before identifier 'm'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(263): error C3861: 'm': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(264): error C2065: 'm': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(271): error C2065: 'mark': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(271): error C2065: 'mark': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(271): error C2660: 'Graph_lib::draw_mark': function does not take 1 arguments
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(259): note: see declaration of 'Graph_lib::draw_mark'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(271): note: while trying to match the argument list '(Graph_lib::Point)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): error C2065: 'string': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): error C2923: 'std::map': 'string' is not a valid template type argument for parameter '_Kty'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: see declaration of 'string'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): error C2976: 'std::map': too few template arguments
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(72): note: see declaration of 'std::map'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): error C2641: cannot deduce template arguments for 'std::map'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map': no matching overloaded function found
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(374): note: could be 'std::map<remove_const<tuple_element<0,iterator_traits<_Ty>::value_type>::type>::type,tuple_element<1,iterator_traits<_Ty>::value_type>::type,_Pr,_Alloc> std::map(_Iter,_Iter,_Pr,_Alloc)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<remove_const<tuple_element<0,iterator_traits<_Ty>::value_type>::type>::type,tuple_element<1,iterator_traits<_Ty>::value_type>::type,_Pr,_Alloc> std::map(_Iter,_Iter,_Pr,_Alloc)': expects 4 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(378): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::initializer_list<std::pair<_Ty1,_Ty2>>,_Pr,_Alloc)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::initializer_list<std::pair<_Ty1,_Ty2>>,_Pr,_Alloc)': expects 3 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(381): note: or       'std::map<remove_const<tuple_element<0,iterator_traits<_Ty>::value_type>::type>::type,tuple_element<1,iterator_traits<_Ty>::value_type>::type,std::less<remove_const<tuple_element<0,iterator_traits<_Ty>::value_type>::type>::type>,_Alloc> std::map(_Iter,_Iter,_Alloc)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<remove_const<tuple_element<0,iterator_traits<_Ty>::value_type>::type>::type,tuple_element<1,iterator_traits<_Ty>::value_type>::type,std::less<remove_const<tuple_element<0,iterator_traits<_Ty>::value_type>::type>::type>,_Alloc> std::map(_Iter,_Iter,_Alloc)': expects 3 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(384): note: or       'std::map<_Kty,_Ty,std::less<_Ty>,_Alloc> std::map(std::initializer_list<std::pair<_Ty1,_Ty2>>,_Alloc)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,std::less<_Ty>,_Alloc> std::map(std::initializer_list<std::pair<_Ty1,_Ty2>>,_Alloc)': expects 2 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(389): note: or       'std::map<remove_const<::std::ranges::range_value_t<_Rng>::first_type>::type,::std::ranges::range_value_t<_Rng>::second_type,_Pr,_Alloc> std::map(std::from_range_t,_Rng &&,_Pr,_Alloc)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<remove_const<::std::ranges::range_value_t<_Rng>::first_type>::type,::std::ranges::range_value_t<_Rng>::second_type,_Pr,_Alloc> std::map(std::from_range_t,_Rng &&,_Pr,_Alloc)': expects 4 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(393): note: or       'std::map<remove_const<::std::ranges::range_value_t<_Rng>::first_type>::type,::std::ranges::range_value_t<_Rng>::second_type,std::less<remove_const<::std::ranges::range_value_t<_Rng>::first_type>::type>,_Alloc> std::map(std::from_range_t,_Rng &&,_Alloc)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<remove_const<::std::ranges::range_value_t<_Rng>::first_type>::type,::std::ranges::range_value_t<_Rng>::second_type,std::less<remove_const<::std::ranges::range_value_t<_Rng>::first_type>::type>,_Alloc> std::map(std::from_range_t,_Rng &&,_Alloc)': expects 3 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(334): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::initializer_list<std::pair<const _Kty,_Ty>>,const _Pr &,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::initializer_list<std::pair<const _Kty,_Ty>>,const _Pr &,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)': expects 3 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(330): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::initializer_list<std::pair<const _Kty,_Ty>>,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::initializer_list<std::pair<const _Kty,_Ty>>,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)': expects 2 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(326): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::initializer_list<std::pair<const _Kty,_Ty>>,const _Pr &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::initializer_list<std::pair<const _Kty,_Ty>>,const _Pr &)': expects 2 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(322): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::initializer_list<std::pair<const _Kty,_Ty>>)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::initializer_list<std::pair<const _Kty,_Ty>>)': expects 1 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(167): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::map<_Kty,_Ty,_Pr,_Alloc> &&,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::map<_Kty,_Ty,_Pr,_Alloc> &&,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)': expects 2 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(165): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::map<_Kty,_Ty,_Pr,_Alloc> &&)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::map<_Kty,_Ty,_Pr,_Alloc> &&)': expects 1 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(155): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::from_range_t,_Rng &&,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::from_range_t,_Rng &&,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)': expects 3 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(150): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::from_range_t,_Rng &&,const _Pr &,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::from_range_t,_Rng &&,const _Pr &,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)': expects 4 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(145): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::from_range_t,_Rng &&,const _Pr &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::from_range_t,_Rng &&,const _Pr &)': expects 3 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(140): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::from_range_t,_Rng &&)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::from_range_t,_Rng &&)': expects 2 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(134): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(_Iter,_Iter,const _Pr &,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(_Iter,_Iter,const _Pr &,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)': expects 4 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(129): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(_Iter,_Iter,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(_Iter,_Iter,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)': expects 3 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(124): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(_Iter,_Iter,const _Pr &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(_Iter,_Iter,const _Pr &)': expects 3 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(119): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(_Iter,_Iter)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(_Iter,_Iter)': expects 2 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(116): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(const _Pr &,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(const _Pr &,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)': expects 2 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(114): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(const _Pr &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(const _Pr &)': expects 1 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(112): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(const std::map<_Kty,_Ty,_Pr,_Alloc> &,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(const std::map<_Kty,_Ty,_Pr,_Alloc> &,const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)': expects 2 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(110): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(const std::map<_Kty,_Ty,_Pr,_Alloc> &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(const std::map<_Kty,_Ty,_Pr,_Alloc> &)': expects 1 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(108): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(const _Tree<std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,false>>::allocator_type &)': expects 1 arguments - 0 provided
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(106): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(void)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(void)': could not deduce template argument for '_Kty'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(void)': could not deduce template argument for '_Ty'
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(72): note: or       'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::map<_Kty,_Ty,_Pr,_Alloc>)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(282): note: 'std::map<_Kty,_Ty,_Pr,_Alloc> std::map(std::map<_Kty,_Ty,_Pr,_Alloc>)': expects 1 arguments - 0 provided
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(286): error C2678: binary '[': no operator found which takes a left-hand operand of type 'std::map' (or there is no acceptable conversion)
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(345): note: could be '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](const _Kty &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(286): note: '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](const _Kty &)': cannot convert 'this' pointer from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc> &'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(286): note: Reason: cannot convert from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc>'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(286): note: Conversion requires a second user-defined-conversion operator or constructor
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(174): note: or       '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](_Kty &&)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(286): note: '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](_Kty &&)': cannot convert 'this' pointer from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc> &'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(286): note: Reason: cannot convert from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc>'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(286): note: Conversion requires a second user-defined-conversion operator or constructor
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(286): note: while trying to match the argument list '(std::map, const char [4])'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(287): error C2678: binary '[': no operator found which takes a left-hand operand of type 'std::map' (or there is no acceptable conversion)
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(345): note: could be '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](const _Kty &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(287): note: '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](const _Kty &)': cannot convert 'this' pointer from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc> &'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(287): note: Reason: cannot convert from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc>'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(287): note: Conversion requires a second user-defined-conversion operator or constructor
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(174): note: or       '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](_Kty &&)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(287): note: '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](_Kty &&)': cannot convert 'this' pointer from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc> &'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(287): note: Reason: cannot convert from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc>'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(287): note: Conversion requires a second user-defined-conversion operator or constructor
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(287): note: while trying to match the argument list '(std::map, const char [4])'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(288): error C2678: binary '[': no operator found which takes a left-hand operand of type 'std::map' (or there is no acceptable conversion)
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(345): note: could be '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](const _Kty &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(288): note: '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](const _Kty &)': cannot convert 'this' pointer from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc> &'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(288): note: Reason: cannot convert from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc>'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(288): note: Conversion requires a second user-defined-conversion operator or constructor
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(174): note: or       '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](_Kty &&)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(288): note: '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](_Kty &&)': cannot convert 'this' pointer from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc> &'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(288): note: Reason: cannot convert from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc>'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(288): note: Conversion requires a second user-defined-conversion operator or constructor
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(288): note: while trying to match the argument list '(std::map, const char [5])'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(289): error C2678: binary '[': no operator found which takes a left-hand operand of type 'std::map' (or there is no acceptable conversion)
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(345): note: could be '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](const _Kty &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(289): note: '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](const _Kty &)': cannot convert 'this' pointer from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc> &'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(289): note: Reason: cannot convert from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc>'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(289): note: Conversion requires a second user-defined-conversion operator or constructor
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(174): note: or       '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](_Kty &&)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(289): note: '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](_Kty &&)': cannot convert 'this' pointer from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc> &'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(289): note: Reason: cannot convert from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc>'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(289): note: Conversion requires a second user-defined-conversion operator or constructor
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(289): note: while trying to match the argument list '(std::map, const char [5])'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(290): error C2678: binary '[': no operator found which takes a left-hand operand of type 'std::map' (or there is no acceptable conversion)
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(345): note: could be '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](const _Kty &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(290): note: '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](const _Kty &)': cannot convert 'this' pointer from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc> &'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(290): note: Reason: cannot convert from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc>'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(290): note: Conversion requires a second user-defined-conversion operator or constructor
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(174): note: or       '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](_Kty &&)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(290): note: '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](_Kty &&)': cannot convert 'this' pointer from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc> &'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(290): note: Reason: cannot convert from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc>'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(290): note: Conversion requires a second user-defined-conversion operator or constructor
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(290): note: while trying to match the argument list '(std::map, const char [4])'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(291): error C2678: binary '[': no operator found which takes a left-hand operand of type 'std::map' (or there is no acceptable conversion)
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(345): note: could be '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](const _Kty &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(291): note: '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](const _Kty &)': cannot convert 'this' pointer from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc> &'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(291): note: Reason: cannot convert from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc>'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(291): note: Conversion requires a second user-defined-conversion operator or constructor
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(174): note: or       '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](_Kty &&)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(291): note: '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](_Kty &&)': cannot convert 'this' pointer from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc> &'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(291): note: Reason: cannot convert from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc>'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(291): note: Conversion requires a second user-defined-conversion operator or constructor
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(291): note: while trying to match the argument list '(std::map, const char [4])'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(292): error C2678: binary '[': no operator found which takes a left-hand operand of type 'std::map' (or there is no acceptable conversion)
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(345): note: could be '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](const _Kty &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(292): note: '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](const _Kty &)': cannot convert 'this' pointer from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc> &'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(292): note: Reason: cannot convert from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc>'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(292): note: Conversion requires a second user-defined-conversion operator or constructor
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(174): note: or       '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](_Kty &&)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(292): note: '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](_Kty &&)': cannot convert 'this' pointer from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc> &'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(292): note: Reason: cannot convert from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc>'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(292): note: Conversion requires a second user-defined-conversion operator or constructor
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(292): note: while trying to match the argument list '(std::map, const char [4])'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(293): error C2678: binary '[': no operator found which takes a left-hand operand of type 'std::map' (or there is no acceptable conversion)
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(345): note: could be '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](const _Kty &)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(293): note: '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](const _Kty &)': cannot convert 'this' pointer from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc> &'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(293): note: Reason: cannot convert from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc>'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(293): note: Conversion requires a second user-defined-conversion operator or constructor
+C:\Program Files\Microsoft Visual Studio\18\Community\VC\Tools\MSVC\14.51.36231\include\map(174): note: or       '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](_Kty &&)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(293): note: '_Ty &std::map<_Kty,_Ty,_Pr,_Alloc>::operator [](_Kty &&)': cannot convert 'this' pointer from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc> &'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(293): note: Reason: cannot convert from 'std::map' to 'std::map<_Kty,_Ty,_Pr,_Alloc>'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(293): note: Conversion requires a second user-defined-conversion operator or constructor
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(293): note: while trying to match the argument list '(std::map, const char [4])'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(297): error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(297): error C2143: syntax error: missing ',' before '&'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(302): error C2653: 'string': is not a class or namespace name
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(302): error C2065: 'const_iterator': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(302): error C2146: syntax error: missing ';' before identifier 'p'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(302): error C2065: 'p': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(302): error C2065: 's': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(302): error C2065: 's': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(302): error C3861: 'find': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(303): error C2065: 'p': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(303): error C2065: 's': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(305): error C2146: syntax error: missing ';' before identifier 'suf'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(305): error C2065: 'p': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(305): error C2065: 's': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(305): error C3861: 'suf': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(306): error C2065: 'suf': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(309): error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(309): error C2143: syntax error: missing ',' before '&'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(312): error C2065: 'ifstream': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(312): error C2146: syntax error: missing ';' before identifier 'ff'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(312): error C2065: 's': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(312): error C3861: 'ff': identifier not found
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(313): error C2065: 'ff': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(319): error C2061: syntax error: identifier 'string'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(320): error C2665: 'Graph_lib::Text::Text': no overloaded function could convert all the argument types
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(245): note: could be 'Graph_lib::Text::Text(Graph_lib::Point,const int)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(320): note: 'Graph_lib::Text::Text(Graph_lib::Point,const int)': cannot convert argument 2 from 'const char [1]' to 'const int'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(320): note: There is no context in which this conversion is possible
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(320): note: while trying to match the argument list '(Graph_lib::Point, const char [1])'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(324): error C2065: 's': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(325): error C2065: 's': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(330): error C2065: 'e': undeclared identifier
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.cpp(330): fatal error C1003: error count exceeds 100; stopping compilation
+[7/10] Building CXX object CMakeFiles\ppp.dir\Simple_window.cpp.obj
+FAILED: [code=2] CMakeFiles/ppp.dir/Simple_window.cpp.obj
+C:\PROGRA~1\MIB055~1\18\COMMUN~1\VC\Tools\MSVC\1451~1.362\bin\Hostx86\x64\cl.exe  /nologo /TP -DLIBJPEG_STATIC -DXML_STATIC -D_MBCS -IC:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp -external:IC:\Users\WouterBeek\.conan2\p\b\fltk69eccc2d4492e\p\include -external:W0 /DWIN32 /D_WINDOWS /EHsc /Ob0 /Od -std:c++latest -MDd -RTC1 -Zi /showIncludes @CMakeFiles\ppp.dir\Simple_window.cpp.obj.modmap /FoCMakeFiles\ppp.dir\Simple_window.cpp.obj /FdCMakeFiles\ppp.dir\ppp.pdb /FS -c C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Simple_window.cpp
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(159): error C2398: Element '1': conversion from 'Fl_Color' to 'int' requires a narrowing conversion
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Simple_window.cpp(11): error C2084: function 'Simple_window::Simple_window(Graph_lib::Point,int,int,const std::string &)' already has a body
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Simple_window.h(10): note: see previous definition of 'Simple_window::Simple_window'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Simple_window.cpp(21): error C2556: 'bool Simple_window::wait_for_button(void)': overloaded function differs only by return type from 'void Simple_window::wait_for_button(void)'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Simple_window.h(15): note: see declaration of 'Simple_window::wait_for_button'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Simple_window.cpp(21): error C2371: 'Simple_window::wait_for_button': redefinition; different basic types
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Simple_window.h(15): note: see declaration of 'Simple_window::wait_for_button'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Simple_window.cpp(21): error C2084: function 'void Simple_window::wait_for_button(void)' already has a body
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Simple_window.h(15): note: see previous definition of 'Simple_window::wait_for_button'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Simple_window.cpp(42): error C2084: function 'void Simple_window::cb_next(Graph_lib::Address,Graph_lib::Address)' already has a body
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Simple_window.h(29): note: see previous definition of 'Simple_window::cb_next'
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Simple_window.cpp(50): error C2084: function 'void Simple_window::next(void)' already has a body
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Simple_window.h(35): note: see previous definition of 'Simple_window::next'
+[8/10] Building CXX object CMakeFiles\ppp.dir\Window.cpp.obj
+FAILED: [code=2] CMakeFiles/ppp.dir/Window.cpp.obj
+C:\PROGRA~1\MIB055~1\18\COMMUN~1\VC\Tools\MSVC\1451~1.362\bin\Hostx86\x64\cl.exe  /nologo /TP -DLIBJPEG_STATIC -DXML_STATIC -D_MBCS -IC:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp -external:IC:\Users\WouterBeek\.conan2\p\b\fltk69eccc2d4492e\p\include -external:W0 /DWIN32 /D_WINDOWS /EHsc /Ob0 /Od -std:c++latest -MDd -RTC1 -Zi /showIncludes @CMakeFiles\ppp.dir\Window.cpp.obj.modmap /FoCMakeFiles\ppp.dir\Window.cpp.obj /FdCMakeFiles\ppp.dir\ppp.pdb /FS -c C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Window.cpp
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(159): error C2398: Element '1': conversion from 'Fl_Color' to 'int' requires a narrowing conversion
+[9/10] Building CXX object CMakeFiles\ppp.dir\GUI.cpp.obj
+FAILED: [code=2] CMakeFiles/ppp.dir/GUI.cpp.obj
+C:\PROGRA~1\MIB055~1\18\COMMUN~1\VC\Tools\MSVC\1451~1.362\bin\Hostx86\x64\cl.exe  /nologo /TP -DLIBJPEG_STATIC -DXML_STATIC -D_MBCS -IC:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp -external:IC:\Users\WouterBeek\.conan2\p\b\fltk69eccc2d4492e\p\include -external:W0 /DWIN32 /D_WINDOWS /EHsc /Ob0 /Od -std:c++latest -MDd -RTC1 -Zi /showIncludes @CMakeFiles\ppp.dir\GUI.cpp.obj.modmap /FoCMakeFiles\ppp.dir\GUI.cpp.obj /FdCMakeFiles\ppp.dir\ppp.pdb /FS -c C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\GUI.cpp
+C:\Users\WouterBeek\source\repos\Programming-_Principles_and_Practice_Using_Cpp\Graph.h(159): error C2398: Element '1': conversion from 'Fl_Color' to 'int' requires a narrowing conversion
+ninja: build stopped: subcommand failed.
+```
diff --git a/src/Graph_lib/GUI.cpp b/src/Graph_lib/GUI.cpp
new file mode 100644
index 0000000..73dc88c
--- /dev/null
+++ b/src/Graph_lib/GUI.cpp
@@ -0,0 +1,69 @@
+#include <Graph_lib/GUI.hpp>
+#include <sstream>
+#include <std_lib_facilities.hpp>
+
+using namespace Graph_lib;
+
+void Button::attach(Window &win) {
+  pw = new Fl_Button(loc.x, loc.y, width, height, label.c_str());
+  pw->callback(reinterpret_cast<Fl_Callback *>(do_it), &win); // pass the window
+  own = &win;
+}
+
+int In_box::get_int() {
+  Fl_Input &pi = reference_to<Fl_Input>(pw);
+  //	return atoi(pi.value());
+  const char *p = pi.value();
+  if (!isdigit(p[0]))
+    return -999999;
+  return atoi(p);
+}
+
+string In_box::get_string() {
+  Fl_Input &pi = reference_to<Fl_Input>(pw);
+  return string(pi.value());
+}
+
+void In_box::attach(Window &win) {
+  pw = new Fl_Input(loc.x, loc.y, width, height, label.c_str());
+  own = &win;
+}
+
+void Out_box::put(int i) {
+  Fl_Output &po = reference_to<Fl_Output>(pw);
+  std::stringstream ss;
+  ss << i;
+  po.value(ss.str().c_str());
+}
+
+void Out_box::put(const string &s) {
+  reference_to<Fl_Output>(pw).value(s.c_str());
+}
+
+void Out_box::attach(Window &win) {
+  pw = new Fl_Output(loc.x, loc.y, width, height, label.c_str());
+  own = &win;
+}
+
+int Menu::attach(Button &b) {
+  b.width = width;
+  b.height = height;
+
+  switch (k) {
+  case horizontal:
+    b.loc = Point(loc.x + offset, loc.y);
+    offset += b.width;
+    break;
+  case vertical:
+    b.loc = Point(loc.x, loc.y + offset);
+    offset += b.height;
+    break;
+  }
+  selection.push_back(&b);
+  return int(selection.size() - 1);
+}
+
+int Menu::attach(Button *p) {
+  //	owned.push_back(p);
+  return attach(*p);
+}
\ No newline at end of file
diff --git a/src/Graph_lib/Graph.cpp b/src/Graph_lib/Graph.cpp
new file mode 100644
index 0000000..b269ef2
--- /dev/null
+++ b/src/Graph_lib/Graph.cpp
@@ -0,0 +1,342 @@
+#include <Graph_lib/Graph.hpp>
+#include <map>
+
+namespace Graph_lib {
+
+void Shape::draw_lines() const {
+  if (color().visibility() && 1 < points.size()) // draw sole pixel?
+    for (unsigned int i = 1; i < points.size(); ++i)
+      fl_line(points[i - 1].x, points[i - 1].y, points[i].x, points[i].y);
+}
+
+void Shape::draw() const {
+  Fl_Color oldc = fl_color();
+  // there is no good portable way of retrieving the current style
+  fl_color(lcolor.as_int());
+  fl_line_style(ls.style(), ls.width());
+  draw_lines();
+  fl_color(oldc); // reset color (to pevious) and style (to default)
+  fl_line_style(0);
+}
+
+// does two lines (p1,p2) and (p3,p4) intersect?
+// if se return the distance of the intersect point as distances from p1
+inline pair<double, double> line_intersect(Point p1, Point p2, Point p3,
+                                           Point p4, bool &parallel) {
+  double x1 = p1.x;
+  double x2 = p2.x;
+  double x3 = p3.x;
+  double x4 = p4.x;
+  double y1 = p1.y;
+  double y2 = p2.y;
+  double y3 = p3.y;
+  double y4 = p4.y;
+
+  double denom = ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1));
+  if (denom == 0) {
+    parallel = true;
+    return pair<double, double>(0, 0);
+  }
+  parallel = false;
+  return pair<double, double>(
+      ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denom,
+      ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / denom);
+}
+
+// intersection between two line segments
+// Returns true if the two segments intersect,
+// in which case intersection is set to the point of intersection
+bool line_segment_intersect(Point p1, Point p2, Point p3, Point p4,
+                            Point &intersection) {
+  bool parallel;
+  pair<double, double> u = line_intersect(p1, p2, p3, p4, parallel);
+  if (parallel || u.first < 0 || u.first > 1 || u.second < 0 || u.second > 1)
+    return false;
+  intersection.x = p1.x + u.first * (p2.x - p1.x);
+  intersection.y = p1.y + u.first * (p2.y - p1.y);
+  return true;
+}
+
+void Polygon::add(Point p) {
+  int np = number_of_points();
+
+  if (1 < np) { // check that thenew line isn't parallel to the previous one
+    if (p == point(np - 1))
+      error("polygon point equal to previous point");
+    bool parallel;
+    line_intersect(point(np - 1), p, point(np - 2), point(np - 1), parallel);
+    if (parallel)
+      error("two polygon points lie in a straight line");
+  }
+
+  for (int i = 1; i < np - 1;
+       ++i) { // check that new segment doesn't interset and old point
+    Point ignore(0, 0);
+    if (line_segment_intersect(point(np - 1), p, point(i - 1), point(i),
+                               ignore))
+      error("intersect in polygon");
+  }
+
+  Closed_polyline::add(p);
+}
+
+void Polygon::draw_lines() const {
+  if (number_of_points() < 3)
+    error("less than 3 points in a Polygon");
+  Closed_polyline::draw_lines();
+}
+
+void Open_polyline::draw_lines() const {
+  if (fill_color().visibility()) {
+    fl_color(fill_color().as_int());
+    fl_begin_complex_polygon();
+    for (int i = 0; i < number_of_points(); ++i) {
+      fl_vertex(point(i).x, point(i).y);
+    }
+    fl_end_complex_polygon();
+    fl_color(color().as_int()); // reset color
+  }
+
+  if (color().visibility())
+    Shape::draw_lines();
+}
+
+void Closed_polyline::draw_lines() const {
+  Open_polyline::draw_lines();
+
+  if (color().visibility()) // draw closing line:
+    fl_line(point(number_of_points() - 1).x, point(number_of_points() - 1).y,
+            point(0).x, point(0).y);
+}
+void Shape::move(int dx, int dy) {
+  for (unsigned int i = 0; i < points.size(); ++i) {
+    points[i].x += dx;
+    points[i].y += dy;
+  }
+}
+
+void Lines::draw_lines() const {
+  //	if (number_of_points()%2==1) error("odd number of points in set of
+  //lines");
+  if (color().visibility())
+    for (int i = 1; i < number_of_points(); i += 2)
+      fl_line(point(i - 1).x, point(i - 1).y, point(i).x, point(i).y);
+}
+
+void Text::draw_lines() const {
+  int ofnt = fl_font();
+  int osz = fl_size();
+  fl_font(fnt.as_int(), fnt_sz);
+  fl_draw(lab.c_str(), point(0).x, point(0).y);
+  fl_font(ofnt, osz);
+}
+
+Function::Function(Fct f, double r1, double r2, Point xy, int count,
+                   double xscale, double yscale)
+// graph f(x) for x in [r1:r2) using count line segments with (0,0) displayed at
+// xy x coordinates are scaled by xscale and y coordinates scaled by yscale
+{
+  if (r2 - r1 <= 0)
+    error("bad graphing range");
+  if (count <= 0)
+    error("non-positive graphing count");
+  double dist = (r2 - r1) / count;
+  double r = r1;
+  for (int i = 0; i < count; ++i) {
+    add(Point(xy.x + int(r * xscale), xy.y - int(f(r) * yscale)));
+    r += dist;
+  }
+}
+
+void Rectangle::draw_lines() const {
+  if (fill_color().visibility()) { // fill
+    fl_color(fill_color().as_int());
+    fl_rectf(point(0).x, point(0).y, w, h);
+    fl_color(color().as_int()); // reset color
+  }
+
+  if (color().visibility()) { // edge on top of fill
+    fl_color(color().as_int());
+    fl_rect(point(0).x, point(0).y, w, h);
+  }
+}
+
+Axis::Axis(Orientation d, Point xy, int length, int n, string lab)
+    : label(Point(0, 0), lab) {
+  if (length < 0)
+    error("bad axis length");
+  switch (d) {
+  case Axis::x: {
+    Shape::add(xy);                         // axis line
+    Shape::add(Point(xy.x + length, xy.y)); // axis line
+    if (1 < n) {
+      int dist = length / n;
+      int x = xy.x + dist;
+      for (int i = 0; i < n; ++i) {
+        notches.add(Point(x, xy.y), Point(x, xy.y - 5));
+        x += dist;
+      }
+    }
+    // label under the line
+    label.move(length / 3, xy.y + 20);
+    break;
+  }
+  case Axis::y: {
+    Shape::add(xy); // a y-axis goes up
+    Shape::add(Point(xy.x, xy.y - length));
+    if (1 < n) {
+      int dist = length / n;
+      int y = xy.y - dist;
+      for (int i = 0; i < n; ++i) {
+        notches.add(Point(xy.x, y), Point(xy.x + 5, y));
+        y -= dist;
+      }
+    }
+    // label at top
+    label.move(xy.x - 10, xy.y - length - 10);
+    break;
+  }
+  case Axis::z:
+    error("z axis not implemented");
+  }
+}
+
+void Axis::draw_lines() const {
+  Shape::draw_lines(); // the line
+  notches.draw();      // the notches may have a different color from the line
+  label.draw();        // the label may have a different color from the line
+}
+
+void Axis::set_color(Color c) {
+  Shape::set_color(c);
+  notches.set_color(c);
+  label.set_color(c);
+}
+
+void Axis::move(int dx, int dy) {
+  Shape::move(dx, dy);
+  notches.move(dx, dy);
+  label.move(dx, dy);
+}
+
+void Circle::draw_lines() const {
+  if (fill_color().visibility()) { // fill
+    fl_color(fill_color().as_int());
+    fl_pie(point(0).x, point(0).y, r + r - 1, r + r - 1, 0, 360);
+    fl_color(color().as_int()); // reset color
+  }
+
+  if (color().visibility()) {
+    fl_color(color().as_int());
+    fl_arc(point(0).x, point(0).y, r + r, r + r, 0, 360);
+  }
+}
+
+void Ellipse::draw_lines() const {
+  if (fill_color().visibility()) { // fill
+    fl_color(fill_color().as_int());
+    fl_pie(point(0).x, point(0).y, w + w - 1, h + h - 1, 0, 360);
+    fl_color(color().as_int()); // reset color
+  }
+
+  if (color().visibility()) {
+    fl_color(color().as_int());
+    fl_arc(point(0).x, point(0).y, w + w, h + h, 0, 360);
+  }
+}
+
+void draw_mark(Point xy, char c) {
+  static const int dx = 4;
+  static const int dy = 4;
+  string m(1, c);
+  fl_draw(m.c_str(), xy.x - dx, xy.y + dy);
+}
+
+void Marked_polyline::draw_lines() const {
+  Open_polyline::draw_lines();
+  for (int i = 0; i < number_of_points(); ++i)
+    draw_mark(point(i), mark[i % mark.size()]);
+}
+/*
+void Marks::draw_lines() const
+{
+        for (int i=0; i<number_of_points(); ++i)
+                fl_draw(mark.c_str(),point(i).x-4,point(i).y+4);
+}
+*/
+
+std::map<string, Suffix::Encoding> suffix_map;
+
+int init_suffix_map() {
+  suffix_map["jpg"] = Suffix::jpg;
+  suffix_map["JPG"] = Suffix::jpg;
+  suffix_map["jpeg"] = Suffix::jpg;
+  suffix_map["JPEG"] = Suffix::jpg;
+  suffix_map["gif"] = Suffix::gif;
+  suffix_map["GIF"] = Suffix::gif;
+  suffix_map["bmp"] = Suffix::bmp;
+  suffix_map["BMP"] = Suffix::bmp;
+  return 0;
+}
+
+Suffix::Encoding get_encoding(const string &s)
+// try to deduce type from file name using a lookup table
+{
+  static int x = init_suffix_map();
+
+  string::const_iterator p = find(s.begin(), s.end(), '.');
+  if (p == s.end())
+    return Suffix::none; // no suffix
+
+  string suf(p + 1, s.end());
+  return suffix_map[suf];
+}
+
+bool can_open(const string &s)
+// check if a file named s exists and can be opened for reading
+{
+  ifstream ff(s.c_str());
+  return ff.is_open();
+}
+
+// somewhat overelaborate constructor
+// because errors related to image files can be such a pain to debug
+Image::Image(Point xy, string s, Suffix::Encoding e) : w(0), h(0), fn(xy, "") {
+  add(xy);
+
+  if (!can_open(s)) {
+    fn.set_label("cannot open \"" + s + '\"');
+    p = new Bad_image(30, 20); // the "error image"
+    return;
+  }
+
+  if (e == Suffix::none)
+    e = get_encoding(s);
+
+  switch (e) {
+  case Suffix::jpg:
+    p = new Fl_JPEG_Image(s.c_str());
+    break;
+  case Suffix::gif:
+    p = new Fl_GIF_Image(s.c_str());
+    break;
+    //	case Suffix::bmp:
+    //		p = new Fl_BMP_Image(s.c_str());
+    //		break;
+  default: // Unsupported image encoding
+    fn.set_label("unsupported file type \"" + s + '\"');
+    p = new Bad_image(30, 20); // the "error image"
+  }
+}
+
+void Image::draw_lines() const {
+  if (fn.label() != "")
+    fn.draw_lines();
+
+  if (w && h)
+    p->draw(point(0).x, point(0).y, w, h, cx, cy);
+  else
+    p->draw(point(0).x, point(0).y);
+}
+
+} // namespace Graph_lib
\ No newline at end of file
diff --git a/Simple_window.cpp b/src/Graph_lib/Simple_window.cpp
similarity index 51%
rename from Simple_window.cpp
rename to src/Graph_lib/Simple_window.cpp
index 1c9c6a4..f14e5ed 100644
--- a/Simple_window.cpp
+++ b/src/Graph_lib/Simple_window.cpp
@@ -4,17 +4,7 @@
 // "Programming -- Principles and Practice Using C++" by Bjarne Stroustrup
 //
 
-#include "Simple_window.h"
-
-//------------------------------------------------------------------------------
-
-Simple_window::Simple_window(Point xy, int w, int h, const string& title) :
-    Window(xy,w,h,title),
-    next_button(Point(x_max()-70,0), 70, 20, "Next", cb_next),
-    button_pushed(false)
-{
-    attach(next_button);
-}
+#include <Graph_lib/Simple_window.hpp>
 
 //------------------------------------------------------------------------------
 
@@ -23,34 +13,34 @@ bool Simple_window::wait_for_button()
 // handle all events (as per default), quit when button_pushed becomes true
 // this allows graphics without control inversion
 {
-    show();
-    button_pushed = false;
+  show();
+  button_pushed = false;
 #if 1
-    // Simpler handler
-    while (!button_pushed) Fl::wait();
-    Fl::redraw();
+  // Simpler handler
+  while (!button_pushed)
+    Fl::wait();
+  Fl::redraw();
 #else
-    // To handle the case where the user presses the X button in the window frame
-    // to kill the application, change the condition to 0 to enable this branch.
-    Fl::run();
+  // To handle the case where the user presses the X button in the window frame
+  // to kill the application, change the condition to 0 to enable this branch.
+  Fl::run();
 #endif
-    return button_pushed;
+  return button_pushed;
 }
 
 //------------------------------------------------------------------------------
 
 void Simple_window::cb_next(Address, Address pw)
 // call Simple_window::next() for the window located at pw
-{  
-    reference_to<Simple_window>(pw).next();    
+{
+  reference_to<Simple_window>(pw).next();
 }
 
 //------------------------------------------------------------------------------
 
-void Simple_window::next()
-{
-    button_pushed = true;
-    hide();
+void Simple_window::next() {
+  button_pushed = true;
+  hide();
 }
 
 //------------------------------------------------------------------------------
diff --git a/src/Graph_lib/Window.cpp b/src/Graph_lib/Window.cpp
new file mode 100644
index 0000000..5d90a05
--- /dev/null
+++ b/src/Graph_lib/Window.cpp
@@ -0,0 +1,62 @@
+#include <Graph_lib/GUI.hpp>
+#include <Graph_lib/Graph.hpp>
+#include <Graph_lib/Window.hpp>
+
+namespace Graph_lib {
+
+Window::Window(int ww, int hh, const string &title)
+    : Fl_Window(ww, hh, title.c_str()), w(ww), h(hh) {
+  init();
+}
+
+Window::Window(Point xy, int ww, int hh, const string &title)
+    : Fl_Window(xy.x, xy.y, ww, hh, title.c_str()), w(ww), h(hh) {
+  init();
+}
+
+void Window::init() {
+  resizable(this);
+  show();
+}
+
+//----------------------------------------------------
+
+void Window::draw() {
+  Fl_Window::draw();
+  for (unsigned int i = 0; i < shapes.size(); ++i)
+    shapes[i]->draw();
+}
+
+void Window::attach(Widget &w) {
+  begin();         // FTLK: begin attaching new Fl_Wigets to this window
+  w.attach(*this); // let the Widget create its Fl_Wigits
+  end();           // FTLK: stop attaching new Fl_Wigets to this window
+}
+
+void Window::detach(Widget &b) { b.hide(); }
+
+void Window::attach(Shape &s) {
+  shapes.push_back(&s);
+  //		s.attached = this;
+}
+void Window::detach(Shape &s) {
+  for (unsigned int i = shapes.size(); 0 < i;
+       --i) // guess last attached will be first released
+    if (shapes[i - 1] == &s)
+      shapes.erase(shapes.begin() + (i - 1)); //&shapes[i-1]);
+}
+
+void Window::put_on_top(Shape &p) {
+  for (int i = 0; i < shapes.size(); ++i) {
+    if (&p == shapes[i]) {
+      for (++i; i < shapes.size(); ++i)
+        shapes[i - 1] = shapes[i];
+      shapes[shapes.size() - 1] = &p;
+      return;
+    }
+  }
+}
+
+int gui_main() { return Fl::run(); }
+
+} // namespace Graph_lib
diff --git a/std_lib_facilities.h b/std_lib_facilities.h
deleted file mode 100644
index 2fd388c..0000000
--- a/std_lib_facilities.h
+++ /dev/null
@@ -1,255 +0,0 @@
-/*
-   std_lib_facilities.h
-*/
-
-/*
-	simple "Programming: Principles and Practice using C++ (second edition)" course header to
-	be used for the first few weeks.
-	It provides the most common standard headers (in the global namespace)
-	and minimal exception/error support.
-
-	Students: please don't try to understand the details of headers just yet.
-	All will be explained. This header is primarily used so that you don't have
-	to understand every concept all at once.
-
-	By Chapter 10, you don't need this file and after Chapter 21, you'll understand it
-
-	Revised April 25, 2010: simple_error() added
-	
-	Revised November 25 2013: remove support for pre-C++11 compilers, use C++11: <chrono>
-	Revised November 28 2013: add a few container algorithms
-	Revised June 8 2014: added #ifndef to workaround Microsoft C++11 weakness
-*/
-
-#ifndef H112
-#define H112 251113L
-
-
-#include<iostream>
-#include<iomanip>
-#include<fstream>
-#include<sstream>
-#include<cmath>
-#include<cstdlib>
-#include<string>
-#include<list>
-#include <forward_list>
-#include<vector>
-#include<unordered_map>
-#include<algorithm>
-#include <array>
-#include <regex>
-#include<random>
-#include<stdexcept>
-
-//------------------------------------------------------------------------------
-
-
-//------------------------------------------------------------------------------
-
-typedef long Unicode;
-
-//------------------------------------------------------------------------------
-
-using namespace std;
-
-template<class T> string to_string(const T& t)
-{
-	ostringstream os;
-	os << t;
-	return os.str();
-}
-
-struct Range_error : out_of_range {	// enhanced vector range error reporting
-	int index;
-	Range_error(int i) :out_of_range("Range error: "+to_string(i)), index(i) { }
-};
-
-
-// trivially range-checked vector (no iterator checking):
-template< class T> struct Vector : public std::vector<T> {
-	using size_type = typename std::vector<T>::size_type;
-
-#ifdef _MSC_VER
-	// microsoft doesn't yet support C++11 inheriting constructors
-	Vector() { }
-	explicit Vector(size_type n) :std::vector<T>(n) {}
-	Vector(size_type n, const T& v) :std::vector<T>(n,v) {}
-	template <class I>
-	Vector(I first, I last) : std::vector<T>(first, last) {}
-	Vector(initializer_list<T> list) : std::vector<T>(list) {}
-#else
-	using std::vector<T>::vector;	// inheriting constructor
-#endif
-
-	T& operator[](unsigned int i) // rather than return at(i);
-	{
-		if (i<0||this->size()<=i) throw Range_error(i);
-		return std::vector<T>::operator[](i);
-	}
-	const T& operator[](unsigned int i) const
-	{
-		if (i<0||this->size()<=i) throw Range_error(i);
-		return std::vector<T>::operator[](i);
-	}
-};
-
-// disgusting macro hack to get a range checked vector:
-#define vector Vector
-
-// trivially range-checked string (no iterator checking):
-struct String : std::string {
-	using size_type = std::string::size_type;
-//	using string::string;
-
-	char& operator[](unsigned int i) // rather than return at(i);
-	{
-		if (i<0||size()<=i) throw Range_error(i);
-		return std::string::operator[](i);
-	}
-
-	const char& operator[](unsigned int i) const
-	{
-		if (i<0||size()<=i) throw Range_error(i);
-		return std::string::operator[](i);
-	}
-};
-
-
-namespace std {
-
-    template<> struct hash<String>
-    {
-        size_t operator()(const String& s) const
-        {
-            return hash<std::string>()(s);
-        }
-    };
-
-} // of namespace std
-
-
-struct Exit : runtime_error {
-	Exit(): runtime_error("Exit") {}
-};
-
-// error() simply disguises throws:
-inline void error(const string& s)
-{
-	throw runtime_error(s);
-}
-
-inline void error(const string& s, const string& s2)
-{
-	error(s+s2);
-}
-
-inline void error(const string& s, int i)
-{
-	ostringstream os;
-	os << s <<": " << i;
-	error(os.str());
-}
-
-
-template<class T> char* as_bytes(T& i)	// needed for binary I/O
-{
-	void* addr = &i;	// get the address of the first byte
-						// of memory used to store the object
-	return static_cast<char*>(addr); // treat that memory as bytes
-}
-
-
-inline void keep_window_open()
-{
-	cin.clear();
-	cout << "Please enter a character to exit\n";
-	char ch;
-	cin >> ch;
-	return;
-}
-
-inline void keep_window_open(string s)
-{
-	if (s=="") return;
-	cin.clear();
-	cin.ignore(120,'\n');
-	for (;;) {
-		cout << "Please enter " << s << " to exit\n";
-		string ss;
-		while (cin >> ss && ss!=s)
-			cout << "Please enter " << s << " to exit\n";
-		return;
-	}
-}
-
-
-
-// error function to be used (only) until error() is introduced in Chapter 5:
-inline void simple_error(string s)	// write ``error: s and exit program
-{
-	cerr << "error: " << s << '\n';
-	keep_window_open();		// for some Windows environments
-	exit(1);
-}
-
-// make std::min() and std::max() accessible on systems with antisocial macros:
-#undef min
-#undef max
-
-
-// run-time checked narrowing cast (type conversion). See ???.
-template<class R, class A> R narrow_cast(const A& a)
-{
-	R r = R(a);
-	if (A(r)!=a) error(string("info loss"));
-	return r;
-}
-
-// random number generators. See 24.7.
-
-
-
-inline int randint(int min, int max) { static default_random_engine ran; return uniform_int_distribution<>{min, max}(ran); }
-
-inline int randint(int max) { return randint(0, max); }
-
-//inline double sqrt(int x) { return sqrt(double(x)); }	// to match C++0x
-
-// container algorithms. See 21.9.
-
-template<typename C>
-using Value_type = typename C::value_type;
-
-template<typename C>
-using Iterator = typename C::iterator;
-
-template<typename C>
-	// requires Container<C>()
-void sort(C& c)
-{
-	std::sort(c.begin(), c.end());
-}
-
-template<typename C, typename Pred>
-// requires Container<C>() && Binary_Predicate<Value_type<C>>()
-void sort(C& c, Pred p)
-{
-	std::sort(c.begin(), c.end(), p);
-}
-
-template<typename C, typename Val>
-	// requires Container<C>() && Equality_comparable<C,Val>()
-Iterator<C> find(C& c, Val v)
-{
-	return std::find(c.begin(), c.end(), v);
-}
-
-template<typename C, typename Pred>
-// requires Container<C>() && Predicate<Pred,Value_type<C>>()
-Iterator<C> find_if(C& c, Pred p)
-{
-	return std::find_if(c.begin(), c.end(), p);
-}
-
-#endif //H112
diff --git a/todo.md b/todo.md
new file mode 100644
index 0000000..f1af7f5
--- /dev/null
+++ b/todo.md
@@ -0,0 +1,3 @@
+# To Do-list
+
+- [ ] Closing the window with the cross close button does not terminate the program.
diff --git a/tool/chapter12.cpp b/tool/chapter12.cpp
new file mode 100644
index 0000000..bb7ddcf
--- /dev/null
+++ b/tool/chapter12.cpp
@@ -0,0 +1,106 @@
+#include <Graph_lib/Graph.hpp>
+#include <Graph_lib/Simple_window.hpp>
+#include <cstdlib>
+
+auto main() -> int {
+  using namespace Graph_lib;
+
+  // Section 12.7.2 An almost blank window
+  Point tl{100, 100};
+  Simple_window win{tl, 600, 400, "Canvas"};
+  win.wait_for_button();
+
+  // Section 12.7.3 Axis
+  Axis xa{Axis::x, Point{20, 300}, 280, 10, "x axis"};
+  win.attach(xa);
+  win.set_label("Canvas #2");
+  win.wait_for_button();
+  Axis ya{Axis::y, Point{20, 300}, 280, 10};
+  ya.set_color(Color::cyan);
+  ya.label.set_color(Color::dark_red);
+  win.attach(ya);
+  win.set_label("Canvas #3");
+  win.wait_for_button();
+
+  // Section 12.7.4 Graphing a function
+  Function sine{sin, 0, 100, Point{20, 150}, 1000, 50, 50};
+  win.attach(sine);
+  win.set_label("Canvas #4");
+  win.wait_for_button();
+
+  // Section 12.7.5 Polygons
+  sine.set_color(Color::blue);
+  Polygon poly;
+  poly.add(Point{300, 200});
+  poly.add(Point{350, 100});
+  poly.add(Point{400, 200});
+  poly.set_color(Color::red);
+  poly.set_style(Line_style::dash);
+  win.attach(poly);
+  win.set_label("Canvas #5");
+  win.wait_for_button();
+
+  // Section 12.7.6 Rectangles
+  Rectangle r{Point{200, 200}, 100, 50};
+  win.attach(r);
+  win.set_label("Canvas #6");
+  win.wait_for_button();
+  Closed_polyline poly_rect;
+  poly_rect.add(Point{100, 50});
+  poly_rect.add(Point{200, 50});
+  poly_rect.add(Point{200, 100});
+  poly_rect.add(Point{100, 100});
+  poly_rect.add(Point{50, 75});
+  win.attach(poly_rect);
+
+  // Section 12.7.7 Fill
+  r.set_fill_color(Color::yellow);
+  poly.set_style(Line_style(Line_style::dash, 4));
+  poly_rect.set_style(Line_style(Line_style::dash, 2));
+  poly_rect.set_fill_color(Color::green);
+  win.set_label("Canvas #7");
+  win.wait_for_button();
+
+  // Section 12.7.8 Text
+  Text t{Point{150, 150}, "Hello, graphical world!"};
+  win.attach(t);
+  win.set_label("Canvas #8");
+  win.wait_for_button();
+  t.set_font(Font::times_bold);
+  t.set_font_size(20);
+  win.set_label("Canvas #9");
+  win.wait_for_button();
+
+  // Section 12.7.9 Images
+  Image ii{Point{100, 50}, "image.jpg"};
+  win.attach(ii);
+  win.set_label("Canvas #10");
+  win.wait_for_button();
+  ii.move(100, 200);
+  win.set_label("Canvas #11");
+  win.wait_for_button();
+
+  // Section 12.7.10 And much more
+  Circle c{Point{100, 200}, 50};
+  Ellipse e{Point{100, 200}, 75, 25};
+  e.set_color(Color::dark_red);
+  Mark m{Point{100, 200}, 'x'};
+
+  ostringstream oss;
+  oss << "screen size: " << x_max() << "*" << y_max()
+      << "; window size: " << win.x_max() << "*" << win.y_max();
+  Text sizes{Point{100, 20}, oss.str()};
+
+  Image cal{Point{22, 225}, "snow_cpp.gif"};
+  cal.set_mask(Point{40, 40}, 200, 150);
+  win.attach(c);
+  win.attach(m);
+  win.attach(e);
+
+  win.attach(sizes);
+  win.attach(cal);
+  win.set_label("Canvas #12");
+  win.wait_for_button();
+
+  return EXIT_SUCCESS;
+}
diff --git a/tool/chapter13.cpp b/tool/chapter13.cpp
new file mode 100644
index 0000000..6cdff30
--- /dev/null
+++ b/tool/chapter13.cpp
@@ -0,0 +1,37 @@
+#include <Graph_lib/Graph.hpp>
+#include <Graph_lib/Simple_window.hpp>
+#include <cstdlib>
+
+auto main() -> int {
+  using namespace Graph_lib;
+
+  Simple_window win{Point{100, 100}, 600, 400, "Canvas"};
+
+  // Section 13.3
+  Lines lines;
+  lines.add(Point{100, 100}, Point{200, 100});
+  lines.add(Point{150, 50}, Point{150, 150});
+  win.attach(lines);
+  win.set_label("Canvas #1");
+  win.wait_for_button();
+
+  int x_size = win.x_max();
+  int y_size = win.y_max();
+  int x_grid = 80;
+  int y_grid = 80;
+
+  Lines grid;
+  for (int x = x_grid; x < x_size; x += x_grid)
+    grid.add(Point{x, 0}, Point{x, y_size});
+  for (int y = y_grid; y < y_size; y += y_grid)
+    grid.add(Point{0, y}, Point{x_size, y});
+  win.attach(grid);
+  win.set_label("Canvas #2");
+  win.wait_for_button();
+
+  // Section 13.4
+  grid.set_color(Color::red);
+  win.wait_for_button();
+
+  return EXIT_SUCCESS;
+}