casadi 3.6.7__cp310-none-manylinux2014_x86_64.whl → 3.7.0__cp310-none-manylinux2014_x86_64.whl

casadi/include/casadi/core/optistack.hpp

@@ -110,6 +110,8 @@ public:
 
       \identifier{18} */
   MX variable(casadi_int n=1, casadi_int m=1, const std::string& attribute="full");
+  MX variable(const Sparsity& sp, const std::string& attribute="full");
+  MX variable(const MX& symbol, const std::string& attribute="full");
 
   /** \brief Create a parameter (symbol); fixed during optimization
   *
@@ -123,6 +125,8 @@ public:
 
       \identifier{19} */
   MX parameter(casadi_int n=1, casadi_int m=1, const std::string& attribute="full");
+  MX parameter(const Sparsity& sp, const std::string& attribute="full");
+  MX parameter(const MX& symbol, const std::string& attribute="full");
 
   /** \brief Set objective
   *
@@ -130,7 +134,7 @@ public:
   * When method is called multiple times, the last call takes effect
 
       \identifier{1a} */
-  void minimize(const MX& f);
+  void minimize(const MX& f, double linear_scale=1);
 
   /// @{
   /** \brief Add constraints
@@ -158,8 +162,10 @@ public:
   *  - opti.debug.show_infeasibilities() may be used to inspect which constraints are violated
   *
       \identifier{1b} */
-  void subject_to(const MX& g);
-  void subject_to(const std::vector<MX>& g);
+  void subject_to(const MX& g, const Dict& options=Dict());
+  void subject_to(const std::vector<MX>& g, const Dict& options=Dict());
+  void subject_to(const MX& g, const DM& linear_scale, const Dict& options=Dict());
+  void subject_to(const std::vector<MX>& g, const DM& linear_scale, const Dict& options=Dict());
   /// @}
 
   /// Clear constraints
@@ -214,8 +220,21 @@ public:
       \identifier{27t} */
   void set_domain(const MX& x, const std::string& domain);
 
-  /// @}
+  /** \brief Set scale of a decision variable
+  * 
+  * (x-offset)/scale will be used in the optimization problem
+  *
+  * \param[in] x decision variable
+  * \param[in] scale scaling value (default: 1)
+  * \param[in] offset scaling value (default: 0)
+  *
+  * \verbatim
+  * opti.set_linear_scale(x, 20)
+  * opti.set_linear_scale(x, 20, 273.15)
+  * \endverbatim
 
+      \identifier{2bs} */
+  void set_linear_scale(const MX& x, const DM& scale, const DM& offset=0);
 
   /// Crunch the numbers; solve the problem
   OptiSol solve();
@@ -269,6 +288,11 @@ public:
   std::vector<MX> value_variables() const;
   std::vector<MX> value_parameters() const;
 
