From af6e8f78292459bb1246ec993d0b8f581990d350 Mon Sep 17 00:00:00 2001
From: Peter Boyle <paboyle@ph.ed.ac.uk>
Date: Fri, 15 May 2015 11:41:31 +0100
Subject: [PATCH] Force inlining on ICPC because inline apparently is not
 enoguh

---
 lib/math/Grid_math_arith_sub.h | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/lib/math/Grid_math_arith_sub.h b/lib/math/Grid_math_arith_sub.h
index de4ef9e5..c359349f 100644
--- a/lib/math/Grid_math_arith_sub.h
+++ b/lib/math/Grid_math_arith_sub.h
@@ -14,14 +14,14 @@ namespace Grid {
 // Vector +/- Vector
 // Matrix +/- Matrix
 // Matrix /- scalar
-template<class vtype,class ltype,class rtype> inline void sub(iScalar<vtype> * __restrict__ ret,
+template<class vtype,class ltype,class rtype> strong_inline void sub(iScalar<vtype> * __restrict__ ret,
                                                               const iScalar<ltype> * __restrict__ lhs,
                                                               const iScalar<rtype> * __restrict__ rhs)
 {
     sub(&ret->_internal,&lhs->_internal,&rhs->_internal);
 }
 
-template<class vtype,class ltype,class rtype,int N> inline void sub(iVector<vtype,N> * __restrict__ ret,
+template<class vtype,class ltype,class rtype,int N> strong_inline void sub(iVector<vtype,N> * __restrict__ ret,
                                                                     const iVector<ltype,N> * __restrict__ lhs,
                                                                     const iVector<rtype,N> * __restrict__ rhs)
 {
@@ -30,7 +30,7 @@ template<class vtype,class ltype,class rtype,int N> inline void sub(iVector<vtyp
     }
     return;
 }
-template<class vtype,class ltype,class rtype, int N> inline void sub(iMatrix<vtype,N> * __restrict__ ret,
+template<class vtype,class ltype,class rtype, int N> strong_inline void sub(iMatrix<vtype,N> * __restrict__ ret,
                                                                      const iMatrix<ltype,N> * __restrict__ lhs,
                                                                      const iMatrix<rtype,N> * __restrict__ rhs){
     for(int c2=0;c2<N;c2++){
@@ -39,7 +39,7 @@ template<class vtype,class ltype,class rtype, int N> inline void sub(iMatrix<vty
     }}
     return;
 }
-template<class vtype,class ltype,class rtype, int N> inline void sub(iMatrix<vtype,N> * __restrict__ ret,
+template<class vtype,class ltype,class rtype, int N> strong_inline void sub(iMatrix<vtype,N> * __restrict__ ret,
                                                                      const iScalar<ltype> * __restrict__ lhs,
                                                                      const iMatrix<rtype,N> * __restrict__ rhs){
     for(int c2=0;c2<N;c2++){
@@ -55,7 +55,7 @@ template<class vtype,class ltype,class rtype, int N> inline void sub(iMatrix<vty
     }}
     return;
 }
-template<class vtype,class ltype,class rtype, int N> inline void sub(iMatrix<vtype,N> * __restrict__ ret,
+template<class vtype,class ltype,class rtype, int N> strong_inline void sub(iMatrix<vtype,N> * __restrict__ ret,
                                                                      const iMatrix<ltype,N> * __restrict__ lhs,
                                                                      const iScalar<rtype> * __restrict__ rhs){
     for(int c2=0;c2<N;c2++){
@@ -69,7 +69,7 @@ template<class vtype,class ltype,class rtype, int N> inline void sub(iMatrix<vty
 }
 
     // - operator for scalar, vector, matrix
-template<class ltype,class rtype> inline auto
+template<class ltype,class rtype> strong_inline auto
 operator - (const iScalar<ltype>& lhs, const iScalar<rtype>& rhs) -> iScalar<decltype(lhs._internal - rhs._internal)>
 {
     typedef iScalar<decltype(lhs._internal-rhs._internal)> ret_t;
@@ -78,7 +78,7 @@ operator - (const iScalar<ltype>& lhs, const iScalar<rtype>& rhs) -> iScalar<dec
     return ret;
 }
 template<class ltype,class rtype,int N>
-inline auto operator - (const iVector<ltype,N>& lhs,const iVector<rtype,N>& rhs) ->iVector<decltype(lhs._internal[0]-rhs._internal[0]),N>
+strong_inline auto operator - (const iVector<ltype,N>& lhs,const iVector<rtype,N>& rhs) ->iVector<decltype(lhs._internal[0]-rhs._internal[0]),N>
 {
     typedef iVector<decltype(lhs._internal[0]-rhs._internal[0]),N> ret_t;
     ret_t ret;
@@ -86,7 +86,7 @@ inline auto operator - (const iVector<ltype,N>& lhs,const iVector<rtype,N>& rhs)
     return ret;
 }
 template<class ltype,class rtype,int N>
-inline auto operator - (const iMatrix<ltype,N>& lhs,const iMatrix<rtype,N>& rhs) ->iMatrix<decltype(lhs._internal[0][0]-rhs._internal[0][0]),N>
+strong_inline auto operator - (const iMatrix<ltype,N>& lhs,const iMatrix<rtype,N>& rhs) ->iMatrix<decltype(lhs._internal[0][0]-rhs._internal[0][0]),N>
 {
     typedef iMatrix<decltype(lhs._internal[0][0]-rhs._internal[0][0]),N> ret_t;
     ret_t ret;
@@ -94,7 +94,7 @@ inline auto operator - (const iMatrix<ltype,N>& lhs,const iMatrix<rtype,N>& rhs)
     return ret;
 }
 template<class ltype,class rtype,int N>
-inline auto operator - (const iScalar<ltype>& lhs,const iMatrix<rtype,N>& rhs)->iMatrix<decltype(lhs._internal-rhs._internal[0][0]),N>
+strong_inline auto operator - (const iScalar<ltype>& lhs,const iMatrix<rtype,N>& rhs)->iMatrix<decltype(lhs._internal-rhs._internal[0][0]),N>
 {
     typedef iMatrix<decltype(lhs._internal-rhs._internal[0][0]),N> ret_t;
     ret_t ret;
@@ -102,7 +102,7 @@ inline auto operator - (const iScalar<ltype>& lhs,const iMatrix<rtype,N>& rhs)->
     return ret;
 }
 template<class ltype,class rtype,int N>
-inline auto operator - (const iMatrix<ltype,N>& lhs,const iScalar<rtype>& rhs)->iMatrix<decltype(lhs._internal[0][0]-rhs._internal),N>
+strong_inline auto operator - (const iMatrix<ltype,N>& lhs,const iScalar<rtype>& rhs)->iMatrix<decltype(lhs._internal[0][0]-rhs._internal),N>
 {
     typedef iMatrix<decltype(lhs._internal[0][0]-rhs._internal),N> ret_t;
     ret_t ret;