template stringlengths 20 4.72k |
|---|
template <typename T, typename U, typename... Args>
constexpr std::size_t
CalcBufSize() noexcept
{
return CalcBufSize<T>() + CalcBufSize<U, Args...>();
} |
template <typename T>
auto
ExtractParams(std::byte* buf)
{
#ifdef PROXY_DEBUG
PROXY_LOG(DBG) << "ExtractParams: " << buf << std::endl;
#endif
T tup;
static_assert(std::tuple_size<T>::value < 17);
chan_sz_ = SZ;
ExtractElem<0> (tup, buf);
ExtractElem<1> (tup, b... |
template <typename... Args>
void
SendRequest(Args... args)
{
if constexpr (sizeof...(Args) > 0)
Unroll(gsl::make_not_null(std::data(GetSendChannel())), SZ, args...);
Switch();
} |
template <typename T>
auto
ExtractParams()
{
#ifdef PROXY_DEBUG
PROXY_LOG(DBG) << ((side_ == kParent) ? "Parent" : "Child")
<< " is waiting for its turn" << std::endl;
#endif
Wait();
if (side_ == kChild && segment_.HangUpRequested()) {
#ifdef PROXY_DEBUG
... |
template <typename... Args>
void
SendRequest(Args... args)
{
segd_.SendRequest(args...);
} |
template <typename R>
auto
ExtractParams()
{
auto rt = segd_.template ExtractParams<std::tuple<R>>();
R r = std::get<0>(rt);
return r;
} |
template<typename Proxy, std::size_t SZX, typename RET, typename... Args>
void
AbstractProxyWorkLoopWrapper(Proxy proxy, SegmentDescriptor<SZX>* segd)
{
proxy->template StartServiceLoop<RET, Args...>(segd);
} |
template<typename RET, typename... Args>
void
StartServiceLoop(SegmentDescriptor<SZ>* segd) noexcept
{
#ifdef PROXY_DEBUG
PROXY_LOG(DBG) << "Starting Service Loop." << std::endl;
#endif
while (true) {
try {
auto ins = segd->template ExtractParams<std::tuple<Args..... |
template<typename SFUNC>
void
SendNewChannelInfo(int segfd, int sndfd, int rcvfd, SFUNC service_func) const
{
Command cmd;
cmd.service_func = reinterpret_cast<void*>(service_func);
cmd.code = kNewChannel;
msghdr msg;
iovec iov[1];
iov[0].iov_base = &cmd;
... |
template <typename RET, typename... Args>
RET
Execute(Args... args)
{
/**
* Compile-time check to ensure that the selected buffer size SZ is
* sufficient for the provided argument and return types.
*/
if constexpr (sizeof...(Args) > 0)
static_assert(Cal... |
template <typename RET, typename... Args>
RET
Stop(Args... args)
{
if (status_ != kProxyActive)
throw InvalidProxyState{};
ExecuteInternal<RET, Args...>(kStop, args...);
return RET{};
} |
template <typename RET, typename... Args>
RET
Shutdown(Args... args) {
if (status_ != kProxyActive)
throw InvalidProxyState{};
status_ = kProxyShutDown;
ExecuteInternal<RET, Args...>(kShutDown, args...);
return RET{};
} |
template<typename RET, typename REQ>
RET
Do(REQ& ins)
{
return service_.Handle(ins);
} |
template<typename RET, typename REQ>
RET
Do(REQ& ins)
{
using namespace detail;
using ARGS = typename remove_first_type<REQ>::type;
using func_type = RET (*)(ARGS);
auto func_name = std::get<0>(ins);
func_type func_ptr;
auto func_iter = funcs_.find(func_name);... |
template <typename SpecificArmor_t>
const ItemProfileThin MakeArmorSpecific(
const SpecificArmor_t SPECIFIC_ARMOR_TYPE,
const misc_type::Enum MISC_TYPE = misc_type::Not) const
{
return ItemProfileThin(armor::ArmorTypeWrapper(SPECIFIC_ARMOR_TYPE), MISC_TYPE);
... |
template <typename SpecificArmorEnum_t>
const ItemProfileThinVec_t MakeArmorSpecificAll() const
{
ItemProfileThinVec_t thinProfiles;
thinProfiles.reserve(static_cast<std::size_t>(SpecificArmorEnum_t::Count));
for (EnumUnderlying_t i(0); i < SpecificArmorEnum_t:... |
template <typename SpecificWeapon_t>
const ItemProfileThin MakeWeaponSpecific(
const SpecificWeapon_t SPECIFIC_WEAPON_TYPE,
const misc_type::Enum MISC_TYPE = misc_type::Not) const
{
return MakeWeapon(weapon::WeaponTypeWrapper(SPECIFIC_WEAPON_TYPE), MISC_TYPE);
... |
template <typename SpecificWeaponEnum_t>
const ItemProfileThinVec_t MakeWeaponSpecificAll() const
{
ItemProfileThinVec_t thinProfiles;
thinProfiles.reserve(static_cast<std::size_t>(SpecificWeaponEnum_t::Count));
for (EnumUnderlying_t i(0); i < SpecificWeaponEnu... |
template <class Real>
IntpTricubic3<Real>::IntpTricubic3 (int iXBound, int iYBound, int iZBound,
Real fXMin, Real fXSpacing, Real fYMin, Real fYSpacing, Real fZMin,
Real fZSpacing, Real*** aaafF, bool bCatmullRom)
{
// At least a 4x4x4 block of data points are needed to construct the
// tricubic interpo... |
template <class Real>
int IntpTricubic3<Real>::GetXBound () const
{
return m_iXBound;
} |
template <class Real>
int IntpTricubic3<Real>::GetYBound () const
{
return m_iYBound;
} |
template <class Real>
int IntpTricubic3<Real>::GetZBound () const
{
return m_iZBound;
} |
template <class Real>
int IntpTricubic3<Real>::GetQuantity () const
{
return m_iQuantity;
} |
template <class Real>
Real*** IntpTricubic3<Real>::GetF () const
{
return m_aaafF;
} |
template <class Real>
Real IntpTricubic3<Real>::GetXMin () const
{
return m_fXMin;
} |
template <class Real>
Real IntpTricubic3<Real>::GetXMax () const
{
return m_fXMax;
} |
template <class Real>
Real IntpTricubic3<Real>::GetXSpacing () const
{
return m_fXSpacing;
} |
template <class Real>
Real IntpTricubic3<Real>::GetYMin () const
{
return m_fYMin;
} |
template <class Real>
Real IntpTricubic3<Real>::GetYMax () const
{
return m_fYMax;
} |
template <class Real>
Real IntpTricubic3<Real>::GetYSpacing () const
{
return m_fYSpacing;
} |
template <class Real>
Real IntpTricubic3<Real>::GetZMin () const
{
return m_fZMin;
} |
template <class Real>
Real IntpTricubic3<Real>::GetZMax () const
{
return m_fZMax;
} |
template <class Real>
Real IntpTricubic3<Real>::GetZSpacing () const
{
return m_fZSpacing;
} |
template <typename T> std::string vector_to_string (std::vector<T> v) {
std::stringstream ss;
for(size_t i = 0; i < v.size(); ++i)
{
if(i != 0)
ss << ",";
ss << v[i];
}
std::string s = ss.str();
return s;
} |
template<class T, size_t (T::*)() const = &T::size>
size_t get_size(T const& t)
{
return t.size();
} |
template<class T, size_t (T::*) = &T::size>
size_t get_size(T const& t)
{
return t.size;
} |
template<class Lut>
OCIO_SHARED_PTR<Lut> HandleLUT(const OCIO_SHARED_PTR<Lut> & fileLut,
Interpolation fileInterp,
bool & fileInterpUsed)
{
OCIO_SHARED_PTR<Lut> lut;
if (fileLut)
{
const bool valid = Lut::IsValidInterpolation(fileInterp);... |
template <class T>
void galapagos::kernel<T>::set_func(void (* _func)(short, interface <T>*, interface <T>*)){
func = _func;
} |
template <class T>
void galapagos::kernel<T>::start(){
t = std::make_unique< std::thread>(func, id, &s_axis, &m_axis);
logger->info("Started Kernel:{0:d}", id);
} |
template <class T>
void galapagos::kernel<T>::barrier(){
t.get()->join();
logger->info("Passed Barrier in Kernel {0:d}", id);
} |
template <class T>
galapagos::interface <T> * galapagos::kernel<T>::get_s_axis(){
return &s_axis;
} |
template <class T>
galapagos::interface <T> * galapagos::kernel<T>::get_m_axis(){
return &m_axis;
} |
template<typename datatype_t, typename RegionEncoderT, typename BinningSpecificationT>
boost::shared_ptr< BinnedIndex >
IndexBuilder< datatype_t, RegionEncoderT, BinningSpecificationT >::build_index(const Dataset &data) {
return this->build_index(data, GridSubset(data.get_grid()));
} |
template <class EventT>
void dispatch(const EventT& event)
{
this->m_state = Reducer(this->m_state, event);
for (auto listener : this->m_listeners) {
listener();
}
} |
template <class EventT>
void dispatch(const EventT& event)
{
this->m_state = std::make_unique<StateT>(
Reducer(*this->m_state, event)
);
for (auto listener : this->m_listeners) {
listener();
}
} |
template<typename Function>
void generate_test(int seed, int n, Function element_generator) {
srand(seed);
vector<int> values;
vector<int64> sum(n);
for (int i = 0; i < n; ++i) {
values.push_back(element_generator());
}
sort(values.begin(), values.end());
sum[0] = 1LL * values[0... |
template<typename system_type, typename state_type>
std::pair<double, state_type> HenonTrick(const system_type& system,
CrossingParameters params) {
std::pair<unsigned int, unsigned int> dimensionality = system.GetDimension();
// dimensionality.second is the dimension of eac... |
template<typename system_type, typename state_type = std::vector<double>>
std::pair<double, state_type> IntegrateToCrossing(system_type& system,
double dt,
CrossingParameters params) {
return IntegrateToCrossingConditi... |
template<typename system_type, typename condition_func,
typename state_type = std::vector<double>>
std::pair<double, state_type> IntegrateToCrossingConditional(
system_type& system, double dt, condition_func&& condition,
CrossingParameters params) {
std::pair<unsigned int, unsigned int> dimensionalit... |
template <class T>
int binsearch(const T array[], int len, T what)
{
if (len == 0) return -1;
int mid = len / 2;
if (array[mid] == what) return mid;
if (array[mid] < what) {
int result = binsearch(array+mid+1, len-(mid+1), what);
if (result == -1) return -1;
else return result + mid+1;
}
if (arr... |
template <std::size_t N>
void interpreter::check_number_operands(
const Token &tok, std::array<std::reference_wrapper<std::any>, N> exprs) {
if (all_of(exprs.begin(), exprs.end(),
[](const std::reference_wrapper<std::any> &expr) {
return expr.get().type() == typeid(double);
... |
template<std::size_t N> requires ( N != 0 )
static void increment(Tuple& t) {
++std::get<N>(t);
increment<N-1>(t);
} |
template<std::size_t N> requires ( N == 0 )
static void increment(Tuple& t) {
++std::get<N>(t);
} |
template<std::size_t N> requires ( N != 0 )
static void decrement(Tuple& t) {
--std::get<N>(t);
decrement<N-1>(t);
} |
template<std::size_t N> requires ( N == 0 )
static void decrement(Tuple& t) {
--std::get<N>(t);
} |
template<std::size_t N, std::integral I> requires ( N != 0 )
static void add_in_place(Tuple& t, const I& ii) {
std::get<N>(t) += ii;
add_in_place<N-1>(t,ii);
} |
template<std::size_t N, std::integral I> requires ( N == 0 )
static void add_in_place(Tuple& t, const I& ii) {
std::get<N>(t) += ii;
} |
template<std::size_t N, std::integral I> requires ( N != 0 )
static void sub_in_place(Tuple& t, const I& ii) {
std::get<N>(t) -= ii;
sub_in_place<N-1>(t,ii);
} |
template<std::size_t N, std::integral I> requires ( N == 0 )
static void sub_in_place(Tuple& t, const I& ii) {
std::get<N>(t) -= ii;
} |
template<class Tuple>
void increment_tuple(Tuple& t){
IteratorTupleHelper<Tuple>::template increment<std::tuple_size<Tuple>::value-1>(t);
} |
template<class Tuple>
void decrement_tuple(Tuple& t){
IteratorTupleHelper<Tuple>::template decrement<std::tuple_size<Tuple>::value-1>(t);
} |
template<class Tuple, std::integral I>
void add_in_place_tuple(Tuple& t, const I& ii){
IteratorTupleHelper<Tuple>::template add_in_place<std::tuple_size<Tuple>::value-1>(t,ii);
} |
template<class Tuple, std::integral I>
void sub_in_place_tuple(Tuple& t, const I& ii){
IteratorTupleHelper<Tuple>::template sub_in_place<std::tuple_size<Tuple>::value-1>(t,ii);
} |
template<class Tuple, std::size_t... I>
auto begin_tuple_impl( const Tuple& t, std::index_sequence<I...>){
return std::make_tuple( std::get<I>(t).begin() ...);
} |
template<class Tuple, std::size_t... I>
auto begin_tuple_impl( Tuple& t, std::index_sequence<I...>){
return std::make_tuple( std::get<I>(t).begin() ...);
} |
template<class Tuple, std::size_t... I>
auto end_tuple_impl( const Tuple& t, std::index_sequence<I...>){
return std::make_tuple( std::get<I>(t).end() ...);
} |
template<class Tuple, std::size_t... I>
auto end_tuple_impl( Tuple& t, std::index_sequence<I...>){
return std::make_tuple( std::get<I>(t).end() ...);
} |
template<class Tuple>
decltype(auto) begin_tuple(Tuple& t){
return begin_tuple_impl(t,std::make_index_sequence<std::tuple_size<Tuple>::value>{});
} |
template<class Tuple>
decltype(auto) begin_tuple(const Tuple& t){
return begin_tuple_impl(t,std::make_index_sequence<std::tuple_size<Tuple>::value>{});
} |
template<class Tuple>
decltype(auto) end_tuple(Tuple& t){
return end_tuple_impl(t,std::make_index_sequence<std::tuple_size<Tuple>::value>{});
} |
template<class Tuple>
decltype(auto) end_tuple(const Tuple& t){
return end_tuple_impl(t,std::make_index_sequence<std::tuple_size<Tuple>::value>{});
} |
template<std::size_t idx>
friend decltype(auto) get( IteratorTuple& tuple ){
return std::get<idx>(tuple._its);
} |
template<std::integral I> IteratorTuple& operator+=( const I& ii) { add_in_place_tuple(_its,ii); return *this; } |
template<std::integral I> IteratorTuple& operator-=( const I& ii) { sub_in_place_tuple(_its,ii); return *this; } |
template<std::integral I> IteratorTuple operator+( const I& ii) { auto result(*this); result+=ii; return result; } |
template<std::integral I> IteratorTuple operator-( const I& ii) { auto result(*this); result-=ii; return result; } |
template<typename F>
void SVD
( Matrix<F>& A, Matrix<Base<F>>& s, Matrix<F>& V, const SVDCtrl<Base<F>>& ctrl )
{
DEBUG_ONLY(CallStackEntry cse("SVD"))
if( ctrl.thresholded )
{
svd::Thresholded( A, s, V, ctrl.tol, ctrl.relative );
}
else
{
if( ctrl.seqQR )
svd::QRSVD( ... |
template<typename F>
void SVD
( AbstractDistMatrix<F>& A, AbstractDistMatrix<Base<F>>& s,
AbstractDistMatrix<F>& V, const SVDCtrl<Base<F>>& ctrl )
{
DEBUG_ONLY(CallStackEntry cse("SVD"))
if( ctrl.thresholded )
{
if( A.ColDist() == VC && A.RowDist() == STAR )
{
auto& ACast = dy... |
template<typename F>
void SVD( Matrix<F>& A, Matrix<Base<F>>& s )
{
DEBUG_ONLY(CallStackEntry cse("SVD"))
const Int m = A.Height();
const Int n = A.Width();
s.Resize( Min(m,n), 1 );
lapack::SVD( m, n, A.Buffer(), A.LDim(), s.Buffer() );
} |
template<typename F>
void SVD
( AbstractDistMatrix<F>& A, AbstractDistMatrix<Base<F>>& s,
const SVDCtrl<Base<F>>& ctrl )
{
DEBUG_ONLY(CallStackEntry cse("SVD"))
// TODO: Add more options
svd::Chan( A, s, ctrl.valChanRatio );
} |
template <typename T>
std::ostream& operator <<(std::ostream& outputStream, const std::vector<T>& values)
{
for (const auto& value : values)
{
outputStream << value << " ";
}
return outputStream;
} |
template<class Summary>
Summary operator()(Summary summary, std::size_t begin, std::size_t size, bool prescan)
{
extent_type ext = in_.extent();
std::size_t ibound = boost::fusion::at_c<0>(ext);
return details::scan_step( summary
, out_, in_
... |
template<typename... Args>
KinGroupIDBorderGrayColorMap( Args&&... ){} |
template<typename ValueType>
std::string Paint(const ValueType& in1, const ValueType& in2) const {
const auto& v1 = in1.data;
const auto& v2 = in2.data;
if (v1[0] == v2[0]) return "transparent";
else if (v1.size() > 1 && v1[1] == v2[1]) return "lightgray";
else return "gray";
} |
template<typename Derived> double qpp::concurrence(
/// const Eigen::MatrixBase<Derived>& A)
TEST(qpp_concurrence, AllTests) {
// random qubit product state
cmat rho1 = prj(kron(randU(), randU()) * mket({0, 0}));
EXPECT_NEAR(0, qpp::concurrence(rho1), 1e-7);
// random maximally entangled 2-qubit ... |
template<typename Derived> double qpp::entanglement(
/// const Eigen::MatrixBase<Derived>& A, const std::vector<idx>& dims)
TEST(qpp_entanglement, AllTests) {
// random qutrit product state
ket psi1 = kron(randU(3), randU(3)) * mket({0, 0}, 3);
EXPECT_NEAR(0, qpp::entanglement(psi1, {3, 3}), 1e-7);
... |
template<typename Derived> double qpp::entanglement(
/// const Eigen::MatrixBase<Derived>& A, idx d = 2)
TEST(qpp_entanglement_qubits, AllTests) {
// random qubit product state
ket psi1 = kron(randU(), randU()) * mket({0, 0});
EXPECT_NEAR(0, qpp::entanglement(psi1), 1e-7);
// random maximally ent... |
template<typename Derived> double qpp::gconcurrence(
/// const Eigen::MatrixBase<Derived>& A)
TEST(qpp_gconcurrence, AllTests) {
// random qubit product state
ket psi1 = kron(randU(), randU()) * mket({0, 0});
EXPECT_NEAR(0, qpp::gconcurrence(psi1), 1e-7);
// random maximally entangled 2-qubit sta... |
template<typename Derived> double qpp::lognegativity(
/// const Eigen::MatrixBase<Derived>& A, const std::vector<idx>& dims)
TEST(qpp_lognegativity, AllTests) {
// zero on product states (2 qutrits)
cmat rho = randrho(3);
cmat sigma = randrho(3);
EXPECT_NEAR(0, qpp::lognegativity(kron(rho, sigma),... |
template<typename Derived> double qpp::lognegativity(
/// const Eigen::MatrixBase<Derived>& A, idx d = 2)
TEST(qpp_lognegativity_qubits, AllTests) {
// zero on product states (2 qubits)
cmat rho = randrho();
cmat sigma = randrho();
EXPECT_NEAR(0, qpp::lognegativity(kron(rho, sigma)), 1e-7);
/... |
template<typename Derived> double qpp::negativity(
/// const Eigen::MatrixBase<Derived>& A, const std::vector<idx>& dims)
TEST(qpp_negativity, AllTests) {
// Must be (d - 1)/2 on MES
// zero on product states (2 qutrits)
cmat rho = randrho(3);
cmat sigma = randrho(3);
EXPECT_NEAR(0, qpp::nega... |
template<typename Derived> double qpp::negativity(
/// const Eigen::MatrixBase<Derived>& A, idx d = 2)
TEST(qpp_negativity_qubits, AllTests) {
// Must be (d - 1)/2 on MES
// zero on product states (2 qutrits)
cmat rho = randrho();
cmat sigma = randrho();
EXPECT_NEAR(0, qpp::negativity(kron(rh... |
template<typename T>
bool IsNonValue(T input) {
bool status = false;
if(input == NULL) {
status = true;
} else if (input.which() == BUFFER) {
status = input.empty();
} else if (input.which() == BUFFERARRAY) {
status = input.empty();
} else if (input.which() == STRING) {
... |
template<typename T>
std::vector<T> Slice(const std::vector<T>& vect, std::size_t start, std::size_t end) {
if(end = -1) {
end = vect.size() - 1;
}
auto first_ = vect.begin() + start;
auto last_ = vect.begin() + end + 1;
std::vector<T> sliced_vector_(first_, last_);
return sliced_vector... |
template<typename T>
int GetLength(const T& input) {
if (!input || input.size() == 0) {
return EMPTY_STRING;
}
const buffer_t input_byte_ = ToBytes(input);
const auto first_byte_ = input_byte_[0];
int result = 0;
if(first_byte_ <= SHORT_STRING) {
result = input_byte_.size();
... |
template<typename Base, typename T>
inline bool instanceof(const T*) {
return std::is_base_of<Base, T>::value;
} |
template <typename T>
std::string GetBytes(T input) {
// std::stringstream stream_;
// stream_ << "<Bytes";
// for(std::size_t i = 0; i < input.size(); i++ ) {
// stream_ << " " << input[i];
// }
// stream_ << ">";
// return stream_.str();
std::string byte_str_ {"<Bytes"};
for... |
template <typename T>
std::vector<T> get_digits(T val)
{
std::vector<T> ret;
while (val != 0)
{
ret.push_back(val % 10);
val /= 10;
}
return std::vector<T>(ret.rbegin(), ret.rend());
} |
template <typename T>
bool is_armstrong(T val)
{
std::vector<T> digits = get_digits(val);
T sum = 0;
for (T elem : digits)
sum += elem * elem * elem;
return val == sum;
} |
template <typename T>
std::vector<T> solve(T first = 100, T last = 999)
{
std::vector<T> ret;
for (T i = first; i <= last; ++i)
if (is_armstrong(i))
ret.push_back(i);
return ret;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.