[Boost-commit] svn:boost r45723 - sandbox/SOC/2007/visualization/libs/svg_plot/example

From: pbristow_at_[hidden]
Date: 2008-05-24 12:32:31

Author: pbristow
Date: 2008-05-24 12:32:30 EDT (Sat, 24 May 2008)
New Revision: 45723
URL: http://svn.boost.org/trac/boost/changeset/45723

Log:
New autoscale examples.
Added:
   sandbox/SOC/2007/visualization/libs/svg_plot/example/auto_1d_containers.cpp   (contents, props changed)
   sandbox/SOC/2007/visualization/libs/svg_plot/example/auto_1d_plot.cpp   (contents, props changed)
   sandbox/SOC/2007/visualization/libs/svg_plot/example/auto_2d_plot.cpp   (contents, props changed)

Added: sandbox/SOC/2007/visualization/libs/svg_plot/example/auto_1d_containers.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/visualization/libs/svg_plot/example/auto_1d_containers.cpp	2008-05-24 12:32:30 EDT (Sat, 24 May 2008)
@@ -0,0 +1,170 @@
+// auto_1d_containers.cpp
+
+// Copyright Paul A Bristow 2008
+
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// An example to demonstrate autoscaling with *multiple* STL containers.
+// See also auto_1d_plot.cpp and auto_1d_container.cpp.
+
+// Caution: this file contains Quickbook markup as well as code
+// and comments: don't change any of the special comment markups!
+
+//[auto_1d_containers_1
+
+/*`First we need a few includes to use Boost.Plot
+(and some others only needed for this example).
+*/
+
+#include <boost/svg_plot/svg_1d_plot.hpp>
+  using namespace boost::svg;
+  using boost::svg::svg_1d_plot;
+
+#include <boost/svg_plot/detail/auto_axes.hpp>
+  using boost::svg::show; // A single STL container.
+  using boost::svg::show_all; // Multiple STL containers.
+  using boost::svg::range; // Find min and max of a STL container.
+  using boost::svg::range_all;// Find min and max of multipler STL containers.
+  // Note neither of these chack for 'limits' (infinite, NaN) values
+
+#include <boost/svg_plot/detail/pair.hpp>
+  using boost::svg::detail::operator<<; // Output pair as 1.23, 4.56
+
+//#include <boost/svg_plot/show_1d_settings.hpp>
+// Only needed for showing which settings in use.
+//void boost::svg::show_1d_plot_settings(svg_1d_plot&);
+
+#include <boost/algorithm/minmax.hpp>
+ using boost::minmax;
+#include <boost/algorithm/minmax_element.hpp>
+ using boost::minmax_element;
+
+#include <iostream>
+  using std::cout;
+  using std::endl;
+  using std::boolalpha;
+
+#include <limits>
+  using std::numeric_limits;
+
+#include <vector>
+  using std::vector;
+
+#include <utility>
+  using std::pair;
+  using boost::svg::detail::operator<<; // Output pair as 1.23, 4.56
+
+#include <algorithm>
+  using std::multiplies;
+  using std::transform;
+  using std::copy;
+#include <iterator>
+  using std::iterator;
+  using std::iterator_traits;
+  using std::ostream_iterator;
+  
+//] [/auto_1d_containers_1]
+
+int main()
+{
+//[auto_1d_containers_2
+  /*`This example uses two containers to demonstrate autoscaling.
+  It is common to plot more than one set of data series together.
+  Autoscaling must probably inspect all the containers of these series
+  in order to find axis ranges that will be suitable for all of them.
+  */
+	vector<double> my_data_1;
+	// Initialize STL container my_data_1 with some entirely fictional data.
+  my_data_1.push_back(0.2); // [0]
+  my_data_1.push_back(1.1); // [1]
+  my_data_1.push_back(4.2); // [2]
+  my_data_1.push_back(3.3); // [3]
+  my_data_1.push_back(5.4); // [4]
+  my_data_1.push_back(6.5); // [5]
+
+  /*`
+  We might use some convenient functions to list the container to cout.
+  */
+  show(my_data_1); // Entire container contents.
+  /*`
+  Others are easily written, often using std::copy, for example:
+  ``
+  copy(my_data_1_2.begin(), my_data_1_2.end(), ostream_iterator<double>(cout, " "));
+  ``
+  */
+  /*`
+  Now we concoct another equally fictional data series by a transform multiplying by 2.3.
+  */
+
+  vector<double> my_data_2; // Create a second data series.
+  copy(my_data_1.begin(), my_data_1.end(), back_inserter(my_data_2));
+  // Change the values in an entirely arbitrary way (each * 2.3).
+  transform(my_data_2.begin(), my_data_2.end(), my_data_2.begin(), bind1st(multiplies<double>(), 2.3));
+  //cout << endl << my_data.size() << " values in my_data_2. " << endl;
+
+  /*`Next we need a new STL container, vector say, to hold our multiple containers of data series.
+    They must all be the same STL container type, in this example, vector<double>.
+    And we use pushback to add the containers.
+  */
+  vector<vector<double> > my_containers; 
+
+  my_containers.push_back(my_data_1); // Add 1st data series. 
+  my_containers.push_back(my_data_2); // Add another data series.
+  cout << my_containers.size() << " containers." << endl;
+  show_all(my_containers);
+
+  /*` Finally we can use all the containers to find the minimum of mimimums and maximum of maximums
+  ready to feed into the plot autoscale function.
+  */
+  pair<double, double> mm = range_all(my_containers);
+  cout << "Data range: "  << mm << endl; // min & max of all data.
+  svg_1d_plot my_1d_plot; // Construct a plot with all the default constructor values.
+
+  /*`We could feed the minimum and maximum values separately,*/
+  my_1d_plot.x_autoscale(mm.first, mm.second);  // Use minimum and maximum to autoscale.
+  /*`
+  but usually feeding the pair is more convenient.
+  (Perhaps we might want to impose some other minimum and maximum here).
+  */
+  my_1d_plot.x_autoscale(mm);  // Use overall minimum and maximum to autoscale.
+
+  /*`Finally, we add the data series containers to the plot, and write the SVG out to file.*/
+  my_1d_plot.plot(my_data_1, "data_1");
+  my_1d_plot.plot(my_data_2, "data_2");
+
+  my_1d_plot.write("auto_1d_containers.svg"); // Write the plot to file.
+
+  /*`If we want, we can check the autoscale range used, or even all the plot settings.*/
+  cout << "x_range() " << my_1d_plot.x_range() << endl; // x_range() 0, 15
+  //show_1d_plot_settings(my_1d_plot); // If required.
+ 
+//] [/auto_1d_containers_2]
+
+	return 0;
+} // int main()
+
+/*
+
+//[auto_1d_containers_output
+
+Compiling...
+auto_1d_containers.cpp
+Linking...
+Embedding manifest...
+Autorun "j:\Cpp\SVG\debug\auto_1d_containers.exe"
+6 values in container: 0.2 1.1 4.2 3.3 5.4 6.5 
+2 containers.
+6 values in container: 0.2 1.1 4.2 3.3 5.4 6.5 
+6 values in container: 0.46 2.53 9.66 7.59 12.42 14.95 
+Data range: 0.2, 14.9
+x_range() 0, 15
+Build Time 0:03
+
+//] [/auto_1d_containers_output]
+
+
+*/
+

