casadi 3.6.4__cp312-none-manylinux2014_x86_64.whl → 3.6.5__cp312-none-manylinux2014_x86_64.whl

casadi/include/include/proxsuite/linalg/veg/internal/external/unhedley.ext.hpp

@@ -1,148 +0,0 @@
-#undef HEDLEY_VERSION
-#undef HEDLEY_STRINGIFY_EX
-#undef HEDLEY_STRINGIFY
-#undef HEDLEY_CONCAT_EX
-#undef HEDLEY_CONCAT
-#undef HEDLEY_CONCAT3_EX
-#undef HEDLEY_CONCAT3
-#undef HEDLEY_VERSION_ENCODE
-#undef HEDLEY_VERSION_DECODE_MAJOR
-#undef HEDLEY_VERSION_DECODE_MINOR
-#undef HEDLEY_VERSION_DECODE_REVISION
-#undef HEDLEY_GNUC_VERSION
-#undef HEDLEY_GNUC_VERSION_CHECK
-#undef HEDLEY_MSVC_VERSION
-#undef HEDLEY_MSVC_VERSION_CHECK
-#undef HEDLEY_INTEL_VERSION
-#undef HEDLEY_INTEL_VERSION_CHECK
-#undef HEDLEY_INTEL_CL_VERSION
-#undef HEDLEY_INTEL_CL_VERSION_CHECK
-#undef HEDLEY_PGI_VERSION
-#undef HEDLEY_PGI_VERSION_CHECK
-#undef HEDLEY_SUNPRO_VERSION
-#undef HEDLEY_SUNPRO_VERSION_CHECK
-#undef HEDLEY_EMSCRIPTEN_VERSION
-#undef HEDLEY_EMSCRIPTEN_VERSION_CHECK
-#undef HEDLEY_ARM_VERSION
-#undef HEDLEY_ARM_VERSION_CHECK
-#undef HEDLEY_IBM_VERSION
-#undef HEDLEY_IBM_VERSION_CHECK
-#undef HEDLEY_TI_VERSION
-#undef HEDLEY_TI_VERSION_CHECK
-#undef HEDLEY_TI_CL2000_VERSION
-#undef HEDLEY_TI_CL2000_VERSION_CHECK
-#undef HEDLEY_TI_CL430_VERSION
-#undef HEDLEY_TI_CL430_VERSION_CHECK
-#undef HEDLEY_TI_ARMCL_VERSION
-#undef HEDLEY_TI_ARMCL_VERSION_CHECK
-#undef HEDLEY_TI_CL6X_VERSION
-#undef HEDLEY_TI_CL6X_VERSION_CHECK
-#undef HEDLEY_TI_CL7X_VERSION
-#undef HEDLEY_TI_CL7X_VERSION_CHECK
-#undef HEDLEY_TI_CLPRU_VERSION
-#undef HEDLEY_TI_CLPRU_VERSION_CHECK
-#undef HEDLEY_CRAY_VERSION
-#undef HEDLEY_CRAY_VERSION_CHECK
-#undef HEDLEY_IAR_VERSION
-#undef HEDLEY_IAR_VERSION_CHECK
-#undef HEDLEY_TINYC_VERSION
-#undef HEDLEY_TINYC_VERSION_CHECK
-#undef HEDLEY_DMC_VERSION
-#undef HEDLEY_DMC_VERSION_CHECK
-#undef HEDLEY_COMPCERT_VERSION
-#undef HEDLEY_COMPCERT_VERSION_CHECK
-#undef HEDLEY_PELLES_VERSION
-#undef HEDLEY_PELLES_VERSION_CHECK
-#undef HEDLEY_GCC_VERSION
-#undef HEDLEY_GCC_VERSION_CHECK
-#undef HEDLEY_HAS_ATTRIBUTE
-#undef HEDLEY_GNUC_HAS_ATTRIBUTE
-#undef HEDLEY_GCC_HAS_ATTRIBUTE
-#undef HEDLEY_HAS_CPP_ATTRIBUTE
-#undef HEDLEY_HAS_CPP_ATTRIBUTE_NS
-#undef HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
-#undef HEDLEY_GCC_HAS_CPP_ATTRIBUTE
-#undef HEDLEY_HAS_BUILTIN
-#undef HEDLEY_GNUC_HAS_BUILTIN
-#undef HEDLEY_GCC_HAS_BUILTIN
-#undef HEDLEY_HAS_FEATURE
-#undef HEDLEY_GNUC_HAS_FEATURE
-#undef HEDLEY_GCC_HAS_FEATURE
-#undef HEDLEY_HAS_EXTENSION
-#undef HEDLEY_GNUC_HAS_EXTENSION
-#undef HEDLEY_GCC_HAS_EXTENSION
-#undef HEDLEY_HAS_DECLSPEC_ATTRIBUTE
-#undef HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
-#undef HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
-#undef HEDLEY_HAS_WARNING
-#undef HEDLEY_GNUC_HAS_WARNING
-#undef HEDLEY_GCC_HAS_WARNING
-#undef HEDLEY_PRAGMA
-#undef HEDLEY_DIAGNOSTIC_PUSH
-#undef HEDLEY_DIAGNOSTIC_POP
-#undef HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
-#undef HEDLEY_CONST_CAST
-#undef HEDLEY_REINTERPRET_CAST
-#undef HEDLEY_STATIC_CAST
-#undef HEDLEY_CPP_CAST
-#undef HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
-#undef HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
-#undef HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
-#undef HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
-#undef HEDLEY_DEPRECATED
-#undef HEDLEY_DEPRECATED_FOR
-#undef HEDLEY_UNAVAILABLE
-#undef HEDLEY_WARN_UNUSED_RESULT
-#undef HEDLEY_WARN_UNUSED_RESULT_MSG
-#undef HEDLEY_SENTINEL
-#undef HEDLEY_NO_RETURN
-#undef HEDLEY_NO_ESCAPE
-#undef HEDLEY_ASSUME
-#undef HEDLEY_UNREACHABLE
-#undef HEDLEY_UNREACHABLE_RETURN
-#undef HEDLEY_NON_NULL
-#undef HEDLEY_PRINTF_FORMAT
-#undef HEDLEY_CONSTEXPR
-#undef HEDLEY_UNPREDICTABLE
-#undef HEDLEY_PREDICT
-#undef HEDLEY_PREDICT_TRUE
-#undef HEDLEY_PREDICT_FALSE
-#undef HEDLEY_LIKELY
-#undef HEDLEY_UNLIKELY
-#undef HEDLEY_MALLOC
-#undef HEDLEY_PURE
-#undef HEDLEY_CONST
-#undef HEDLEY_RESTRICT
-#undef HEDLEY_INLINE
-#undef HEDLEY_ALWAYS_INLINE
-#undef HEDLEY_NEVER_INLINE
-#undef HEDLEY_PRIVATE
-#undef HEDLEY_PUBLIC
-#undef HEDLEY_IMPORT
-#undef HEDLEY_NO_THROW
-#undef HEDLEY_FALL_THROUGH
-#undef HEDLEY_RETURNS_NON_NULL
-#undef HEDLEY_ARRAY_PARAM
-#undef HEDLEY_IS_CONSTANT
-#undef HEDLEY_IS_CONSTEXPR_
-#undef HEDLEY_REQUIRE_CONSTEXPR
-#undef HEDLEY_BEGIN_C_DECLS
-#undef HEDLEY_END_C_DECLS
-#undef HEDLEY_C_DECL
-#undef HEDLEY_STATIC_ASSERT
-#undef HEDLEY_NULL
-#undef HEDLEY_MESSAGE
-#undef HEDLEY_WARNING
-#undef HEDLEY_REQUIRE
-#undef HEDLEY_REQUIRE_MSG
-#undef HEDLEY_FLAGS
-#undef HEDLEY_FLAGS_CAST
-#undef HEDLEY_EMPTY_BASES
-#undef HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
-#undef HEDLEY_CLANG_HAS_ATTRIBUTE
-#undef HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
-#undef HEDLEY_CLANG_HAS_BUILTIN
-#undef HEDLEY_CLANG_HAS_FEATURE
-#undef HEDLEY_CLANG_HAS_EXTENSION
-#undef HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE
-#undef HEDLEY_CLANG_HAS_WARNING