+  /** \brief Scale a helper function constructed via opti.x, opti.g, ...
+
+      \identifier{2ci} */
+  Function scale_helper(const Function& h) const;
+
   /** \brief get the dual variable
   *
   * m must be a constraint expression.
@@ -319,6 +343,11 @@ public:
   MX lbg() const;
   MX ubg() const;
 
+  DM x_linear_scale() const;
+  DM x_linear_scale_offset() const;
+  DM g_linear_scale() const;
+  double f_linear_scale() const;
+
   /** \brief Get all (scalarised) dual variables as a symbolic column vector
   *
   * Useful for obtaining the Lagrange Hessian:
@@ -480,7 +509,7 @@ public:
     casadi_int stop;
   };
   struct MetaCon : IndexAbstraction {
-    MetaCon() :  n(1), flipped(false) {}
+    MetaCon() :  n(1), flipped(false), linear_scale(1) {}
     MX original;  // original expression
     MX canon; // Canonical expression
     ConstraintType type;
@@ -491,6 +520,7 @@ public:
     MX dual_canon;
     MX dual;
     Dict extra;
+    DM linear_scale;
   };
   struct MetaVar : IndexAbstraction {
     std::string attribute;
@@ -571,11 +601,15 @@ public:
   MX x_lookup(casadi_index i) const;
   MX g_lookup(casadi_index i) const;
 
-  std::string x_describe(casadi_index i) const;
-  std::string g_describe(casadi_index i) const;
-  std::string describe(const MX& x, casadi_index indent=0) const;
+  casadi_index g_index_reduce_g(casadi_index i) const;
+  casadi_index g_index_reduce_x(casadi_index i) const;
+  casadi_index g_index_unreduce_g(casadi_index i) const;
+
+  std::string x_describe(casadi_index i, const Dict& opts=Dict()) const;
+  std::string g_describe(casadi_index i, const Dict& opts=Dict()) const;
+  std::string describe(const MX& x, casadi_index indent=0, const Dict& opts=Dict()) const;
 
-  void show_infeasibilities(double tol=0) const;
+  void show_infeasibilities(double tol=0, const Dict& opts=Dict()) const;
 
   void solve_prepare();
   DMDict solve_actual(const DMDict& args);

casadi/include/casadi/core/printable.hpp

@@ -26,7 +26,15 @@
 #ifndef CASADI_PRINTABLE_HPP
 #define CASADI_PRINTABLE_HPP
 
+#if __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnonnull"
+#endif
 #include <iostream>
+#if __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
 #include <sstream>
 #include <streambuf>
 #include <string>

casadi/include/casadi/core/resource.hpp

@@ -0,0 +1,107 @@
+/*
+ *    This file is part of CasADi.
+ *
+ *    CasADi -- A symbolic framework for dynamic optimization.
+ *    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
+ *                            KU Leuven. All rights reserved.
+ *    Copyright (C) 2011-2014 Greg Horn
+ *
+ *    CasADi is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License as published by the Free Software Foundation; either
+ *    version 3 of the License, or (at your option) any later version.
+ *
+ *    CasADi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with CasADi; if not, write to the Free Software
+ *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+
+#ifndef CASADI_RESOURCE_HPP
+#define CASADI_RESOURCE_HPP
+
+#include "shared_object.hpp"
+#include "printable.hpp"
+#include "generic_type.hpp"
+
+namespace casadi {
+  // Forward declaration
+  class ResourceInternal;
+  class SerializingStream;
+  class DeserializingStream;
+
+  /** \brief RAII class for reading from a zip file
+
+      \identifier{2cn} */
+  class CASADI_EXPORT Resource
+    : public SharedObject,
+      public SWIG_IF_ELSE(PrintableCommon, Printable<Resource>) {
+  public:
+    /** \brief Initialize with a path 
+    *
+    * If the path is a directory or empty, the path is passed through to the consumer.
+    * Otherwise, the zip file is extracted to a temporary directory.
+    *
+    * Upon destruction, the temporary directory is removed.
+
+        \identifier{2co} */
+    Resource(const std::string& path);
+    /// Default constructor
+    explicit Resource();
+
+    /// Readable name of the public class
+    static std::string type_name() {return "Resource";}
+
+    /// Check if a particular cast is allowed
+    static bool test_cast(const SharedObjectInternal* ptr);
+
+#ifndef SWIG
+      /** \brief  Create from node
+
+          \identifier{2cp} */
+      static Resource create(ResourceInternal *node);
+
+      ResourceInternal* get() const;
+
+      /// Access a member function or object
+      const ResourceInternal* operator->() const;
+
+      /// Access a member function or object
+      ResourceInternal* operator->();
+
+      /// Reference to internal structure
+      const ResourceInternal& operator*() const;
+#endif
+
+      /// Get path for a consumer
+      const std::string& path() const;
+
+    /** \brief Serialize an object
+
+        \identifier{2cq} */
+    void serialize(SerializingStream &s) const;
+
+    /** \brief Change option after object creation for debugging
+
+      * This is only possible for a selected number of options that do not change the numerical
+      * results of the comput
+
+        \identifier{2d4} */
+    void change_option(const std::string& option_name,
+      const GenericType& option_value);
+
+    /** \brief Deserialize with type disambiguation
+
+        \identifier{2cr} */
+    static Resource deserialize(DeserializingStream& s);
+  };
+
+} // namespace casadi
+
+#endif // CASADI_RESOURCE_HPP

casadi/include/casadi/core/runtime/casadi_blazing_1d_boor_eval.hpp

