From: Richard Kreckel <kreckel@ginac.de>
Date: Sat, 7 Nov 2015 12:23:26 +0000 (+0100)
Subject: Remove C++89 workaround for closing angle brackets in nested templates.
X-Git-Tag: release_1-7-0~7^2~60
X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=commitdiff_plain;h=dfaa3383381a37f871cdd8ae7b19db579dddd83d

Remove C++89 workaround for closing angle brackets in nested templates.
---

diff --git a/check/time_hashmap.cpp b/check/time_hashmap.cpp
index 4d065b21..e7c1d258 100644
--- a/check/time_hashmap.cpp
+++ b/check/time_hashmap.cpp
@@ -82,10 +82,10 @@ unsigned time_hashmap()
 	for (vector<unsigned>::const_iterator i = sizes.begin(); i != sizes.end(); ++i) {
 		double time_insert, time_find, time_erase;
 
-		run_timing< exhashmap<ex> >(*i, time_insert, time_find, time_erase);
+		run_timing<exhashmap<ex>>(*i, time_insert, time_find, time_erase);
 
 // If you like, you can compare it with this:
-//		run_timing< std::map<ex, ex, ex_is_less> >(*i, time_insert, time_find, time_erase);
+//		run_timing<std::map<ex, ex, ex_is_less>>(*i, time_insert, time_find, time_erase);
 
 		times_insert.push_back(time_insert);
 		times_find.push_back(time_find);
diff --git a/doc/CodingStyle b/doc/CodingStyle
index 4ac0f189..e387bf29 100644
--- a/doc/CodingStyle
+++ b/doc/CodingStyle
@@ -208,12 +208,10 @@ after (or before, in the case of postfix '++' and '--') unary operators:
 	x = -(y + z) / 2;
 
 There are no spaces around the '<' and '>' used to designate template
-parameters. Unfortunately, a design flaw in C++ requires putting a space
-between two consecutive closing '>'s. We suggest that in this case you also
-put a space after the opening '<':
+parameters:
 
 	vector<int> vi;
-	vector< list<int> > vli;
+	vector<list<int>> vli;
 
 '*' and '&' in the declaration of pointer-to and reference-to variables
 have a space before, but not after them:
diff --git a/doc/examples/lanczos.cpp b/doc/examples/lanczos.cpp
index d1dce8c1..627bb3f8 100644
--- a/doc/examples/lanczos.cpp
+++ b/doc/examples/lanczos.cpp
@@ -66,7 +66,7 @@ using namespace cln;
  * Chebyshev polynomial coefficient matrix as far as is required for
  * the Lanczos approximation.
  */
-void calc_chebyshev(vector<vector<cl_I> >& C, const size_t size)
+void calc_chebyshev(vector<vector<cl_I>>& C, const size_t size)
 {	
 	C.reserve(size);
 	for (size_t i=0; i<size; ++i)
@@ -85,7 +85,7 @@ void calc_chebyshev(vector<vector<cl_I> >& C, const size_t size)
 /*
  * The coefficients p_n(g) that occur in the Lanczos approximation.
  */
-const cl_F p(const size_t k, const cl_F& g, const vector<vector<cln::cl_I> >& C)
+const cl_F p(const size_t k, const cl_F& g, const vector<vector<cln::cl_I>>& C)
 {	
 	const float_format_t prec = float_format(g);
 	const cl_F sqrtPi = sqrt(pi(prec));
@@ -110,7 +110,7 @@ const cl_F p(const size_t k, const cl_F& g, const vector<vector<cln::cl_I> >& C)
 void calc_lanczos_coeffs(vector<cl_F>& lanc, const cln::cl_F& g)
 {	
 	const size_t n = lanc.size();
-	vector<vector<cln::cl_I> > C;
+	vector<vector<cln::cl_I>> C;
 	calc_chebyshev(C, 2*n+2);
 	
 	// \Pi_{i=1}^n (z-i+1)/(z+i) = \Pi_{i=1}^n (1 - (2i-1)/(z+i))
@@ -118,7 +118,7 @@ void calc_lanczos_coeffs(vector<cl_F>& lanc, const cln::cl_F& g)
 	// Q[1/(z+1),...1/(z+n)] of degree 1. To store coefficients of this
 	// polynomial we use vector<cl_I>, so the set of such polynomials is
 	// stored as
-	vector<vector<cln::cl_I> > fractions(n);
+	vector<vector<cln::cl_I>> fractions(n);
 	
 	// xi = 1/(z+i)
 	fractions[0] = vector<cl_I>(1);
diff --git a/ginac/container.h b/ginac/container.h
index 3c1ac47e..5ba09434 100644
--- a/ginac/container.h
+++ b/ginac/container.h
@@ -38,7 +38,7 @@
 namespace GiNaC {
 
 /** Helper template for encapsulating the reserve() mechanics of STL containers. */
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 class container_storage {
 protected:
 	typedef C<ex> STLT;
@@ -124,7 +124,7 @@ private:
 };
 
 /** Wrapper template for making GiNaC classes out of STL containers. */
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 class container : public basic, public container_storage<C> {
 	GINAC_DECLARE_REGISTERED_CLASS(container, basic)
 protected:
@@ -493,21 +493,21 @@ protected:
 };
 
 /** Default constructor */
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 container<C>::container()
 {
 	setflag(get_default_flags());
 }
 
 
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 void container<C>::do_print(const print_context & c, unsigned level) const
 {
 	// always print brackets around seq, ignore upper_precedence
 	printseq(c, get_open_delim(), ',', get_close_delim(), precedence(), precedence()+1);
 }
 
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 void container<C>::do_print_tree(const print_tree & c, unsigned level) const
 {
 	c.s << std::string(level, ' ') << class_name() << " @" << this
@@ -522,20 +522,20 @@ void container<C>::do_print_tree(const print_tree & c, unsigned level) const
 	c.s << std::string(level + c.delta_indent,' ') << "=====" << std::endl;
 }
 
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 void container<C>::do_print_python(const print_python & c, unsigned level) const
 {
 	printseq(c, '[', ',', ']', precedence(), precedence()+1);
 }
 
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 void container<C>::do_print_python_repr(const print_python_repr & c, unsigned level) const
 {
 	c.s << class_name();
 	printseq(c, '(', ',', ')', precedence(), precedence()+1);
 }
 
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 ex container<C>::op(size_t i) const
 {
 	GINAC_ASSERT(i < nops());
@@ -545,7 +545,7 @@ ex container<C>::op(size_t i) const
 	return *it;
 }
 
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 ex & container<C>::let_op(size_t i)
 {
 	GINAC_ASSERT(i < nops());
@@ -556,7 +556,7 @@ ex & container<C>::let_op(size_t i)
 	return *it;
 }
 
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 ex container<C>::eval(int level) const
 {
 	if (level == 1)
@@ -565,7 +565,7 @@ ex container<C>::eval(int level) const
 		return thiscontainer(evalchildren(level));
 }
 
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 ex container<C>::subs(const exmap & m, unsigned options) const
 {
 	// After having subs'ed all children, this method subs'es one final
@@ -579,12 +579,12 @@ ex container<C>::subs(const exmap & m, unsigned options) const
 	STLT subsed = subschildren(m, options);
 	if (!subsed.empty()) {
 		ex result(thiscontainer(subsed));
-		if (is_a<container<C> >(result))
+		if (is_a<container<C>>(result))
 			return ex_to<basic>(result).subs_one_level(m, options);
 		else
 			return result;
 	} else {
-		if (is_a<container<C> >(*this))
+		if (is_a<container<C>>(*this))
 			return subs_one_level(m, options);
 		else
 			return *this;
@@ -592,7 +592,7 @@ ex container<C>::subs(const exmap & m, unsigned options) const
 }
 
 /** Compare two containers of the same type. */
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 int container<C>::compare_same_type(const basic & other) const
 {
 	GINAC_ASSERT(is_a<container>(other));
@@ -611,7 +611,7 @@ int container<C>::compare_same_type(const basic & other) const
 	return (it1 == it1end) ? (it2 == it2end ? 0 : -1) : 1;
 }
 
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 bool container<C>::is_equal_same_type(const basic & other) const
 {
 	GINAC_ASSERT(is_a<container>(other));
@@ -631,7 +631,7 @@ bool container<C>::is_equal_same_type(const basic & other) const
 }
 
 /** Add element at front. */
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 container<C> & container<C>::prepend(const ex & b)
 {
 	ensure_if_modifiable();
@@ -640,7 +640,7 @@ container<C> & container<C>::prepend(const ex & b)
 }
 
 /** Add element at back. */
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 container<C> & container<C>::append(const ex & b)
 {
 	ensure_if_modifiable();
@@ -649,7 +649,7 @@ container<C> & container<C>::append(const ex & b)
 }
 
 /** Remove first element. */
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 container<C> & container<C>::remove_first()
 {
 	ensure_if_modifiable();
@@ -658,7 +658,7 @@ container<C> & container<C>::remove_first()
 }
 
 /** Remove last element. */
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 container<C> & container<C>::remove_last()
 {
 	ensure_if_modifiable();
@@ -667,7 +667,7 @@ container<C> & container<C>::remove_last()
 }
 
 /** Remove all elements. */
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 container<C> & container<C>::remove_all()
 {
 	ensure_if_modifiable();
@@ -676,7 +676,7 @@ container<C> & container<C>::remove_all()
 }
 
 /** Sort elements. */
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 container<C> & container<C>::sort()
 {
 	ensure_if_modifiable();
@@ -691,7 +691,7 @@ template<> inline void container<std::list>::unique_()
 }
 
 /** Remove adjacent duplicate elements. */
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 container<C> & container<C>::unique()
 {
 	ensure_if_modifiable();
@@ -700,7 +700,7 @@ container<C> & container<C>::unique()
 }
 
 /** Print sequence of contained elements. */
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 void container<C>::printseq(const print_context & c, char openbracket, char delim,
                             char closebracket, unsigned this_precedence,
                             unsigned upper_precedence) const
@@ -723,7 +723,7 @@ void container<C>::printseq(const print_context & c, char openbracket, char deli
 		c.s << closebracket;
 }
 
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 typename container<C>::STLT container<C>::evalchildren(int level) const
 {
 	if (level == 1)
@@ -744,7 +744,7 @@ typename container<C>::STLT container<C>::evalchildren(int level) const
 	return s;
 }
 
-template <template <class T, class = std::allocator<T> > class C>
+template <template <class T, class = std::allocator<T>> class C>
 typename container<C>::STLT container<C>::subschildren(const exmap & m, unsigned options) const
 {
 	// returns an empty container if nothing had to be substituted
diff --git a/ginac/ex.h b/ginac/ex.h
index e27abe50..8512a4c7 100644
--- a/ginac/ex.h
+++ b/ginac/ex.h
@@ -542,7 +542,7 @@ public:
 	}
 
 private:
-	std::stack<internal::_iter_rep, std::vector<internal::_iter_rep> > s;
+	std::stack<internal::_iter_rep, std::vector<internal::_iter_rep>> s;
 
 	void increment()
 	{
@@ -607,7 +607,7 @@ public:
 	}
 
 private:
-	std::stack<internal::_iter_rep, std::vector<internal::_iter_rep> > s;
+	std::stack<internal::_iter_rep, std::vector<internal::_iter_rep>> s;
 
 	void descend()
 	{
diff --git a/ginac/factor.cpp b/ginac/factor.cpp
index 5ff3cd38..33b8f501 100644
--- a/ginac/factor.cpp
+++ b/ginac/factor.cpp
@@ -118,7 +118,7 @@ ostream& operator<<(ostream& o, const vector<numeric>& v)
 	}
 	return o;
 }
-ostream& operator<<(ostream& o, const vector< vector<cl_MI> >& v)
+ostream& operator<<(ostream& o, const vector<vector<cl_MI>>& v)
 {
 	auto i = v.begin(), end = v.end();
 	while ( i != end ) {
@@ -1462,7 +1462,7 @@ private:
 	}
 private:
 	umodpoly lr[2];
-	vector< vector<umodpoly> > cache;
+	vector<vector<umodpoly>> cache;
 	upvec factors;
 	umodpoly one;
 	size_t n;
diff --git a/ginac/inifcns_nstdsums.cpp b/ginac/inifcns_nstdsums.cpp
index eb98d7a9..54d12c9b 100644
--- a/ginac/inifcns_nstdsums.cpp
+++ b/ginac/inifcns_nstdsums.cpp
@@ -102,7 +102,7 @@ namespace {
 
 // lookup table for factors built from Bernoulli numbers
 // see fill_Xn()
-std::vector<std::vector<cln::cl_N> > Xn;
+std::vector<std::vector<cln::cl_N>> Xn;
 // initial size of Xn that should suffice for 32bit machines (must be even)
 const int xninitsizestep = 26;
 int xninitsize = xninitsizestep;
@@ -1779,7 +1779,7 @@ namespace {
 
 // lookup table for special Euler-Zagier-Sums (used for S_n,p(x))
 // see fill_Yn()
-std::vector<std::vector<cln::cl_N> > Yn;
+std::vector<std::vector<cln::cl_N>> Yn;
 int ynsize = 0; // number of Yn[]
 int ynlength = 100; // initial length of all Yn[i]
 
@@ -3547,7 +3547,7 @@ static void initcX(std::vector<cln::cl_N>& crX,
 
 	int Sm = 0;
 	int Smp1 = 0;
-	std::vector<std::vector<cln::cl_N> > crG(s.size() - 1, std::vector<cln::cl_N>(L2 + 1));
+	std::vector<std::vector<cln::cl_N>> crG(s.size() - 1, std::vector<cln::cl_N>(L2 + 1));
 	for (int m=0; m < (int)s.size() - 1; m++) {
 		Sm += s[m];
 		Smp1 = Sm + s[m+1];
@@ -3587,12 +3587,12 @@ static cln::cl_N crandall_Y_loop(const cln::cl_N& Sqk,
 
 
 // [Cra] section 4
-static void calc_f(std::vector<std::vector<cln::cl_N> >& f_kj,
+static void calc_f(std::vector<std::vector<cln::cl_N>>& f_kj,
 	           const int maxr, const int L1)
 {
 	cln::cl_N t0, t1, t2, t3, t4;
 	int i, j, k;
-	std::vector<std::vector<cln::cl_N> >::iterator it = f_kj.begin();
+	std::vector<std::vector<cln::cl_N>>::iterator it = f_kj.begin();
 	cln::cl_F one = cln::cl_float(1, cln::float_format(Digits));
 	
 	t0 = cln::exp(-lambda);
@@ -3616,7 +3616,7 @@ static void calc_f(std::vector<std::vector<cln::cl_N> >& f_kj,
 
 // [Cra] (3.1)
 static cln::cl_N crandall_Z(const std::vector<int>& s,
-	                    const std::vector<std::vector<cln::cl_N> >& f_kj)
+	                    const std::vector<std::vector<cln::cl_N>>& f_kj)
 {
 	const int j = s.size();
 
@@ -3693,7 +3693,7 @@ cln::cl_N zeta_do_sum_Crandall(const std::vector<int>& s)
 		}
 	}
 
-	std::vector<std::vector<cln::cl_N> > f_kj(L1);
+	std::vector<std::vector<cln::cl_N>> f_kj(L1);
 	calc_f(f_kj, maxr, L1);
 
 	const cln::cl_N r0factorial = cln::factorial(r[0]-1);
diff --git a/ginac/polynomial/collect_vargs.h b/ginac/polynomial/collect_vargs.h
index f2e55711..b1bb64b3 100644
--- a/ginac/polynomial/collect_vargs.h
+++ b/ginac/polynomial/collect_vargs.h
@@ -56,7 +56,7 @@ static inline bool zerop(const exp_vector_t& v)
 	return true;
 }
 
-typedef std::vector<std::pair<exp_vector_t, ex> > ex_collect_t;
+typedef std::vector<std::pair<exp_vector_t, ex>> ex_collect_t;
 
 extern void
 collect_vargs(ex_collect_t& ec, const ex& e, const exvector& x);
diff --git a/ginac/ptr.h b/ginac/ptr.h
index 5911dd67..76c3ee7e 100644
--- a/ginac/ptr.h
+++ b/ginac/ptr.h
@@ -54,7 +54,7 @@ private:
  *      from refcounted)
  *    T* T::duplicate() member function (only if makewriteable() is used) */
 template <class T> class ptr {
-	friend class std::less< ptr<T> >;
+	friend class std::less<ptr<T>>;
 
 	// NB: This implementation of reference counting is not thread-safe.
 	// The reference counter needs to be incremented/decremented atomically,
@@ -155,7 +155,7 @@ namespace std {
 
 /** Specialization of std::less for ptr<T> to enable ordering of ptr<T>
  *  objects (e.g. for the use as std::map keys). */
-template <class T> struct less< GiNaC::ptr<T> >
+template <class T> struct less<GiNaC::ptr<T>>
  : public binary_function<GiNaC::ptr<T>, GiNaC::ptr<T>, bool> {
 	bool operator()(const GiNaC::ptr<T> &lhs, const GiNaC::ptr<T> &rhs) const
 	{
diff --git a/ginac/registrar.h b/ginac/registrar.h
index cb351716..5c97e6d1 100644
--- a/ginac/registrar.h
+++ b/ginac/registrar.h
@@ -36,7 +36,7 @@ namespace GiNaC {
 class ex;
 class archive_node;
 
-template <template <class T, class = std::allocator<T> > class> class container;
+template <template <class T, class = std::allocator<T>> class> class container;
 typedef container<std::list> lst;
 
 /** To distinguish between different kinds of non-commutative objects */