Added: sandbox/SOC/2007/visualization/libs/svg_plot/example/auto_1d_plot.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/visualization/libs/svg_plot/example/auto_1d_plot.cpp	2008-05-24 12:32:30 EDT (Sat, 24 May 2008)
@@ -0,0 +1,375 @@
+// auto_1d_plot.cpp
+
+// Copyright Jacob Voytko 2007
+// Copyright Paul A Bristow 2008
+
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// An example to demonstrate simple 1D settings, including *auto-scaling*.
+// See auto_1d_containers.cpp for an example autoscaling with multiple data series.
+// See also demo_1d_plot.cpp for a wider range of use.
+
+// This file is written to be included from a Quickbook .qbk document.
+// It can be compiled by the C++ compiler, and run. Any output can
+// also be added here as comment or included or pasted in elsewhere.
+
+// Caution: this file contains Quickbook markup as well as code
+// and comments: don't change any of the special comment markups!
+
+
+//[auto_1d_plot_1
+
+/*`First we need a few includes to use Boost.Plot
+(and some others only needed for this example).
+*/
+
+#include <boost/svg_plot/svg_1d_plot.hpp>
+  using namespace boost::svg;
+  using boost::svg::svg_1d_plot;
+
+#include <boost/svg_plot/show_1d_settings.hpp>
+// Only needed for showing which settings in use.
+ void boost::svg::show_1d_plot_settings(svg_1d_plot&);
+ // (Also provides operator<< for std::pair).
+
+#include <boost/algorithm/minmax.hpp>
+ using boost::minmax;
+#include <boost/algorithm/minmax_element.hpp>
+ using boost::minmax_element;
+
+#include <iostream> // for debugging.
+  using std::cout;
+  using std::endl;
+  using std::boolalpha;
+
+#include <limits>
+  using std::numeric_limits;
+
+#include <vector>
+  using std::vector;
+#include <set>
+  using std::multiset;
+
+#include <utility>
+  using std::pair;
+
+#include <boost/svg_plot/detail/auto_axes.hpp>
+  using boost::svg::show; // A single STL container.
+  using boost::svg::show_all; // Multiple STL containers.
+  using boost::svg::range; // Find min and max of a STL container.
+  using boost::svg::range_all;// Find min and max of multipler STL containers.
+
+//] [/auto_1d_plot_1]
+
+void scale_axis(double min_value, double max_value, // input
+               double* axis_min_value,  double* axis_max_value, double* axis_tick_increment, // updated.
+               bool origin, double tight, int min_ticks, int steps); 
+
+double tol100eps = 1000 * numeric_limits<double>::epsilon(); // suitable tight value.
+
+int main()
+{
+  //[auto_1d_plot_2
+  /*`This example uses containers to demonstrate autoscaling.
+  Autoscaling must inspect the container in order to find axis ranges that will be suitable.
+  First we create a container and fill with some fictional data.
+  */
+	vector<double> my_data;
+	// Initialize my_data with some entirely fictional data.
+  my_data.push_back(0.2);
+  my_data.push_back(1.1); // [1]
+  my_data.push_back(4.2); // [2]
+  my_data.push_back(3.3); // [3]
+  my_data.push_back(5.4); // [4]
+  my_data.push_back(6.5); // [5]
+
+  /*`Also included is an 'at limit' value that could confuse autoscaling.
+  Obviously we do not want the plot range to include infinity.*/
+  my_data.push_back(numeric_limits<double>::infinity()); // [6]
+
+  try
+  { // Ensure error, warning and information messages are displayed by the catch block.
+    double mn;
+    double mx;
+    int good = mnmx(my_data.begin(), my_data.end(), &mn, &mx);
+    cout << good << " good values, " << my_data.size() - good << " limit values." << endl;
+
+    using boost::svg::detail::operator<<; // For displaying std::pair.
+    svg_1d_plot my_1d_plot; // Construct a plot with all the default constructor values.
+    my_1d_plot.x_autoscale(my_data);  // Compute autoscale values for the plot.
+    my_1d_plot.plot(my_data, "Default 1D"); // Add the one data series, and give it a title.
+    my_1d_plot.write("auto_1d_plot.svg"); // Write the plot to file.
+
+    /*`It may be useful to display that range chosen by autoscaling. */
+    cout << "x_range() " << my_1d_plot.x_range() << endl; // x_range() 
+  }
+  catch(const std::exception& e)
+  { // Error, warning and information messages are displayed by the catch block.
+    std::cout <<
+      "\n""Message from thrown exception was:\n   " << e.what() << std::endl;
+  }
+  //] [/auto_1d_plot_2]
+
+  //[auto_1d_plot_3
+/*`Other STL containers can also be used, for example set, or multiset (allowing duplicates):*/
+
+  try
+  { // Ensure error, warning and information messages are displayed by the catch block.
+
+  multiset<double> my_set;
+	// Initialize my_set with some entirely fictional data.
+  my_set.insert(1.2);
+  my_set.insert(2.3);
+  my_set.insert(3.4);
+  my_set.insert(4.5);
+  my_set.insert(5.6);
+  my_set.insert(6.7);
+  my_set.insert(7.8);
+  my_set.insert(8.9);
+  // Some examples of showing the set using various iterators:
+  multiset<double>::const_iterator si;
+
+  show(my_data); // Entire container contents,
+  show(my_set); // for two different types of container.
+
+  // show(&my_data[0], &my_data[my_data.size()]); // pointers - wrong! uses more all data ;-)
+  show(&my_data[0], &my_data[my_data.size()-1]); // pointers, all data.
+  show(&my_data[1], &my_data[5]); // pointers, part data.
+  show(my_data.begin(), my_data.end()); // iterators.
+  show(++(my_data.begin()), --(my_data.end())); // Just the 4 middle values.
+
+  vector<double>::const_iterator idb = my_data.begin();
+  vector<double>::const_iterator ide = my_data.end();
+  show(idb, ide); // All
+  ++idb; // Move to 2nd value.
+  --ide; // move back from last value.
+  show(idb, ide); // Just the 4 middle values.
+
+  typedef vector<double>::const_iterator vector_iterator;
+  pair<vector_iterator, vector_iterator> result = boost::minmax_element(my_data.begin(), my_data.end());
+  cout << "The smallest element is " << *(result.first) << endl; // 0.2
+  cout << "The largest element is  " << *(result.second) << endl; // 6.5
+
+/*`Autoscaling can also use two double min and max values provided by the user program.
+Using `x_autoscale(my_set)` effectively uses the first and last items in the STL container.
+If the container is sorted, then these are the minimum and maximum values.*/
+
+  double min_value = *(my_data.begin());
+  double max_value = *(--my_data.end());
+  cout << "my_set min " << min_value << ", max = " << max_value << endl;
+
+/*`Function scale_axis is used by autoscale, but is also available for use direct by the user.
+It accepts parameters controlling the scaling and updates 4 items. Its signature is:
+
+  ``void scale_axis(double min_value, double max_value, // Input range
+               double* axis_min_value,  double* axis_max_value, double* axis_tick_increment, int* auto_ticks, // All 4 updated.
+               bool check_limits, // Whether to check all values for infinity, NaN etc.
+               bool origin, // If true, ensures that zero is a tick value.
+               double tight, // Allows user to avoid a small fraction over a tick using another tick.
+               int min_ticks, // Minimum number of ticks.
+               int steps); // Round up and down to 2, 4, 6, 8, 10, or 5, 10 or 2, 5, 10 systems.
+  ``
+
+  */
+  double axis_min_value; // Values to be updated by autoscale.
+  double axis_max_value;
+  double axis_tick_increment;
+  int axis_ticks;
+
+  /*`min_value` and `max_value` could be provided by the user program:
+  usually these values are derived in some way from the user data.
+  Several examples follow.*/
+
+  // Scaling using first and last values in container,
+  // assuming the data are ordered in ascending value,
+  // for example, set, map, multimap, or a sorted vector or array.
+  //scale_axis(*my_data.begin(),*(--my_data.end()),
+  scale_axis(1., 9.,
+    &axis_min_value, &axis_max_value, &axis_tick_increment, &axis_ticks,
+    false, tol100eps, 6, 0); // Display range.
+  cout << "scaled min " << axis_min_value << ", max = " << axis_max_value
+    << ", increment " << axis_tick_increment << ", axis ticks " << axis_ticks << endl;
+
+  // Scaling using two begin & end iterators into STL container,
+  // scale_axis does finding min and max.
+  scale_axis(my_data.begin(), my_data.end(),
+    &axis_min_value, &axis_max_value, &axis_tick_increment, &axis_ticks,
+    true, false, tol100eps, 6); // Display range.
+  cout << "scaled min " << axis_min_value << ", max = " << axis_max_value
+    << ", increment " << axis_tick_increment << ", axis ticks " << axis_ticks << endl;
+
+  // Scaling using two begin & end iterators into STL container,
+  // scale_axis does finding min and max.
+  scale_axis(my_data[1], my_data[4], // Only middle part of the container used, ignoring 1st and last values.
+    &axis_min_value, &axis_max_value, &axis_tick_increment, &axis_ticks,
+    false, tol100eps, 6); // Display range.
+  cout << "scaled min " << axis_min_value << ", max = " << axis_max_value
+    << ", increment " << axis_tick_increment << ", axis ticks " << axis_ticks << endl;
+
+  // Scaling using whole  STL vector container,
+  // scale_axis does finding min and max.
+  scale_axis(my_data, &axis_min_value, &axis_max_value, &axis_tick_increment, &axis_ticks,
+    true, false, tol100eps, 6); // Display range.
+  cout << "scaled min " << axis_min_value << ", max = " << axis_max_value
+    << ", increment " << axis_tick_increment << ", axis ticks " << axis_ticks << endl;
+  
+  // Scaling using whole STL set container,
+  // scale_axis does finding min and max.
+  scale_axis(my_set, &axis_min_value, &axis_max_value, &axis_tick_increment, &axis_ticks,
+    true, false, tol100eps, 6); // Display range.
+  cout << "scaled min " << axis_min_value << ", max = " << axis_max_value
+    << ", increment " << axis_tick_increment << ", axis ticks " << axis_ticks << endl;
+
+  /*`However there may be trouble if the data could contain values that are outside normal limits.
+  Infinity (+ and -), and maximum value, and  NotaNumbers, are separated by the plot program to allow them to be shown,
+  but separate from 'normal' values.  These values similarly can distort automatic scaling:
+  a single infinity would result in useless scaling!
+  When the plot range is set, the maximum and minimum values are checked,
+  and if not normal then an exception will be thrown, and no plot will be produced.
+  However, when autoscaling, it is more useful to ignore 'limit' values.
+  But this means checking all values individually.  If it known that all values are normal,
+  for example because they come from some measuring equipment that is known only to produce normal values,
+  it will be much quicker to use std::min_max_element which can take advantange of knowledge of the container.
+
+  The function `autoscale_check_limits(bool)` is provided to control this. 
+  If set true, all values will be checked, and those at 'limits' will be ignored in autoscaling.
+  The default is true, to check all values.
+
+  If we had many very known normal values to plot and want to autoscale,
+  we might instead opt to ignore these checks, and write:
+  */
+	svg_1d_plot my_1d_plot; // Construct a plot with all the default constructor values.
+
+  //my_1d_plot.autoscale_check_limits(false);
+  // This *will throw an exception* if checks are avoided and any values are at 'limits'.
+
+  // One could also intercept and change any values calculated by scale_axis here.
+  // Set the plot to use range and interval from the scale_axis values.
+  my_1d_plot.x_range(axis_min_value, axis_max_value)
+    .x_major_interval(axis_tick_increment);
+
+  my_1d_plot.x_autoscale(false);  // Ensure autoscale values are *not* recalculated for the plot.
+
+/*`There are also some parameters which can fine-tune the autoscaling to produce more
+aesthetically pleasing ranges. One can:
+* enforce the inclusion of zero on the plot.
+* Specify a minimum number of major ticks.
+* Specify the steps between major ticks, default 0,  or 2 for 2, 4, 6, 8, 10, 5 for 1, 5, 10, or 10 (2, 5, 10).
+* Avoid values that are a tiny amount over the minimum or maximum from causing an apparently empty tick at the minimum or maximum.
+*/
+
+  // Set some autoscaling parameters:
+  my_1d_plot.x_with_zero(false);
+  my_1d_plot.x_min_ticks(10);
+  my_1d_plot.x_steps(0);
+  my_1d_plot.x_tight(0.001);
+
+  // Show the flags just set.
+  cout << (my_1d_plot.x_with_zero() ? "x_with_zero, " : "not x_with_zero, ")
+    << my_1d_plot.x_min_ticks() << " x_min_ticks, "
+    << my_1d_plot.x_steps() << " x_steps, " 
+    << my_1d_plot.x_tight() << " tightness." << endl;
+
+/*`Finally here are some examples of using autoscaling using all or part of containers.
+*/
+
+  my_1d_plot.x_autoscale(my_data);  // Use all my_data to autoscale.
+  cout << "Autoscaled " // Show the results of autoscale:
+    "min " << my_1d_plot.x_auto_min_value() 
+    << ", max "<< my_1d_plot.x_auto_max_value() 
+    << ", interval " << my_1d_plot.x_auto_tick_interval() << endl; // Autoscaled min 0, max 6.5, interval 0.5
+
+  my_1d_plot.x_autoscale(my_data.begin(), my_data.end());  // Use all my_data to autoscale.
+
+  cout << "Autoscaled " // Show the results of autoscale:
+    "min " << my_1d_plot.x_auto_min_value() 
+    << ", max "<< my_1d_plot.x_auto_max_value() 
+    << ", interval " << my_1d_plot.x_auto_tick_interval() << endl; // Autoscaled min 0, max 6.5, interval 0.5
+
+  my_1d_plot.x_autoscale(my_data[1], my_data[4]);  // Use only part of my_data to autoscale.
+
+  cout << "Autoscaled " // Show the results of autoscale:
+    "min " << my_1d_plot.x_auto_min_value() 
+    << ", max "<< my_1d_plot.x_auto_max_value() 
+    << ", interval " << my_1d_plot.x_auto_tick_interval() << endl; // Autoscaled min 1, max 5.5, interval 0.5
+
+  //my_1d_plot.x_autoscale(true);  // Ensure autoscale values are used for the plot.
+  // This is also automatically set true by any call of `x_autoscale(some_data);`
+
+
+/*`The actual addition of data values to the plot is, of course, quite separate from any autoscaling.
+*/
+  my_1d_plot.plot(my_data, "Auto 1D"); // Add the one data series.
+  cout << "Autoscaled " // Show the results of autoscale:
+    " min " << my_1d_plot.x_auto_min_value() 
+    << ", max "<< my_1d_plot.x_auto_max_value() 
+    << ", interval " << my_1d_plot.x_auto_tick_interval() << endl; // Autoscaled min 1, max 5.5, interval 0.5
+
+  my_1d_plot.plot(my_set.begin(), my_set.end(), "Auto 1D"); // Add another data series from my_set.
+  my_1d_plot.plot(my_set, "Auto 1D"); // Add another whole data series from my_set.
+  my_1d_plot.plot(&my_data[1], &my_data[4], "Auto 1D"); // Add part (1,2 3 but *not* 4) of the one data series.
+  //my_1d_plot.plot(&my_set[1], &my_set[4], "Auto 1D"); // operator[] is not defined for set container!
+
+  my_1d_plot.write("auto_1d_plot.svg"); // Write the plot to file.
+  
+  using boost::svg::detail::operator<<;
+  cout << "x_range() " << my_1d_plot.x_range() << endl; // x_range() 1, 5.5
+  show_1d_plot_settings(my_1d_plot);
+  }
+  catch(const std::exception& e)
+  { // Error, warning and information messages are displayed by the catch block.
+    std::cout <<
+      "\n""Message from thrown exception was:\n   " << e.what() << std::endl;
+  }
+
+/*`If necessary, one can obtain a complete listing of all the settings used.
+This is often useful when the plot does not meet expectations.
+*/
+ 
+//] [auto_1d_plot_3]
+
+	return 0;
+} // int main()
+
+/*
+
+auto_1d_plot.cpp
+Linking...
+Embedding manifest...
+Autorun "j:\Cpp\SVG\debug\auto_1d_plot.exe"
+limit value: 1.#INF
+6 good values, 1 limit values.
+7 values in container: 0.2 1.1 4.2 3.3 5.4 6.5 1.#INF 
+8 values in container: 1.2 2.3 3.4 4.5 5.6 6.7 7.8 8.9 
+0.2 1.1 4.2 3.3 5.4 6.5 : 6 values used.
+1.1 4.2 3.3 5.4 : 4 values used.
+0.2 1.1 4.2 3.3 5.4 6.5 1.#INF : 7 values used.
+1.1 4.2 3.3 5.4 6.5 : 5 values used.
+0.2 1.1 4.2 3.3 5.4 6.5 1.#INF : 7 values used.
+1.1 4.2 3.3 5.4 6.5 : 5 values used.
+The smallest element is 0.2
+The largest element is  1.#INF
+my_set min 0.2, max = 1.#INF
+scaled min 1, max = 9, increment 1, axis ticks 9
+limit value: 1.#INF
+scaled min 0, max = 7, increment 1, axis ticks 8
+scaled min 1, max = 6, increment 1, axis ticks 6
+limit value: 1.#INF
+scaled min 0, max = 7, increment 1, axis ticks 8
+scaled min 1, max = 9, increment 1, axis ticks 9
+not x_with_zero, 10 x_min_ticks, 0 x_steps, 0.001 tightness.
+limit value: 1.#INF
+Autoscaled min 0, max 6.5, interval 0.5
+limit value: 1.#INF
+Autoscaled min 0, max 6.5, interval 0.5
+Autoscaled min 1, max 5.5, interval 0.5
+Autoscaled  min 1, max 5.5, interval 0.5
+x_range() 1, 5.5
+Build Time 0:03
+
+
+*/
+

