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

Subject: [Boost-commit] svn:boost r51060 - sandbox/SOC/2007/visualization/libs/svg_plot/example
From: pbristow_at_[hidden]
Date: 2009-02-06 12:33:55

Author: pbristow
Date: 2009-02-06 12:33:54 EST (Fri, 06 Feb 2009)
New Revision: 51060
URL: http://svn.boost.org/trac/boost/changeset/51060

Log:
New example of minmax and STL containers.
Added:
   sandbox/SOC/2007/visualization/libs/svg_plot/example/container_minmax.cpp   (contents, props changed)

Added: sandbox/SOC/2007/visualization/libs/svg_plot/example/container_minmax.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/visualization/libs/svg_plot/example/container_minmax.cpp	2009-02-06 12:33:54 EST (Fri, 06 Feb 2009)
@@ -0,0 +1,320 @@
+/*! \file container_minmax.cpp
+    \brief Finding minmax of an STL container.
+    \author Paul A Bristow 
+*/
+
+// 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)
+
+
+#ifdef _MSC_VER
+//#  pragma warning(disable : 4512) //  assignment operator could not be generated
+#endif
+
+#include <boost/algorithm/minmax_element.hpp>
+ using boost::minmax_element;
+ // minmax_element finds both min and max elements more efficiently than separately.
+
+#include <algorithm>
+  using std::min_element;
+  using std::max_element;
+
+#include <iostream> 
+  using std::cout;
+  using std::endl;
+
+#include <vector>
+  using std::vector;
+
+#include <utility>
+  using std::pair;
+
+#include <iterator> // for std::iterator_traits;
+  using std::iterator;
+  using std::iterator_traits;
+  using std::ostream_iterator;
+
+#include <set>
+  using std::multiset;
+
+#include <functional>
+  using std::multiplies;
+
+#include <limits>
+  using std::numeric_limits;
+
+//namespace detail
+//{
+
+  //std::ostream& operator<< (std::ostream&, const std::pair<double, double>&);
+  //template<class T1, class T2> std::ostream& operator<< (std::ostream&, std::pair<T1, T1>&);
+
+  template<class T1, class T2>
+  std::ostream& operator<< (std::ostream& os, const std::pair<T1, T2>& p)
+  { // Output a pair of values.
+         os << p.first << ", " << p.second;
+      // Outputs:  1.2, 3.4
+      return os;
+  } // std::ostream& operator<<
+
+  std::ostream& operator<< (std::ostream& os, const std::pair<double, double>& p)
+  { // Output a pair of double values.
+      int precision = os.precision(3); // Save & use rather than default precision(6)
+      os << p.first << ", " << p.second;
+      // Outputs:  1.2, 3.4
+      os.precision(precision); // Restore.
+      return os;
+  } // std::ostream& operator<<
+
+  // Maybe better as:
+  //template<typename charT, typename traits, typename T1, typename T2>
+  //inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& os, const std::pair<T1, T2>& p)
+  //{
+  //  return os << p.first << " " << p.second;
+  //}
+  //
+  //// Explicit double, double.
+  //template<typename charT, typename traits>
+  //inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& os, const std::pair<double, double>& p)
+  //{
+  //  return os << p.first << " " << p.second;
+  //}
+  // but OK for this purpose.
+//} // namespace detail
+
+
+template <typename T> // T an STL container: array, vector ...
+size_t show(const T& container)
+{ // Show all the containers values.
+  for (T::const_iterator it = container.begin(); it != container.end(); it++)
+  {
+    cout << *it << ' ';
+  }
+  cout << endl;
+  cout << container.size() << " values in container. " << endl;
+  return container.size();
+} // Container Data series to plot.
+
+//template <typename T> // T an STL container: container of containers.
+//size_t show_all(vector<T> containers)
+//{ // Show all the containers values.
+//  for (size_t i = 0; i < containers.size(); i++)
+//  {
+//    show(containers[i]);
+//  }
+//  return containers.size();
+//} // Container Data series to plot.
+
+template <typename T> // T an STL container: container of containers.
+size_t show_all(const T& containers)
+{ // Show all the containers values.
+  for (T::const_iterator it = containers.begin(); it != containers.end(); it++)
+  {
+    show(*it);
+  }
+  return containers.size();
+} // Container Data series to plot.
+
+// Pointer version is not needed - iterator version is used instead.
+//template <typename T> // T an STL container: array, vector ...
+//size_t show_part(T const* begin, T const* end) // pointers.
+//{
+//  int count = 0;
+//  while (begin != end)
+//  {
+//    count++;
+//    cout << *begin << ' ';
+//    ++begin;
+//  }
+//  cout << endl;
+//  cout << count << " values in container used. " << endl;
+//  return count;
+//}// Container Data series to plot.
+
+template <typename iter> // T an STL container: array, vector ...
+size_t show_part(iter begin, iter end) // Iterators.
+{// Show some or all of the containers values.
+  size_t count = 0;
+  while (begin != end)
+  {
+    count++;
+    cout << *begin << ' ';
+    ++begin;
+  }
+  cout << endl;
+  cout << count << " values in container used. " << endl;
+  return count;
+}// Container Data series to plot.
+
+
+// typedef std::iterator_traits<iter>::value_type would be double, etc
+
+template <typename iter> // into an STL container: array, vector, set ...
+pair<double, double> s(iter begin, iter end) // Data series to plot.
+{
+  iter it = min_element(begin, end);
+  cout << "min_element " << *it << endl;
+  pair<iter, iter> result = boost::minmax_element(begin, end);
+  //pair<const T::const_iterator, const T::const_iterator > result = boost::minmax_element(begin, end);
+  // error C2825: 'T': must be a class or namespace when followed by '::'
+  cout << "minmax_elements " << *result.first << ' ' << *result.second << endl;
+
+  pair<double, double > minmax;
+  minmax.first = *result.first;
+  minmax.second = *result.second;
+  return minmax; // pair<double, double>
+} // template <class T> int s  T an STL container: array, vector ...
+
+template <class T> // T an STL container: for example: array<float>, vector<double> ...
+pair<double, double> s(const T& container) // Data series to plot.
+{
+  pair<T::const_iterator, T::const_iterator> result = boost::minmax_element(container.begin(), container.end());
+  cout << "minmax_elements " << *result.first << ' ' << *result.second << endl;
+  pair<double, double > minmax; // Convert type of container T to double.
+  minmax.first = *result.first;
+  minmax.second = *result.second;
+  return minmax; // pair<double, double>
+} // template <class T> int s  T an STL container: array, vector ...
+
+template <class T> // T an STL container: array, vector ...
+pair<double, double> scale(const T& container) // Container Data series
+{
+  //typedef <const T& >::const_iterator container_iterator;
+  //pair< T, T > result = boost::minmax_element(container.begin(), container.end());
+  //pair< vector_iterator, vector_iterator > result = boost::minmax_element(container.begin(), container.end());
+  //cout << "Autoscale min is " << *(result.first) << endl;
+  //cout << "Max is  " << *(result.second) << endl;
+  //T::const_iterator it;
+  //it = min_element(container.begin(), container.end());
+  //cout << "min " << *it << endl;
+  //it = max_element(container.begin(), container.end());
+  //cout << "max " << *it << endl;
+
+  //pair<double, double> mm;
+  //mm.first= *(minmax_element(container.begin(), container.end()).first);
+  //mm.second= *(minmax_element(container.begin(), container.end()).second);
+  // But this calls minmax_element twice.
+
+  pair<T::const_iterator, T::const_iterator> result = boost::minmax_element(container.begin(), container.end());
+
+  pair<double, double> minmax;
+  minmax.first = *result.first;
+  minmax.second = *result.second;
+  return minmax;
+} // template <class T> int scale_axis,  T an STL container: array, vector  set, map ...
+
+template <class T> // T an STL container: array, vector, set, map ...
+pair<double, double> s_all(const T& containers) // Container of containers of Data series.
+{
+  pair<double, double> minmax(numeric_limits<double>::max(), numeric_limits<double>::min());
+  for (T::const_iterator it = containers.begin(); it != containers.end(); it++)
+  {
+    pair<double, double> mm = s(*it); // Scale of this container.
+    minmax.first = (std::min)(mm.first, minmax.first); //
+    minmax.second = (std::max)(mm.second, minmax.second);
+  }
+  return minmax;
+} // template <class T> int scale_axis,  T an STL container: array, vector ...
+
+int main()
+{
+	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]
+
+  vector<double> my_data_2;
+  // transform(my_data.begin(), my_data.end(), data2.begin(), bind1st(multiplies<double>(), 2.3));
+  copy(my_data.begin(), my_data.end(), back_inserter(my_data_2));
+  copy(my_data.begin(), my_data.end(), ostream_iterator<double>(cout, " "));
+  cout << endl << my_data.size() << " values in my_data. " << endl;
+  copy(my_data_2.begin(), my_data_2.end(), ostream_iterator<double>(cout, " "));
+  transform(my_data_2.begin(), my_data_2.end(), my_data_2.begin(), bind1st(multiplies<double>(), 2.3));
+  copy(my_data_2.begin(), my_data_2.end(), ostream_iterator<double>(cout, " "));
+
+  cout << endl << my_data.size() << " values in my_data. " << endl;
+
+  vector<vector<double> > my_containers;
+
+  my_containers.push_back(my_data);
+  my_containers.push_back(my_data_2);
+
+  cout << my_containers.size() << " containers." << endl;
+
+  show_all(my_containers);
+
+  cout << s_all(my_containers) << endl;
+
+
+
+  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 using two double min and max values.
+  double first_value = *(my_data.begin());
+  double last_value = *(--my_data.end());
+  cout << "First value " << first_value << ", last = " << last_value << endl;
+
+  // Using first and last in container,
+  // assuming the data are ordered in ascending value,
+  // either because they have been sorted, for vector or array,
+  // or by being sorted as inserted, for example, map, multimap.
+  //s(*my_data.begin(),*(--my_data.end()));
+
+  // Using two begin & end iterators into STL container,
+  pair<double, double> mm = s(my_data.begin(), my_data.end() );
+  cout << mm << endl;
+  cout << mm.first << ' ' << mm.second << endl;
+
+  // Using two begin & end pointer into STL container,
+  // scale_axis does finding min and max.
+  mm = s(&my_data[1], &my_data[4]); // Only middle part of the container used.
+
+  // Autoscaling using whole STL container,
+  // scale_axis does finding min and max.
+  mm = s(my_data); // Display range.
+
+  multiset<double> my_set;
+	// Initialize my_set with some entirely fictional data.
+  my_set.insert(2.3);
+  my_set.insert(7.8);
+  my_set.insert(3.4);
+  my_set.insert(4.5);
+  my_set.insert(1.2);
+  my_set.insert(5.6);
+  my_set.insert(6.7);
+  my_set.insert(8.9);
+  // Show the set.
+  multiset<double>::const_iterator si;
+  for (si = my_set.begin(); si != my_set.end(); si++)
+  {
+    cout << *si << ' ';
+  }
+  cout << endl;
+  cout << my_set.size() << " values in my_set. " << endl; // 8 values in my_set. 
+
+  mm = s(my_set); // Display range.
+  cout << mm << endl; //  1.2, 8.9
+  cout <<"first " << *my_set.begin()  << ", last " << *(--my_set.end()) << endl;
+
+
+
+	return 0;
+} // int main()
+
+/*
+
+
+
+*/
+