1. refactor Global_Func::find()

2. fix bug in Parallel_LRI_Equally_Filter::get_list_Ab2()

Author: PeizeLin

include/RI/global/Global_Func-1.h

@@ -7,6 +7,7 @@
 
 #include "Tensor.h"
 
+#include <vector>
 #include <map>
 #include <set>
 #include <array>
@@ -17,54 +18,67 @@ namespace RI
 
 namespace Global_Func
 {
+	template<typename T> const T ZERO{};
+
 	// tensor = find(m,i,j,k);
 	//   <=>
 	// tensor = m.at(i).at(j).at(k);
 	// Peize Lin add 2022.05.26
 	template<typename Tkey, typename Tdata,
 		typename std::enable_if<std::is_arithmetic<Tdata>::value,bool>::type=0>
-	inline Tdata find(
+	inline const Tdata &find(
 		const std::map<Tkey, Tdata> &m,
 		const Tkey &key)
 	{
-		const auto ptr = m.find(key);
+		const auto &ptr = m.find(key);
 		if(ptr==m.end())
-			return 0;
+			return ZERO<Tdata>;
 		else
 			return ptr->second;
 	}
 	template<typename Tkey, typename Tdata>
-	inline Tensor<Tdata> find(
+	inline const Tensor<Tdata> &find(
 		const std::map<Tkey, Tensor<Tdata>> &m,
 		const Tkey &key)
 	{
-		const auto ptr = m.find(key);
+		const auto &ptr = m.find(key);
 		if(ptr==m.end())
-			return Tensor<Tdata>{};
+			return ZERO<Tensor<Tdata>>;
 		else
 			return ptr->second;
 	}
 	template<typename Tkey, typename Tdata, std::size_t Ndim>
-	inline std::array<Tdata,Ndim> find(
+	inline const std::array<Tdata,Ndim> &find(
 		const std::map<Tkey, std::array<Tdata,Ndim>> &m,
 		const Tkey &key)
 	{
-		const auto ptr = m.find(key);
+		const auto &ptr = m.find(key);
+		if(ptr==m.end())
+			return ZERO<std::array<Tdata,Ndim>>;
+		else
+			return ptr->second;
+	}
+	template<typename Tkey, typename Tdata>
+	inline const std::vector<Tdata> &find(
+		const std::map<Tkey, std::vector<Tdata>> &m,
+		const Tkey &key)
+	{
+		const auto &ptr = m.find(key);
 		if(ptr==m.end())
-			return std::array<Tdata,Ndim>{};
+			return ZERO<std::vector<Tdata>>;
 		else
 			return ptr->second;
 	}
-	template<typename Tkey, typename Tvalue, typename... Tkeys>
-	inline auto find(
-		const std::map<Tkey, Tvalue> &m,
-		const Tkey &key,
+	template<typename Tkey0, typename Tkey1, typename Tvalue, typename... Tkeys>
+	inline const auto &find(
+		const std::map<Tkey0, std::map<Tkey1,Tvalue>> &m,
+		const Tkey0 &key0,
 		const Tkeys&... keys)
 //	-> decltype(find( m.find(key)->second, keys... ))			// why error for C++ compiler high version
 	{
-		const auto ptr = m.find(key);
+		const auto &ptr = m.find(key0);
 		if(ptr==m.end())
-			return decltype(find( ptr->second, keys... )){};
+			return ZERO<typename std::remove_reference<decltype(find( ptr->second, keys... ))>::type>;
 		else
 			return find( ptr->second, keys... );
 	}

include/RI/global/Tensor-multiply.hpp

@@ -53,8 +53,8 @@ Tensor<T> operator* (const Tensor<T> &t1, const Tensor<T> &t2)
 					assert(t1.shape[0] == t2.shape[0]);
 					return Blas_Interface::gemv('T', T(1), t2, t1);
 				}
-				default:;
-					throw std::invalid_argument(std::string(__FILE__)+" line "+std::to_string(__LINE__));
+				default:
+					throw std::invalid_argument("Tensor multiply:\t"+std::to_string(t1.shape.size())+" * "+std::to_string(t2.shape.size())+".\n"+std::string(__FILE__)+" line "+std::to_string(__LINE__));
 			}
 		}
 		case 2:
@@ -72,11 +72,11 @@ Tensor<T> operator* (const Tensor<T> &t1, const Tensor<T> &t2)
 					return Blas_Interface::gemm('N', 'N', T(1), t1, t2);
 				}
 				default:
-					throw std::invalid_argument(std::string(__FILE__)+" line "+std::to_string(__LINE__));
+					throw std::invalid_argument("Tensor multiply:\t"+std::to_string(t1.shape.size())+" * "+std::to_string(t2.shape.size())+".\n"+std::string(__FILE__)+" line "+std::to_string(__LINE__));
 			}
 		}
 		default:
-			throw std::invalid_argument(std::string(__FILE__)+" line "+std::to_string(__LINE__));
+			throw std::invalid_argument("Tensor multiply:\t"+std::to_string(t1.shape.size())+" * "+std::to_string(t2.shape.size())+".\n"+std::string(__FILE__)+" line "+std::to_string(__LINE__));
 	}
 }
 

include/RI/global/Tensor_Algorithm.hpp

@@ -90,8 +90,8 @@ namespace Tensor_Algorithm
 		}
 
 		Tensor<T> em({m.shape[0], m.shape[1]});
-		int ie=0;
-		for( int i=0; i!=m.shape[0]; ++i )
+		std::size_t ie=0;
+		for( std::size_t i=0; i<m.shape[0]; ++i )
 			if( std::abs(eigen_values[i]) >= threshold )
 			{
 				Blas_Interface::axpy(m.shape[1], T(1.0)/eigen_values[i], m.ptr()+i*m.shape[1], em.ptr()+ie*em.shape[1]);

include/RI/parallel/Parallel_LRI_Equally_Filter.h

@@ -20,7 +20,7 @@ class Parallel_LRI_Equally_Filter: public Parallel_LRI_Equally<TA,Tcell,Ndim,Tda
 
 	const std::vector<TAC>& get_list_Ab2 (const TA &Aa01, const TAC &Aa2, const TAC &Ab01) const override
 	{
-		return this->list_Ab2_filter.at(Ab01);
+		return Global_Func::find(this->list_Ab2_filter,Ab01);
 	}
 
 	void filter_Ab2 (const std::map<TA, std::map<TAC, Tensor<Tdata>>> &Ds_b);