@@ -0,0 +1,112 @@
+//
+//    MIT No Attribution
+//
+//    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl, KU Leuven.
+//
+//    Permission is hereby granted, free of charge, to any person obtaining a copy of this
+//    software and associated documentation files (the "Software"), to deal in the Software
+//    without restriction, including without limitation the rights to use, copy, modify,
+//    merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so.
+//
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+//    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+// SYMBOL "blazing_1d_boor_eval"
+template<typename T1>
+void casadi_blazing_1d_boor_eval(T1* f, T1* J, T1* H, const T1* all_knots, const casadi_int* offset, const T1* c, const T1* dc, const T1* ddc, const T1* all_x, const casadi_int* lookup_mode, casadi_int* iw, T1* w) { // NOLINT(whitespace/line_length)
+  casadi_int n_dims = 1;
+  casadi_int m = 1;
+  casadi_int n_iter, i, pivot;
+  casadi_int *boor_offset, *starts, *index, *coeff_offset;
+  T1 *cumprod;
+  boor_offset = iw; iw+=n_dims+1;
+  starts = iw; iw+=n_dims;
+  index = iw; iw+=n_dims;
+  coeff_offset = iw;
+  cumprod = w; w+= n_dims+1;
+  boor_offset[0] = 0;
+  cumprod[n_dims] = 1;
+  coeff_offset[n_dims] = 0;
+
+  casadi_int stride1 = offset[1]-offset[0]-4;
+
+  simde__m256d zero = simde_mm256_set1_pd(0.0);
+
+  simde__m256d boor_start_0000 = zero;
+  simde__m256d boor_start_1111 = simde_mm256_set1_pd(1.0);
+  simde__m256d boor_start_0001 = simde_mm256_set_pd(1.0, 0.0, 0.0, 0.0);
+  simde__m256d boor_start_0010 = simde_mm256_set_pd(0.0, 1.0, 0.0, 0.0);
+
+  simde__m256d boor0_d3;
+  simde__m256d boor0_d2;
+  simde__m256d boor0_d1;
+  simde__m256d boor0_d0;
+
+    const T1* knots;
+    T1 x;
+    casadi_int degree, n_knots, n_b, L, start;
+    degree = 3;
+    knots = all_knots + offset[0];
+    n_knots = offset[0+1]-offset[0];
+    n_b = n_knots-degree-1;
+    x = all_x[0];
+    L = casadi_low(x, knots+degree, n_knots-2*degree, lookup_mode[0]);
+    start = L;
+    if (start>n_b-degree-1) start = n_b-degree-1;
+    starts[0] = start;
+    boor0_d3 = boor_start_0000;
+    if (x>=knots[0] && x<=knots[n_knots-1]) {
+      if (x==knots[1]) {
+        boor0_d3 = boor_start_1111;
+      } else if (x==knots[n_knots-1]) {
+        boor0_d3 = boor_start_0001;
+      } else if (knots[L+degree]==x) {
+        boor0_d3 = boor_start_0010;
+      } else {
+        boor0_d3 = boor_start_0001;
+      }
+    }
+    casadi_blazing_de_boor(x, knots+start, &boor0_d0, &boor0_d1, &boor0_d2, &boor0_d3);
+
+  double boor0_d0v[4];
+  simde_mm256_storeu_pd(boor0_d0v, boor0_d0);
+
+  const T1* C = c+starts[0];
+  if (f) {
+    f[0] = 0;
+    for (casadi_int i=0;i<4;++i) {
+      f[0] += boor0_d0v[i]*C[i];
+    }
+  }
+
+  // First derivative
+  if (dc && J) {
+    C = dc+starts[0];
+
+    double boor0_d1v[4];
+    simde_mm256_storeu_pd(boor0_d1v, boor0_d1);
+
+    J[0] = 0;
+    for (casadi_int i=0;i<3;++i) {
+      J[0] += boor0_d1v[i+1]*C[i];
+    }
+  }
+
+  if (ddc && H) {
+    C = ddc+starts[0];
+
+    double boor0_d2v[4];
+    simde_mm256_storeu_pd(boor0_d2v, boor0_d2);
+
+    H[0] = 0;
+    for (casadi_int i=0;i<2;++i) {
+      H[0] += boor0_d2v[i+2]*C[i];
+    }
+  }
+}