Added: sandbox/SOC/2007/visualization/libs/svg_plot/example/auto_2d_plot.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/visualization/libs/svg_plot/example/auto_2d_plot.cpp	2008-05-24 12:32:30 EDT (Sat, 24 May 2008)
@@ -0,0 +1,168 @@
+// auto_2d_plot.cpp
+
+// Copyright Paul A Bristow 2008
+
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// An example to demonstrate autoscaling with *multiple* STL containers.
+// See also auto_1d_plot.cpp and auto_1d_container.cpp.
+
+// Caution: this file contains Quickbook markup as well as code
+// and comments: don't change any of the special comment markups!
+
+//[auto_2d_plot_1
+
+/*`First we need a few includes to use Boost.Plot
+*/
+
+#include <boost/svg_plot/svg_2d_plot.hpp>
+  using namespace boost::svg;
+#include <utility>
+  using std::pair;
+#include <map>
+  using std::map;
+#include <set>
+  using std::multiset;
+#include <iostream>
+  using std::cout;
+  using std::endl;
+
+#include <limits>
+  using std::numeric_limits;
+
+#include <boost\math\special_functions\fpclassify.hpp>
+  using boost::math::isfinite;
+
+  // demo of getting the max and min of x and y
+template <class T> // T an STL container: array, vector ...
+void s(const T& container, // Container Data series to plot - entire container.
+               // (not necessarily ordered, so will find min and max).
+               double* x_min,  double* x_max,
+               double* y_min,  double* y_max
+               )
+{
+  typedef T::const_iterator iter;
+  std::pair<iter, iter> result = boost::minmax_element(container.begin(), container.end());
+  // minmax_element is efficient for maps because can use knowledge of being sorted,
+  // BUT only if it can be assumed that no values are 'at limits',
+  // infinity, NaN, max_value, min_value, denorm_min.
+  // Otherwise it is necessary to inspect all values individually.
+  pair<const double, double> px = *result.first;
+  pair<const double, double> py = *result.second;
+  *x_min = px.first;
+  *x_max = py.first;
+  *y_min = px.second;
+  *y_max = py.second;
+
+  cout << "s x_min " << *x_min << ", x_max " << *x_max << endl; // x_min 1, x_max 7.3
+  cout << "s y_min " << *y_min << ", y_max " << *y_max << endl; // y_min 3.2, y_max 9.1
+} // template <class T> int scale_axis  T an STL container: array, vector ...
+
+
+//] [/auto_2d_plot_1]
+
+int main()
+{
+//[auto_2d_plot_2
+  /*`This example uses a single map to demonstrate autoscaling.
+  We create a map to hold our data series.
+  */
+	map<const double, double> my_map;
+  /*`
+  Inserting some fictional values also sorts the data.
+  The index value in [] is the x value.
+  */
+	my_map[1.1] = 3.2;
+	my_map[7.3] = 9.1;
+	my_map[2.1] = 5.4;
+
+/*`Also include some 'limits' values that would confuse autoscaling.
+*/
+	my_map[99.99] = numeric_limits<double>::quiet_NaN();
+	my_map[999.9] = numeric_limits<double>::infinity();
+	my_map[999.] = +numeric_limits<double>::infinity();
+
+
+
+  /*`Next a 2D plot is created using defaults for the very many possible settings.
+  */
+	svg_2d_plot my_plot;
+
+  /*`Add at least a title,
+  specify the both x and y axes are to use autoscaling,
+  and add the one data series to plotted.
+  */
+	my_plot.title("Autoscale example");
+  //my_plot.autoscale_check_limits(false);  // Skip checks for speed.
+  // Will fail at run-time if any infinite or NaNs.
+
+	my_plot.xy_autoscale(my_map);
+
+	my_plot.plot(my_map);
+  /*`Finally write the SVG image to a file. */
+  my_plot.write("./auto_2d_plot.svg");
+
+  cout << "X min " << my_plot.x_range().first <<  ", X max " << my_plot.x_range().second << endl; 
+  cout << "Y min " << my_plot.y_range().first << ", Y max "  << my_plot.y_range().second << endl; 
+
+//] [/auto_2d_plot_2]
+
+	return 0;
+}
+
+/*
+//[auto_2d_plot_output
+
+Output:
+
+auto_2d_plot.cpp
+Linking...
+Embedding manifest...
+Autorun "j:\Cpp\SVG\debug\auto_2d_plot.exe"
+2 goods, 2.1 5.4
+3 goods, 7.3 9.1
+limit value: 99.99 1.#QNAN
+limit value: 999 1.#INF
+limit value: 999.9 1.#INF
+x_min 1.1, x_max 7.3
+y_min 3.2, y_max 9.1
+limits 3
+1 8
+3 10
+Build Time 0:21
+
+
+Linking...
+Embedding manifest...
+Autorun "j:\Cpp\SVG\debug\auto_2d_plot.exe"
+X min 1, X max 8
+Y min 3, Y max 10
+Build Time 0:03
+
+
+//] [/auto_2d_plot_output]
+
+
+Parked pro tem.
+
+
+// double tol100eps = 1000 * numeric_limits<double>::epsilon(); // suitable tight value.
+
+ // double axis_min_value; // Values to be updated by autoscale.
+ // double axis_max_value;
+ // double axis_tick_increment;
+ // int axis_ticks;
+
+ // multiset<double> my_set;
+	//// Initialize my_set with some entirely fictional data.
+ // my_set.insert(1.2);
+ // my_set.insert(2.3);
+ // my_set.insert(3.4);
+
+ // // Feed STL 1D container to scale_axis.
+ // scale_axis(my_set, &axis_min_value, &axis_max_value, &axis_tick_increment, &axis_ticks, false, tol100eps, 6, 0);
+
+*/