casadi/include/include/proxsuite/linalg/veg/internal/fix_index.hpp

@@ -1,339 +0,0 @@
-#ifndef VEG_META_INT_FIX_HPP_7S9Y48TFS
-#define VEG_META_INT_FIX_HPP_7S9Y48TFS
-
-#include "proxsuite/linalg/veg/type_traits/tags.hpp"
-#include "proxsuite/linalg/veg/internal/std.hpp"
-#include "proxsuite/linalg/veg/internal/dbg.hpp"
-#include "proxsuite/linalg/veg/internal/prologue.hpp"
-
-namespace proxsuite {
-namespace linalg {
-namespace veg {
-struct Dyn;
-template<isize N>
-struct Fix;
-
-namespace _detail {
-template<typename L, typename R>
-struct binary_traits
-{
-  using Add = void;
-  using Sub = void;
-  using Mul = void;
-  using Div = void;
-  using Mod = void;
-
-  using CmpEq = void;
-  using CmpNEq = void;
-  using CmpLT = void;
-  using CmpLE = void;
-  using CmpGT = void;
-  using CmpGE = void;
-};
-
-namespace idx {
-namespace adl {
-template<typename T>
-struct IdxBase
-{};
-} // namespace adl
-} // namespace idx
-namespace _meta {
-template<typename T>
-struct is_fix : false_type
-{};
-template<isize N>
-struct is_fix<Fix<N>> : true_type
-{};
-} // namespace _meta
-} // namespace _detail
-
-namespace concepts {
-VEG_DEF_CONCEPT(typename T,
-                index,
-                VEG_CONCEPT(same<T, Dyn>) || _detail::_meta::is_fix<T>::value);
-} // namespace concepts
-
-enum struct Ternary : unsigned char
-{
-  no,
-  maybe,
-  yes,
-};
-
-constexpr auto no = Ternary::no;
-constexpr auto maybe = Ternary::maybe;
-constexpr auto yes = Ternary::yes;
-using no_c = meta::constant<Ternary, Ternary::no>;
-using maybe_c = meta::constant<Ternary, Ternary::maybe>;
-using yes_c = meta::constant<Ternary, Ternary::yes>;
-
-template<Ternary T>
-struct Boolean;
-
-template<Ternary T>
-struct Boolean
-{
-  constexpr Boolean() VEG_NOEXCEPT = default;
-  using type = meta::constant<Ternary, T>;
-
-  VEG_INLINE constexpr Boolean(Boolean<maybe> /*b*/,
-                               Unsafe /*tag*/) VEG_NOEXCEPT;
-  VEG_INLINE constexpr Boolean // NOLINT(hicpp-explicit-conversions)
-    (Boolean<maybe> b) VEG_NOEXCEPT;
-
-  VEG_NODISCARD VEG_INLINE constexpr friend auto operator!(Boolean /*arg*/)
-    VEG_NOEXCEPT->Boolean<T == yes ? no : yes>
-  {
-    return {};
-  }
-  VEG_NODISCARD VEG_INLINE explicit constexpr operator bool() const VEG_NOEXCEPT
-  {
-    return T == yes;
-  }
-};
-
-template<isize N>
-struct Fix : _detail::idx::adl::IdxBase<Fix<N>>
-{
-  constexpr Fix() VEG_NOEXCEPT = default;
-  VEG_INLINE constexpr Fix(Dyn /*arg*/, Unsafe /*tag*/) VEG_NOEXCEPT;
-  VEG_INLINE constexpr Fix // NOLINT(hicpp-explicit-conversions)
-    (Dyn arg) VEG_NOEXCEPT;
-  VEG_TEMPLATE((isize M),
-               requires((M != N)),
-               constexpr Fix,
-               (/*arg*/, Fix<M>)) = delete;
-
-  VEG_NODISCARD VEG_INLINE explicit constexpr operator isize() const
-    VEG_NOEXCEPT
-  {
-    return N;
-  }
-  VEG_NODISCARD VEG_INLINE constexpr auto operator+() const VEG_NOEXCEPT->Fix
-  {
-    return {};
-  }
-  VEG_NODISCARD VEG_INLINE constexpr auto operator-() const
-    VEG_NOEXCEPT->Fix<-N>
-  {
-    return {};
-  }
-
-#define VEG_OP(Op, Name, TypeName)                                             \
-  VEG_TEMPLATE((typename R),                                                   \
-               requires(VEG_CONCEPT(index<R>)),                                \
-               VEG_NODISCARD VEG_INLINE constexpr auto                         \
-               operator Op,                                                    \
-               (b, R))                                                         \
-  const VEG_NOEXCEPT->typename _detail::binary_traits<Fix, R>::TypeName        \
-  {                                                                            \
-    return _detail::binary_traits<Fix, R>::Name##_fn(*this, b);                \
-  }                                                                            \
-  VEG_NOM_SEMICOLON
-
-  VEG_OP(+, add, Add);
-  VEG_OP(-, sub, Sub);
-  VEG_OP(*, mul, Mul);
-
-#undef VEG_OP
-
-  VEG_TEMPLATE(
-    (typename R),
-    requires(VEG_CONCEPT(index<R>) &&
-             VEG_CONCEPT(index<typename _detail::binary_traits<Fix, R>::Div>)),
-    VEG_NODISCARD VEG_INLINE constexpr auto
-    operator/,
-    (b, R))
-  const VEG_NOEXCEPT->typename _detail::binary_traits<Fix, R>::Div
-  {
-    return _detail::binary_traits<Fix, R>::div_fn(*this, b);
-  }
-
-  VEG_TEMPLATE(
-    (typename R),
-    requires(VEG_CONCEPT(index<R>) &&
-             VEG_CONCEPT(index<typename _detail::binary_traits<Fix, R>::Mod>)),
-    VEG_NODISCARD VEG_INLINE constexpr auto
-    operator%,
-    (b, R))
-  const VEG_NOEXCEPT->typename _detail::binary_traits<Fix, R>::Mod
-  {
-    return _detail::binary_traits<Fix, R>::mod_fn(*this, b);
-  }
-
-#define VEG_CMP(Name, TypeName, Op)                                            \
-  VEG_TEMPLATE((typename R),                                                   \
-               requires(VEG_CONCEPT(index<R>)),                                \
-               VEG_NODISCARD VEG_INLINE constexpr auto                         \
-               operator Op, /* NOLINT */                                       \
-               (b, R))                                                         \
-  const VEG_NOEXCEPT->typename _detail::binary_traits<Fix, R>::TypeName        \
-  {                                                                            \
-    return _detail::binary_traits<Fix, R>::cmp_##Name##_fn(*this, b);          \
-  }                                                                            \
-  VEG_NOM_SEMICOLON
-
-  VEG_CMP(eq, CmpEq, ==);
-  VEG_CMP(neq, CmpNEq, !=);
-  VEG_CMP(lt, CmpLT, <);
-  VEG_CMP(le, CmpLE, <=);
-  VEG_CMP(gt, CmpGT, >);
-  VEG_CMP(ge, CmpGE, >=);
-
-#undef VEG_CMP
-
-#undef VEG_CMP
-};
-
-namespace _detail {
-struct Error
-{
-  constexpr auto operator()(u64 const* fail = nullptr) const VEG_NOEXCEPT->u64
-  {
-    return *fail;
-  }
-};
-
-using parser = auto(*)(char, Error) -> u64;
-constexpr auto
-parse_digit_2(char c, Error e) VEG_NOEXCEPT->u64
-{
-  return (c == '0') ? 0 : (c == '1' ? 1 : e());
-}
-constexpr auto
-parse_digit_8(char c, Error e) VEG_NOEXCEPT->u64
-{
-  return (c >= '0' && c <= '7') ? u64(c - '0') : e();
-}
-constexpr auto
-parse_digit_10(char c, Error e) VEG_NOEXCEPT->u64
-{
-  return (c >= '0' && c <= '9') ? u64(c - '0') : e();
-}
-constexpr auto
-parse_digit_16(char c, Error e) VEG_NOEXCEPT->u64
-{
-  return (c >= '0' && c <= '9') //
-           ? u64(c - '0')
-           : (c >= 'a' && c <= 'f') //
-               ? u64(c - 'a')
-               : (c >= 'A' && c <= 'F') //
-                   ? u64(c - 'A')
-                   : e();
-}
-
-constexpr auto
-parse_digit(u64 radix) VEG_NOEXCEPT->parser
-{
-  return radix == 2
-           ? parse_digit_2
-           : (radix == 8
-                ? parse_digit_8
-                : (radix == 10 ? parse_digit_10
-                               : (radix == 16 ? parse_digit_16 : nullptr)));
-}
-
-constexpr auto
-parse_num(char const* str, u64 len, u64 radix, Error e) VEG_NOEXCEPT->u64
-{
-  return (len == 0) ? 0
-                    : radix * parse_num(str, len - 1, radix, e) +
-                        (parse_digit(radix)(str[len - 1], e));
-}
-
-constexpr auto
-parse_int(char const* str, u64 len, Error e) VEG_NOEXCEPT->u64
-{
-  return (len == 0) //
-           ? e()
-           : ((str[0] == '0') //
-                ? ((len == 1) //
-                     ? 0
-                     : (str[1] == 'b' || str[1] == 'B') //
-                         ? parse_num(str + 2, len - 2, 2, e)
-                         : (str[1] == 'x' || str[1] == 'X') //
-                             ? parse_num(str + 2, len - 2, 16, e)
-                             : parse_num(str + 1, len - 1, 8, e))
-                : parse_num(str, len, 10, e));
-}
-
-template<char... Chars>
-struct char_seq
-{
-  static constexpr char value[] = { Chars... };
-};
-
-template<isize N, isize M>
-struct binary_traits<Fix<N>, Fix<M>>
-{
-
-#define VEG_OP(Name, TypeName, Op)                                             \
-  using TypeName /* NOLINT(bugprone-macro-parentheses) */ =                    \
-    Fix<isize(usize(isize{ N }) Op usize(isize{ M }))>;                        \
-  VEG_NODISCARD VEG_INLINE static constexpr auto Name##_fn(Fix<N>, Fix<M>)     \
-    VEG_NOEXCEPT->TypeName                                                     \
-  {                                                                            \
-    return {};                                                                 \
-  }                                                                            \
-  static_assert(true, "")
-
-#define VEG_CMP(Name, TypeName, Op)                                            \
-  using TypeName /* NOLINT(bugprone-macro-parentheses) */ =                    \
-    Boolean<(N Op M) ? yes : no>;                                              \
-  VEG_NODISCARD VEG_INLINE static constexpr auto Name##_fn(Fix<N>, Fix<M>)     \
-    VEG_NOEXCEPT->TypeName                                                     \
-  {                                                                            \
-    return {};                                                                 \
-  }                                                                            \
-  static_assert(true, "")
-
-  VEG_OP(add, Add, +);
-  VEG_OP(sub, Sub, -);
-  VEG_OP(mul, Mul, *);
-  VEG_CMP(cmp_eq, CmpEq, ==);
-  VEG_CMP(cmp_neq, CmpNEq, !=);
-  VEG_CMP(cmp_lt, CmpLT, <);
-  VEG_CMP(cmp_le, CmpLE, <=);
-  VEG_CMP(cmp_gt, CmpGT, >);
-  VEG_CMP(cmp_ge, CmpGE, >=);
-
-  using Div = meta::if_t<M == 0, void, Fix<N / (M != 0 ? M : 1)>>;
-  using Mod = meta::if_t<M == 0, void, Fix<N % (M != 0 ? M : 1)>>;
-
-  VEG_NODISCARD VEG_INLINE static constexpr auto div_fn(Fix<N> /*a*/,
-                                                        Fix<M> /*b*/)
-    VEG_NOEXCEPT->Div
-  {
-    return Div();
-  }
-  VEG_NODISCARD VEG_INLINE static constexpr auto mod_fn(Fix<N> /*a*/,
-                                                        Fix<M> /*b*/)
-    VEG_NOEXCEPT->Mod
-  {
-    return Mod();
-  }
-
-#undef VEG_OP
-#undef VEG_CMP
-};
-namespace idx {
-namespace adl {
-} // namespace adl
-} // namespace idx
-} // namespace _detail
-
-inline namespace literals {
-template<char... Chars>
-VEG_INLINE constexpr auto operator"" _c() VEG_NOEXCEPT
-{
-  return Fix<_detail::parse_int(
-    _detail::char_seq<Chars...>::value, sizeof...(Chars), _detail::Error{})>{};
-}
-} // namespace literals
-} // namespace veg
-} // namespace linalg
-} // namespace proxsuite
-
-#include "proxsuite/linalg/veg/internal/epilogue.hpp"
-#endif /* end of include guard VEG_META_INT_FIX_HPP_7S9Y48TFS */

casadi/include/include/proxsuite/linalg/veg/internal/has_asan.hpp

@@ -1,17 +0,0 @@
-#ifndef VEG_HAS_ASAN_HPP_AWVAMMSFS
-#define VEG_HAS_ASAN_HPP_AWVAMMSFS
-
-#if defined(__clang__)
-#if __has_feature(address_sanitizer)
-#define VEG_HAS_ASAN 1
-#else
-#define VEG_HAS_ASAN 0
-#endif
-
-#elif defined(__SANITIZE_ADDRESS__) && __SANITIZE_ADDRESS__ == 1
-#define VEG_HAS_ASAN 1
-#else
-#define VEG_HAS_ASAN 0
-#endif
-
-#endif /* end of include guard VEG_HAS_ASAN_HPP_AWVAMMSFS */