helics  3.0.1
helicsTypes.hpp
Go to the documentation of this file.
1 /*
2 Copyright (c) 2017-2021,
3 Battelle Memorial Institute; Lawrence Livermore National Security, LLC; Alliance for Sustainable
4 Energy, LLC. See the top-level NOTICE for additional details. All rights reserved.
5 SPDX-License-Identifier: BSD-3-Clause
6 */
7 #pragma once
8 #include "../core/core-data.hpp"
9 #include "helics_cxx_export.h"
10 
11 #include <complex>
12 #include <limits>
13 #include <string>
14 #include <string_view>
15 #include <typeinfo>
16 #include <utility>
17 #include <vector>
21 namespace helics {
22 using IdentifierType = std::uint32_t;
23 using std::int32_t;
24 using std::int64_t;
25 
27  static_cast<IdentifierType>(-1);
28 
30 enum class Identifiers : char {
31  PUBLICATION,
32  INPUT,
33  FILTER,
34  ENDPOINT,
35  QUERY,
36 };
37 
39 enum class InterfaceVisibility {
40  LOCAL,
41  GLOBAL,
42 };
43 
50 template<typename BaseType, Identifiers ID, BaseType invalidValue>
51 class IdentifierId {
52  private:
53  BaseType ivalue = invalidValue;
54 
55  public:
56  static const Identifiers identity{ID};
57  using UnderlyingType = BaseType;
59  constexpr IdentifierId() noexcept: ivalue(invalidValue) {}
61  constexpr explicit IdentifierId(BaseType val) noexcept: ivalue(val) {}
63  constexpr IdentifierId(const IdentifierId& id) noexcept: ivalue(id.ivalue) {}
65  IdentifierId& operator=(BaseType val) noexcept
66  {
67  ivalue = val;
68  return *this;
69  }
71  IdentifierId& operator=(const IdentifierId& id) = default;
72 
74  BaseType value() const noexcept { return ivalue; };
76  bool operator==(IdentifierId id) const noexcept { return (ivalue == id.ivalue); }
78  bool operator!=(IdentifierId id) const noexcept { return (ivalue != id.ivalue); }
80  bool operator<(IdentifierId id) const noexcept { return (ivalue < id.ivalue); }
81  // check if the current value is not the invalidValue
82  bool isValid() const noexcept { return (ivalue != invalidValue); }
83 };
84 } // namespace helics
85 
86 // specialize std::hash
87 namespace std {
89 template<typename BaseType, helics::Identifiers ID, BaseType invalidValue>
90 struct hash<helics::IdentifierId<BaseType, ID, invalidValue>> {
91  using argument_type =
93  using result_type = std::size_t;
94 
95  result_type operator()(argument_type const& key) const noexcept
96  {
97  return std::hash<BaseType>{}(key.value());
98  }
99 };
100 } // namespace std
101 
102 namespace helics {
103 using PublicationId = IdentifierId<IdentifierType, Identifiers::PUBLICATION, invalid_id_value>;
104 using InputId = IdentifierId<IdentifierType, Identifiers::INPUT, invalid_id_value>;
105 
106 using QueryId = IdentifierId<IdentifierType, Identifiers::QUERY, invalid_id_value>;
107 
109 class NamedPoint {
110  public:
111  std::string name;
112  double value =
113  std::numeric_limits<double>::quiet_NaN();
114 
115  NamedPoint() = default;
117  NamedPoint(std::string_view valname, double valval): name(valname), value(valval) {}
122  bool operator==(const NamedPoint& np) const
123  {
124  return ((std::isnan(value)) && (std::isnan(np.value))) ?
125  (name == np.name) :
126  ((value == np.value) && (name == np.name));
127  }
128  bool operator!=(const NamedPoint& np) const { return !operator==(np); }
132  bool operator<(const NamedPoint& np) const
133  {
134  return (name == np.name) ? (name < np.name) : (value < np.value);
135  }
139  bool operator>(const NamedPoint& np) const
140  {
141  return (name == np.name) ? (name > np.name) : (value > np.value);
142  }
143 };
144 
146 template<class X>
147 inline constexpr const char* typeNameString()
148 {
149  // this will probably not be the same on all platforms
150  return typeid(X).name();
151 }
152 namespace typestrings {
153  constexpr auto svecstr = "string_vector";
154  constexpr auto dvecstr = "double_vector";
155  constexpr auto cvecstr = "complex_vector";
156 
157  constexpr auto doublestr = "double";
158  constexpr auto floatstr = "float";
159  constexpr auto boolstr = "bool";
160 
161  constexpr auto charstr = "char";
162  constexpr auto ucharstr = "uchar";
163  constexpr auto i32str = "int32";
164  constexpr auto ui32str = "uint32";
165  constexpr auto i64str = "int64";
166  constexpr auto ui64str = "uint64";
167 
168  constexpr auto cfloatstr = "complex_f";
169  constexpr auto cdoublestr = "complex";
170  constexpr auto npstr = "named_point";
171  constexpr auto strstr = "string";
172 } // namespace typestrings
173 
174 template<>
175 inline constexpr const char* typeNameString<std::vector<std::string>>()
176 {
177  return typestrings::svecstr;
178 }
179 template<>
180 inline constexpr const char* typeNameString<std::vector<double>>()
181 {
182  return typestrings::dvecstr;
183 }
184 
185 template<>
186 inline constexpr const char* typeNameString<std::vector<std::complex<double>>>()
187 {
188  return typestrings::cvecstr;
189 }
190 
192 template<>
193 inline constexpr const char* typeNameString<double>()
194 {
195  return typestrings::doublestr;
196 }
197 
199 template<>
200 inline constexpr const char* typeNameString<float>()
201 {
202  return typestrings::floatstr;
203 }
204 
206 template<>
207 inline constexpr const char* typeNameString<bool>()
208 {
209  return typestrings::boolstr;
210 }
211 
213 template<>
214 inline constexpr const char* typeNameString<char>()
215 {
216  return typestrings::charstr;
217 }
219 template<>
220 inline constexpr const char* typeNameString<unsigned char>()
221 {
222  return typestrings::ucharstr;
223 }
225 template<>
226 inline constexpr const char* typeNameString<std::int32_t>()
227 {
228  return typestrings::i32str;
229 }
231 template<>
232 inline constexpr const char* typeNameString<std::uint32_t>()
233 {
234  return typestrings::ui32str;
235 }
237 template<>
238 inline constexpr const char* typeNameString<int64_t>()
239 {
240  return typestrings::i64str;
241 }
243 template<>
244 inline constexpr const char* typeNameString<std::uint64_t>()
245 {
246  return typestrings::ui64str;
247 }
249 template<>
250 inline constexpr const char* typeNameString<std::complex<float>>()
251 {
252  return typestrings::cfloatstr;
253 }
255 template<>
256 inline constexpr const char* typeNameString<std::complex<double>>()
257 {
258  return typestrings::cdoublestr;
259 }
260 template<>
261 inline constexpr const char* typeNameString<std::string>()
262 {
263  return typestrings::strstr;
264 }
265 
266 template<>
267 inline constexpr const char* typeNameString<NamedPoint>()
268 {
269  return typestrings::npstr;
270 }
272 enum class DataType : int {
273  HELICS_UNKNOWN = HELICS_DATA_TYPE_UNKNOWN,
274  HELICS_STRING = HELICS_DATA_TYPE_STRING,
275  HELICS_DOUBLE = HELICS_DATA_TYPE_DOUBLE,
276  HELICS_INT = HELICS_DATA_TYPE_INT,
277 
278  HELICS_COMPLEX = HELICS_DATA_TYPE_COMPLEX,
279  HELICS_VECTOR = HELICS_DATA_TYPE_VECTOR,
280  HELICS_COMPLEX_VECTOR = HELICS_DATA_TYPE_COMPLEX_VECTOR,
281  HELICS_NAMED_POINT = HELICS_DATA_TYPE_NAMED_POINT,
282  HELICS_BOOL = HELICS_DATA_TYPE_BOOLEAN,
283  HELICS_TIME = HELICS_DATA_TYPE_TIME,
284  HELICS_CUSTOM = HELICS_DATA_TYPE_RAW,
285  HELICS_ANY = HELICS_DATA_TYPE_ANY,
286  HELICS_JSON = HELICS_DATA_TYPE_JSON,
287  HELICS_MULTI = HELICS_DATA_TYPE_MULTI,
288 };
289 
290 inline constexpr bool isBytesType(DataType type)
291 {
292  return (type == DataType::HELICS_ANY) || (type == DataType::HELICS_CUSTOM);
293 }
294 
296 HELICS_CXX_EXPORT const std::string& typeNameStringRef(DataType type);
297 
299 HELICS_CXX_EXPORT DataType getTypeFromString(std::string_view typeName);
300 
303 HELICS_CXX_EXPORT std::string_view getCleanedTypeName(std::string_view typeName);
304 
306 HELICS_CXX_EXPORT std::string helicsComplexString(double real, double imag);
308 HELICS_CXX_EXPORT std::string helicsComplexString(std::complex<double> val);
311 HELICS_CXX_EXPORT std::string helicsVectorString(const std::vector<double>& val);
313 HELICS_CXX_EXPORT std::string helicsIntString(std::int64_t val);
315 HELICS_CXX_EXPORT std::string helicsDoubleString(double val);
318 HELICS_CXX_EXPORT std::string helicsVectorString(const double* vals, size_t size);
321 HELICS_CXX_EXPORT std::string
322  helicsComplexVectorString(const std::vector<std::complex<double>>& val);
326 HELICS_CXX_EXPORT std::string helicsNamedPointString(const NamedPoint& point);
327 HELICS_CXX_EXPORT std::string helicsNamedPointString(std::string_view pointName, double val);
329 HELICS_CXX_EXPORT std::complex<double> helicsGetComplex(std::string_view val);
331 HELICS_CXX_EXPORT std::vector<double> helicsGetVector(std::string_view val);
332 HELICS_CXX_EXPORT void helicsGetVector(std::string_view val, std::vector<double>& data);
333 
335 HELICS_CXX_EXPORT std::vector<std::complex<double>> helicsGetComplexVector(std::string_view val);
336 
338 HELICS_CXX_EXPORT void helicsGetComplexVector(std::string_view val,
339  std::vector<std::complex<double>>& data);
340 
342 HELICS_CXX_EXPORT NamedPoint helicsGetNamedPoint(std::string_view val);
344 HELICS_CXX_EXPORT std::int64_t getIntFromString(std::string_view val);
346 HELICS_CXX_EXPORT double getDoubleFromString(std::string_view val);
348 HELICS_CXX_EXPORT std::complex<double> getComplexFromString(std::string_view val);
350 HELICS_CXX_EXPORT bool helicsBoolValue(std::string_view val);
352 HELICS_CXX_EXPORT double vectorNorm(const std::vector<double>& vec);
354 HELICS_CXX_EXPORT double vectorNorm(const std::vector<std::complex<double>>& vec);
359 HELICS_CXX_EXPORT SmallBuffer typeConvert(DataType type, double val);
360 HELICS_CXX_EXPORT SmallBuffer typeConvert(DataType type, int64_t val);
361 HELICS_CXX_EXPORT SmallBuffer typeConvert(DataType type, std::string_view val);
362 HELICS_CXX_EXPORT SmallBuffer typeConvert(DataType type, const std::vector<double>& val);
363 HELICS_CXX_EXPORT SmallBuffer typeConvert(DataType type, const double* vals, size_t size);
364 HELICS_CXX_EXPORT SmallBuffer typeConvertComplex(DataType type, const double* vals, size_t size);
365 HELICS_CXX_EXPORT SmallBuffer typeConvert(DataType type,
366  const std::vector<std::complex<double>>& val);
367 HELICS_CXX_EXPORT SmallBuffer typeConvert(DataType type, const std::complex<double>& val);
368 HELICS_CXX_EXPORT SmallBuffer typeConvert(DataType type, const NamedPoint& val);
369 HELICS_CXX_EXPORT SmallBuffer typeConvert(DataType type, std::string_view str, double val);
370 HELICS_CXX_EXPORT SmallBuffer typeConvert(DataType type, bool val);
371 HELICS_CXX_EXPORT SmallBuffer typeConvert(DataType type, char val);
372 HELICS_CXX_EXPORT SmallBuffer typeConvert(DataType type, Time val);
373 
375 template<class X>
376 constexpr DataType helicsType()
377 {
378  return DataType::HELICS_CUSTOM;
379 }
380 
381 template<>
382 constexpr DataType helicsType<int64_t>()
383 {
384  return DataType::HELICS_INT;
385 }
386 
387 template<>
388 constexpr DataType helicsType<bool>()
389 {
390  return DataType::HELICS_BOOL;
391 }
392 
393 template<>
394 constexpr DataType helicsType<std::string>()
395 {
396  return DataType::HELICS_STRING;
397 }
398 
399 template<>
400 constexpr DataType helicsType<NamedPoint>()
401 {
402  return DataType::HELICS_NAMED_POINT;
403 }
404 template<>
405 constexpr DataType helicsType<double>()
406 {
407  return DataType::HELICS_DOUBLE;
408 }
409 
410 template<>
411 constexpr DataType helicsType<Time>()
412 {
413  return DataType::HELICS_TIME;
414 }
415 
416 template<>
417 constexpr DataType helicsType<std::complex<double>>()
418 {
419  return DataType::HELICS_COMPLEX;
420 }
421 
422 template<>
423 constexpr DataType helicsType<std::vector<double>>()
424 {
425  return DataType::HELICS_VECTOR;
426 }
427 
428 template<>
429 constexpr DataType helicsType<std::vector<std::complex<double>>>()
430 {
431  return DataType::HELICS_COMPLEX_VECTOR;
432 }
433 
434 // check if the type is directly convertible to a base HelicsType
435 template<class X>
436 constexpr bool isConvertableType()
437 {
438  return false;
439 }
440 
441 template<>
442 constexpr bool isConvertableType<float>()
443 {
444  return true;
445 }
446 
447 template<>
448 constexpr bool isConvertableType<long double>()
449 {
450  return true;
451 }
452 
453 template<>
454 constexpr bool isConvertableType<int32_t>()
455 {
456  return true;
457 }
458 
459 template<>
460 constexpr bool isConvertableType<int16_t>()
461 {
462  return true;
463 }
464 
465 template<>
466 constexpr bool isConvertableType<uint16_t>()
467 {
468  return true;
469 }
470 
471 template<>
472 constexpr bool isConvertableType<char>()
473 {
474  return true;
475 }
476 
477 template<>
478 constexpr bool isConvertableType<unsigned char>()
479 {
480  return true;
481 }
482 
483 template<>
484 constexpr bool isConvertableType<uint64_t>()
485 {
486  return true;
487 }
488 
490 template<class X>
491 inline X invalidValue()
492 {
493  return X();
494 }
495 
497 constexpr double invalidDouble = -1e49;
498 
499 template<>
500 constexpr double invalidValue<double>()
501 {
502  return invalidDouble;
503 }
504 
505 template<>
506 constexpr int64_t invalidValue<int64_t>()
507 {
508  return (std::numeric_limits<int64_t>::min)();
509 }
510 
511 template<>
512 constexpr uint64_t invalidValue<uint64_t>()
513 {
514  return (std::numeric_limits<uint64_t>::max)();
515 }
516 
517 template<>
518 constexpr Time invalidValue<Time>()
519 {
520  return Time::minVal();
521 }
522 
523 template<>
524 inline NamedPoint invalidValue<NamedPoint>()
525 {
526  return {std::string(), std::nan("0")};
527 }
528 
529 template<>
530 constexpr std::complex<double> invalidValue<std::complex<double>>()
531 {
532  return {invalidValue<double>(), 0.0};
533 }
535 template<typename T>
536 using remove_cv_ref = std::remove_cv_t<std::remove_reference_t<T>>;
537 
538 constexpr int primaryType = 0;
539 constexpr int convertibleType = 1;
540 constexpr int nonConvertibleType = 2;
545 template<typename X>
546 using typeCategory =
547  std::conditional_t<helicsType<remove_cv_ref<X>>() != DataType::HELICS_CUSTOM,
548  std::integral_constant<int, primaryType>,
549  std::conditional_t<isConvertableType<remove_cv_ref<X>>(),
550  std::integral_constant<int, convertibleType>,
551  std::integral_constant<int, nonConvertibleType>>>;
552 } // namespace helics
helics::timeZero
constexpr Time timeZero
Definition: helicsTime.hpp:31
helics::helicsIntString
std::string helicsIntString(std::int64_t val)
Definition: helicsTypes.cpp:334
helics::IdentifierId::IdentifierId
constexpr IdentifierId(const IdentifierId &id) noexcept
Definition: helicsTypes.hpp:63
helicsTypes.hpp
helics::NamedPoint::name
std::string name
the text value for the named point
Definition: helicsTypes.hpp:111
helics::helicsType
constexpr DataType helicsType()
Definition: helicsTypes.hpp:376
helics::InterfaceVisibility
InterfaceVisibility
Definition: helicsTypes.hpp:39
helics::NamedPoint
Definition: helicsTypes.hpp:109
helics::IdentifierId
Definition: helicsTypes.hpp:51
helics::typeCategory
std::conditional_t< helicsType< remove_cv_ref< X > >() !=DataType::HELICS_CUSTOM, std::integral_constant< int, primaryType >, std::conditional_t< isConvertableType< remove_cv_ref< X > >(), std::integral_constant< int, convertibleType >, std::integral_constant< int, nonConvertibleType > >> typeCategory
Definition: helicsTypes.hpp:551
HELICS_DATA_TYPE_JSON
@ HELICS_DATA_TYPE_JSON
Definition: helics_enums.h:86
helics::SmallBuffer
Definition: SmallBuffer.hpp:24
helics::IdentifierId::value
BaseType value() const noexcept
Definition: helicsTypes.hpp:74
HELICS_DATA_TYPE_ANY
@ HELICS_DATA_TYPE_ANY
Definition: helics_enums.h:90
HELICS_DATA_TYPE_COMPLEX
@ HELICS_DATA_TYPE_COMPLEX
Definition: helics_enums.h:72
helics::NamedPoint::NamedPoint
NamedPoint()=default
helics::helicsComplexVectorString
std::string helicsComplexVectorString(const std::vector< std::complex< double >> &val)
Definition: helicsTypes.cpp:354
helics::typeNameString< unsigned char >
constexpr const char * typeNameString< unsigned char >()
Definition: helicsTypes.hpp:220
helics::invalidValue
X invalidValue()
Definition: helicsTypes.hpp:491
helics::ValueConverter
Definition: ValueConverter.hpp:98
helics::getCleanedTypeName
std::string_view getCleanedTypeName(std::string_view typeName)
Definition: helicsTypes.cpp:245
helics::typeNameString
constexpr const char * typeNameString()
Definition: helicsTypes.hpp:147
helics::helicsGetComplexVector
std::vector< std::complex< double > > helicsGetComplexVector(std::string_view val)
Definition: helicsTypes.cpp:381
helics::NamedPoint::value
double value
the data value for the named point
Definition: helicsTypes.hpp:112
helics::Time
TimeRepresentation< count_time< 9 > > Time
Definition: helicsTime.hpp:27
helics::Identifiers
Identifiers
Definition: helicsTypes.hpp:30
helics::typeNameString< char >
constexpr const char * typeNameString< char >()
Definition: helicsTypes.hpp:214
helics::IdentifierId::IdentifierId
constexpr IdentifierId() noexcept
Definition: helicsTypes.hpp:59
helics::HELICS_UNKNOWN
@ HELICS_UNKNOWN
unknown state
Definition: CoreTypes.hpp:29
helics::getTypeFromString
DataType getTypeFromString(std::string_view typeName)
Definition: helicsTypes.cpp:219
HELICS_DATA_TYPE_STRING
@ HELICS_DATA_TYPE_STRING
Definition: helics_enums.h:66
HELICS_DATA_TYPE_NAMED_POINT
@ HELICS_DATA_TYPE_NAMED_POINT
Definition: helics_enums.h:78
helics::typeNameString< bool >
constexpr const char * typeNameString< bool >()
Definition: helicsTypes.hpp:207
std::hash< helics::IdentifierId< BaseType, ID, invalidValue > >::result_type
std::size_t result_type
the result type of the hash code
Definition: helicsTypes.hpp:93
helics::vectorNorm
double vectorNorm(const std::vector< double > &vec)
Definition: helicsTypes.cpp:85
helics::DataType
DataType
Definition: helicsTypes.hpp:272
helics::NamedPoint::operator==
bool operator==(const NamedPoint &np) const
Definition: helicsTypes.hpp:122
HELICS_DATA_TYPE_BOOLEAN
@ HELICS_DATA_TYPE_BOOLEAN
Definition: helics_enums.h:80
HELICS_DATA_TYPE_RAW
@ HELICS_DATA_TYPE_RAW
Definition: helics_enums.h:84
helics::helicsDoubleString
std::string helicsDoubleString(double val)
Definition: helicsTypes.cpp:339
helics::IdentifierId::operator<
bool operator<(IdentifierId id) const noexcept
Definition: helicsTypes.hpp:80
helics::IdentifierId::identity
static const Identifiers identity
the type of the identifier
Definition: helicsTypes.hpp:56
helics::IdentifierId::operator!=
bool operator!=(IdentifierId id) const noexcept
Definition: helicsTypes.hpp:78
HELICS_DATA_TYPE_TIME
@ HELICS_DATA_TYPE_TIME
Definition: helics_enums.h:82
helics::helicsBoolValue
bool helicsBoolValue(std::string_view val)
Definition: helicsTypes.cpp:626
helics::IdentifierType
std::uint32_t IdentifierType
specify the underlying type used in the identifiers
Definition: helicsTypes.hpp:22
helics::invalidDouble
constexpr double invalidDouble
defined constant for an invalid value as a double
Definition: helicsTypes.hpp:497
HELICS_DATA_TYPE_VECTOR
@ HELICS_DATA_TYPE_VECTOR
Definition: helics_enums.h:74
helics::helicsVectorString
std::string helicsVectorString(const std::vector< double > &val)
Definition: helicsTypes.cpp:344
helics::helicsGetNamedPoint
NamedPoint helicsGetNamedPoint(std::string_view val)
Definition: helicsTypes.cpp:388
helics::IdentifierId::IdentifierId
constexpr IdentifierId(BaseType val) noexcept
Definition: helicsTypes.hpp:61
helics::IdentifierId::operator==
bool operator==(IdentifierId id) const noexcept
Definition: helicsTypes.hpp:76
helics::typeNameString< int64_t >
constexpr const char * typeNameString< int64_t >()
Definition: helicsTypes.hpp:238
HELICS_DATA_TYPE_INT
@ HELICS_DATA_TYPE_INT
Definition: helics_enums.h:70
std::hash< helics::IdentifierId< BaseType, ID, invalidValue > >::operator()
result_type operator()(argument_type const &key) const noexcept
Definition: helicsTypes.hpp:95
helics::NamedPoint::operator>
bool operator>(const NamedPoint &np) const
Definition: helicsTypes.hpp:139
helics::remove_cv_ref
std::remove_cv_t< std::remove_reference_t< T > > remove_cv_ref
Helper template to remove const volatile references.
Definition: helicsTypes.hpp:536
HELICS_DATA_TYPE_MULTI
@ HELICS_DATA_TYPE_MULTI
Definition: helics_enums.h:88
helics::helicsComplexString
std::string helicsComplexString(double real, double imag)
Definition: helicsTypes.cpp:103
HELICS_DATA_TYPE_DOUBLE
@ HELICS_DATA_TYPE_DOUBLE
Definition: helics_enums.h:68
helics::IdentifierId::operator=
IdentifierId & operator=(BaseType val) noexcept
Definition: helicsTypes.hpp:65
helics::typeNameString< float >
constexpr const char * typeNameString< float >()
Definition: helicsTypes.hpp:200
helics::getIntFromString
std::int64_t getIntFromString(std::string_view val)
Definition: helicsTypes.cpp:462
helics::typeConvert
SmallBuffer typeConvert(DataType type, double val)
Definition: helicsTypes.cpp:712
helics
the main namespace for the helics co-simulation library User functions will be in the helics namespac...
Definition: AsyncFedCallInfo.hpp:14
helics::NamedPoint::NamedPoint
NamedPoint(std::string_view valname, double valval)
Definition: helicsTypes.hpp:117
helics::getComplexFromString
std::complex< double > getComplexFromString(std::string_view val)
Definition: helicsTypes.cpp:444
helics::typeNameStringRef
const std::string & typeNameStringRef(DataType type)
Definition: helicsTypes.cpp:46
helics::helicsGetVector
std::vector< double > helicsGetVector(std::string_view val)
Definition: helicsTypes.cpp:374
helics::typeNameString< double >
constexpr const char * typeNameString< double >()
Definition: helicsTypes.hpp:193
helics::invalid_id_value
constexpr IdentifierType invalid_id_value
defining an invalid id value
Definition: helicsTypes.hpp:26
HELICS_DATA_TYPE_COMPLEX_VECTOR
@ HELICS_DATA_TYPE_COMPLEX_VECTOR
Definition: helics_enums.h:76
helics::helicsNamedPointString
std::string helicsNamedPointString(const NamedPoint &point)
Definition: helicsTypes.cpp:359
ValueConverter.hpp
helics::NamedPoint::operator<
bool operator<(const NamedPoint &np) const
Definition: helicsTypes.hpp:132
helics::getDoubleFromString
double getDoubleFromString(std::string_view val)
Definition: helicsTypes.cpp:473
helics::helicsGetComplex
std::complex< double > helicsGetComplex(std::string_view val)
Definition: helicsTypes.cpp:275