casadi/include/casadi/core/runtime/casadi_blazing_2d_boor_eval.hpp

@@ -0,0 +1,311 @@
+//
+//    MIT No Attribution
+//
+//    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl, KU Leuven.
+//
+//    Permission is hereby granted, free of charge, to any person obtaining a copy of this
+//    software and associated documentation files (the "Software"), to deal in the Software
+//    without restriction, including without limitation the rights to use, copy, modify,
+//    merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so.
+//
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+//    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+// SYMBOL "blazing_2d_boor_eval"
+template<typename T1>
+void casadi_blazing_2d_boor_eval(T1* f, T1* J, T1* H, const T1* all_knots, const casadi_int* offset, const T1* c, const T1* dc, const T1* ddc, const T1* all_x, const casadi_int* lookup_mode, casadi_int* iw, T1* w) { // NOLINT(whitespace/line_length)
+  casadi_int n_dims = 2;
+  casadi_int m = 1;
+  casadi_int n_iter, i, pivot;
+  casadi_int *boor_offset, *starts, *index, *coeff_offset;
+  T1 *cumprod;
+  boor_offset = iw; iw+=n_dims+1;
+  starts = iw; iw+=n_dims;
+  index = iw; iw+=n_dims;
+  coeff_offset = iw;
+  cumprod = w; w+= n_dims+1;
+  boor_offset[0] = 0;
+  cumprod[n_dims] = 1;
+  coeff_offset[n_dims] = 0;
+
+  casadi_int stride1 = offset[1]-offset[0]-4;
+
+  simde__m256d zero = simde_mm256_set1_pd(0.0);
+
+  simde__m256d boor_start_0000 = zero;
+  simde__m256d boor_start_1111 = simde_mm256_set1_pd(1.0);
+  simde__m256d boor_start_0001 = simde_mm256_set_pd(1.0, 0.0, 0.0, 0.0);
+  simde__m256d boor_start_0010 = simde_mm256_set_pd(0.0, 1.0, 0.0, 0.0);
+
+  simde__m256d boor0_d3;
+  simde__m256d boor0_d2;
+  simde__m256d boor0_d1;
+  simde__m256d boor0_d0;
+
+  simde__m256d boor1_d3;
+  simde__m256d boor1_d2;
+  simde__m256d boor1_d1;
+  simde__m256d boor1_d0;
+
+    const T1* knots;
+    T1 x;
+    casadi_int degree, n_knots, n_b, L, start;
+    degree = 3;
+    knots = all_knots + offset[0];
+    n_knots = offset[0+1]-offset[0];
+    n_b = n_knots-degree-1;
+    x = all_x[0];
+    L = casadi_low(x, knots+degree, n_knots-2*degree, lookup_mode[0]);
+    start = L;
+    if (start>n_b-degree-1) start = n_b-degree-1;
+    starts[0] = start;
+    boor0_d3 = boor_start_0000;
+    if (x>=knots[0] && x<=knots[n_knots-1]) {
+      if (x==knots[1]) {
+        boor0_d3 = boor_start_1111;
+      } else if (x==knots[n_knots-1]) {
+        boor0_d3 = boor_start_0001;
+      } else if (knots[L+degree]==x) {
+        boor0_d3 = boor_start_0010;
+      } else {
+        boor0_d3 = boor_start_0001;
+      }
+    }
+    casadi_blazing_de_boor(x, knots+start, &boor0_d0, &boor0_d1, &boor0_d2, &boor0_d3);
+
+    knots = all_knots + offset[1];
+    n_knots = offset[1+1]-offset[1];
+    n_b = n_knots-degree-1;
+    x = all_x[1];
+    L = casadi_low(x, knots+degree, n_knots-2*degree, lookup_mode[1]);
+    start = L;
+    if (start>n_b-degree-1) start = n_b-degree-1;
+    starts[1] = start;
+    boor1_d3 = boor_start_0000;
+    if (x>=knots[0] && x<=knots[n_knots-1]) {
+      if (x==knots[1]) {
+        boor1_d3 = boor_start_1111;
+      } else if (x==knots[n_knots-1]) {
+        boor1_d3 = boor_start_0001;
+      } else if (knots[L+degree]==x) {
+        boor1_d3 = boor_start_0010;
+      } else {
+        boor1_d3 = boor_start_0001;
+      }
+    }
+    casadi_blazing_de_boor(x, knots+start, &boor1_d0, &boor1_d1, &boor1_d2, &boor1_d3);
+
+  simde__m256d C[4];
+
+  for (int j=0;j<4;++j) {
+    C[j] = simde_mm256_loadu_pd(c+(starts[1]+j)*stride1+starts[0]);
+  }
+
+  simde__m256d a, b0, b1, b2, b3, c0, c1, c2, c3, r;
+  simde__m256d ab[4];
+  simde__m128d r0, r1;
+
+  a = boor0_d0;
+  b0 = simde_mm256_permute4x64_pd(boor1_d0, SIMDE_MM_SHUFFLE(0, 0, 0, 0));
+  b1 = simde_mm256_permute4x64_pd(boor1_d0, SIMDE_MM_SHUFFLE(1, 1, 1, 1));
+  b2 = simde_mm256_permute4x64_pd(boor1_d0, SIMDE_MM_SHUFFLE(2, 2, 2, 2));
+  b3 = simde_mm256_permute4x64_pd(boor1_d0, SIMDE_MM_SHUFFLE(3, 3, 3, 3));
+
+  // Need to compute sum_ab C_ab A_a B_b
+
+  // Step 1: Outer product a b: A_a B_b
+  ab[0] = simde_mm256_mul_pd(a, b0);
+  ab[1] = simde_mm256_mul_pd(a, b1);
+  ab[2] = simde_mm256_mul_pd(a, b2);
+  ab[3] = simde_mm256_mul_pd(a, b3);
+
+  // Sum over b axis: sum_b C_ab * (A_a B_b)_b
+  // r <- r + ab[i]*C[i]
+  r = simde_mm256_set1_pd(0);
+  r = simde_mm256_fmadd_pd(ab[0], C[0], r);
+  r = simde_mm256_fmadd_pd(ab[1], C[1], r);
+  r = simde_mm256_fmadd_pd(ab[2], C[2], r);
+  r = simde_mm256_fmadd_pd(ab[3], C[3], r);
+
+  if (f) {
+    // Sum all cab entries
+    r0  = simde_mm256_castpd256_pd128(r);
+    r1 = simde_mm256_extractf128_pd(r, 1);
+    r0  = simde_mm_add_pd(r0, r1);
+    f[0] = simde_mm_cvtsd_f64(simde_mm_add_sd(r0, simde_mm_unpackhi_pd(r0, r0)));
+  }
+
+  // First derivative
+  if (dc && J) {
+    stride1 = offset[1]-offset[0]-4-1;
+    for (int j=0;j<4;++j) {
+      C[j] = simde_mm256_loadu_pd(dc+(starts[1]+j)*stride1+starts[0]-1);
+    }
+    dc += stride1*(offset[2]-offset[1]-4);
+
+    a = boor0_d1;
+    ab[0] = simde_mm256_mul_pd(a, b0);
+    ab[1] = simde_mm256_mul_pd(a, b1);
+    ab[2] = simde_mm256_mul_pd(a, b2);
+    ab[3] = simde_mm256_mul_pd(a, b3);
+
+    // Sum over b axis: sum_b C_abc * (A_a B_b)_b
+    // cab <- cab + ab[i]*C[i]
+    r = simde_mm256_set1_pd(0);
+    r = simde_mm256_fmadd_pd(ab[0], C[0], r);
+    r = simde_mm256_fmadd_pd(ab[1], C[1], r);
+    r = simde_mm256_fmadd_pd(ab[2], C[2], r);
+    r = simde_mm256_fmadd_pd(ab[3], C[3], r);
+
+    // Sum all r entries
+    r0  = simde_mm256_castpd256_pd128(r);
+    r1 = simde_mm256_extractf128_pd(r, 1);
+    r0  = simde_mm_add_pd(r0, r1);
+    J[0] = simde_mm_cvtsd_f64(simde_mm_add_sd(r0, simde_mm_unpackhi_pd(r0, r0)));
+
+
+    stride1 = offset[1]-offset[0]-4;
+    for (int j=0;j<4;++j) {
+      if (j==0) {
+        C[j] = zero;
+      } else {
+        C[j] = simde_mm256_loadu_pd(dc+(starts[1]+j-1)*stride1+starts[0]);
+      }
+    }
+
+    a = boor0_d0;
+
+    b0 = simde_mm256_permute4x64_pd(boor1_d1, SIMDE_MM_SHUFFLE(0, 0, 0, 0));
+    b1 = simde_mm256_permute4x64_pd(boor1_d1, SIMDE_MM_SHUFFLE(1, 1, 1, 1));
+    b2 = simde_mm256_permute4x64_pd(boor1_d1, SIMDE_MM_SHUFFLE(2, 2, 2, 2));
+    b3 = simde_mm256_permute4x64_pd(boor1_d1, SIMDE_MM_SHUFFLE(3, 3, 3, 3));
+
+    ab[0] = simde_mm256_mul_pd(a, b0);
+    ab[1] = simde_mm256_mul_pd(a, b1);
+    ab[2] = simde_mm256_mul_pd(a, b2);
+    ab[3] = simde_mm256_mul_pd(a, b3);
+
+    // Sum over b axis: sum_b C_abc * (A_a B_b)_b
+    // cab <- cab + ab[i]*C[i]
+    r = simde_mm256_set1_pd(0);
+    r = simde_mm256_fmadd_pd(ab[0], C[0], r);
+    r = simde_mm256_fmadd_pd(ab[1], C[1], r);
+    r = simde_mm256_fmadd_pd(ab[2], C[2], r);
+    r = simde_mm256_fmadd_pd(ab[3], C[3], r);
+
+    // Sum all r entries
+    r0  = simde_mm256_castpd256_pd128(r);
+    r1 = simde_mm256_extractf128_pd(r, 1);
+    r0  = simde_mm_add_pd(r0, r1);
+    J[1] = simde_mm_cvtsd_f64(simde_mm_add_sd(r0, simde_mm_unpackhi_pd(r0, r0)));
+  }
+
+  if (ddc && H) {
+    stride1 = offset[1]-offset[0]-4-2;
+    for (int j=0;j<4;++j) {
+      C[j] = simde_mm256_loadu_pd(ddc+(starts[1]+j)*stride1+starts[0]-2);
+    }
+    ddc += stride1*(offset[2]-offset[1]-4);
+
+    a = boor0_d2;
+    b0 = simde_mm256_permute4x64_pd(boor1_d0, SIMDE_MM_SHUFFLE(0, 0, 0, 0));
+    b1 = simde_mm256_permute4x64_pd(boor1_d0, SIMDE_MM_SHUFFLE(1, 1, 1, 1));
+    b2 = simde_mm256_permute4x64_pd(boor1_d0, SIMDE_MM_SHUFFLE(2, 2, 2, 2));
+    b3 = simde_mm256_permute4x64_pd(boor1_d0, SIMDE_MM_SHUFFLE(3, 3, 3, 3));
+
+    ab[0] = simde_mm256_mul_pd(a, b0);
+    ab[1] = simde_mm256_mul_pd(a, b1);
+    ab[2] = simde_mm256_mul_pd(a, b2);
+    ab[3] = simde_mm256_mul_pd(a, b3);
+    // Sum over b axis: sum_b C_abc * (A_a B_b)_b
+    // cab <- cab + ab[i]*C[i]
+    r = simde_mm256_set1_pd(0);
+    r = simde_mm256_fmadd_pd(ab[0], C[0], r);
+    r = simde_mm256_fmadd_pd(ab[1], C[1], r);
+    r = simde_mm256_fmadd_pd(ab[2], C[2], r);
+    r = simde_mm256_fmadd_pd(ab[3], C[3], r);
+
+    // Sum all r entries
+    r0  = simde_mm256_castpd256_pd128(r);
+    r1 = simde_mm256_extractf128_pd(r, 1);
+    r0  = simde_mm_add_pd(r0, r1);
+    H[0] = simde_mm_cvtsd_f64(simde_mm_add_sd(r0, simde_mm_unpackhi_pd(r0, r0)));
+
+    stride1 = offset[1]-offset[0]-4;
+    for (int j=0;j<4;++j) {
+      if (j<=1) {
+        C[j] = zero;
+      } else {
+        C[j] = simde_mm256_loadu_pd(ddc+(starts[1]+j-2)*stride1+starts[0]);
+      }
+    }
+    ddc += stride1*(offset[2]-offset[1]-4-2);
+
+    a = boor0_d0;
+    b0 = simde_mm256_permute4x64_pd(boor1_d2, SIMDE_MM_SHUFFLE(0, 0, 0, 0));
+    b1 = simde_mm256_permute4x64_pd(boor1_d2, SIMDE_MM_SHUFFLE(1, 1, 1, 1));
+    b2 = simde_mm256_permute4x64_pd(boor1_d2, SIMDE_MM_SHUFFLE(2, 2, 2, 2));
+    b3 = simde_mm256_permute4x64_pd(boor1_d2, SIMDE_MM_SHUFFLE(3, 3, 3, 3));
+
+    ab[0] = simde_mm256_mul_pd(a, b0);
+    ab[1] = simde_mm256_mul_pd(a, b1);
+    ab[2] = simde_mm256_mul_pd(a, b2);
+    ab[3] = simde_mm256_mul_pd(a, b3);
+    // Sum over b axis: sum_b C_abc * (A_a B_b)_b
+    // cab <- cab + ab[i]*C[i]
+    r = simde_mm256_set1_pd(0);
+    r = simde_mm256_fmadd_pd(ab[0], C[0], r);
+    r = simde_mm256_fmadd_pd(ab[1], C[1], r);
+    r = simde_mm256_fmadd_pd(ab[2], C[2], r);
+    r = simde_mm256_fmadd_pd(ab[3], C[3], r);
+
+    // Sum all r entries
+    r0  = simde_mm256_castpd256_pd128(r);
+    r1 = simde_mm256_extractf128_pd(r, 1);
+    r0  = simde_mm_add_pd(r0, r1);
+    H[3] = simde_mm_cvtsd_f64(simde_mm_add_sd(r0, simde_mm_unpackhi_pd(r0, r0)));
+
+    stride1 = offset[1]-offset[0]-5;
+    for (int j=0;j<4;++j) {
+      if (j==0) {
+        C[j] = zero;
+      } else {
+        C[j] = simde_mm256_loadu_pd(ddc+(starts[1]+j-1)*stride1+starts[0]-1);
+      }
+    }
+    ddc += stride1*(offset[3]-offset[2]-5);
+
+    a = boor0_d1;
+
+    b0 = simde_mm256_permute4x64_pd(boor1_d1, SIMDE_MM_SHUFFLE(0, 0, 0, 0));
+    b1 = simde_mm256_permute4x64_pd(boor1_d1, SIMDE_MM_SHUFFLE(1, 1, 1, 1));
+    b2 = simde_mm256_permute4x64_pd(boor1_d1, SIMDE_MM_SHUFFLE(2, 2, 2, 2));
+    b3 = simde_mm256_permute4x64_pd(boor1_d1, SIMDE_MM_SHUFFLE(3, 3, 3, 3));
+
+    ab[0] = simde_mm256_mul_pd(a, b0);
+    ab[1] = simde_mm256_mul_pd(a, b1);
+    ab[2] = simde_mm256_mul_pd(a, b2);
+    ab[3] = simde_mm256_mul_pd(a, b3);
+    // Sum over b axis: sum_b C_abc * (A_a B_b)_b
+    // cab <- cab + ab[i]*C[i]
+    r = simde_mm256_set1_pd(0);
+    r = simde_mm256_fmadd_pd(ab[0], C[0], r);
+    r = simde_mm256_fmadd_pd(ab[1], C[1], r);
+    r = simde_mm256_fmadd_pd(ab[2], C[2], r);
+    r = simde_mm256_fmadd_pd(ab[3], C[3], r);
+
+    // Sum all r entries
+    r0  = simde_mm256_castpd256_pd128(r);
+    r1 = simde_mm256_extractf128_pd(r, 1);
+    r0  = simde_mm_add_pd(r0, r1);
+    H[1] = H[2] = simde_mm_cvtsd_f64(simde_mm_add_sd(r0, simde_mm_unpackhi_pd(r0, r0)));
+
+  }
+
+}