eqc-models 0.9.9__tar.gz → 0.10.1__tar.gz

{eqc_models-0.9.9/eqc_models.egg-info → eqc_models-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: eqc-models
-Version: 0.9.9
+Version: 0.10.1
 Summary: Optimization and ML modeling package targeting EQC devices
 Author: Quantum Computing Inc.
 Author-email: support@quantumcomputinginc.com
@@ -13,6 +13,7 @@ License-File: LICENSE.txt
 Requires-Dist: numpy<2,>=1.22.1
 Requires-Dist: networkx<3,>=2.6.3
 Requires-Dist: pandas>=2.1.0
+Requires-Dist: scikit-learn>=1.2.1
 Requires-Dist: qci-client<5,>=4.3.0
 Requires-Dist: emucore-direct==1.0.6
 Provides-Extra: direct

eqc_models-0.10.1/compile_extensions.py

@@ -0,0 +1,67 @@
+import os
+import sys
+from setuptools import Extension
+from setuptools.command.build_py import build_py as _build_py
+import numpy
+
+# # Set cvqboost compile args
+# if sys.platform == "darwin":
+#     openmp_prefix = os.environ.get(
+#         "LIBOMP_PREFIX", "/opt/homebrew/opt/libomp"
+#     )
+#     openmp_include = os.path.join(openmp_prefix, "include")
+#     openmp_lib = os.path.join(openmp_prefix, "lib", "libomp.a")
+#     extra_compile_args_cvq = [
+#         "-Xpreprocessor",
+#         "-fopenmp",
+#         "-O3",
+#         "-ffast-math",
+#         "-march=native",
+#     ]
+#     extra_link_args_cvq = [openmp_lib, "-O3", "-march=native"]
+# elif sys.platform.startswith("linux"):
+#     extra_compile_args_cvq = [
+#         "-static-libgcc",
+#         "-fopenmp",
+#         "-O3",
+#         "-ffast-math",
+#     ]
+#     extra_link_args_cvq = [
+#         "-static-libgcc",
+#         "-static-libstdc++",
+#         "-fopenmp",
+#         "-O3",
+#     ]
+# elif sys.platform == "win32":
+#     extra_compile_args_cvq = ["/openmp"]
+#     extra_link_args_cvq = []
+
+# Modules to be compiled and include_dirs when necessary
+extensions = [
+    Extension(
+        "eqc_models.base.polyeval",
+        ["eqc_models/base/polyeval.pyx"],
+        include_dirs=[numpy.get_include()],
+        extra_compile_args=["-O3", "-ffast-math"],
+    ),
+    # Extension(
+    #     "eqc_models.ml.cvqboost_hamiltonian",
+    #     ["eqc_models/ml/cvqboost_hamiltonian.pyx"],
+    #     include_dirs=[numpy.get_include()],
+    #     extra_compile_args=extra_compile_args_cvq,
+    #     extra_link_args=extra_link_args_cvq,
+    # ),
+]
+
+
+class build_py(_build_py):
+    def run(self):
+        self.run_command("build_ext")
+        return super().run()
+
+    def initialize_options(self):
+        super().initialize_options()
+        if self.distribution.ext_modules == None:
+            self.distribution.ext_modules = []
+
+        self.distribution.ext_modules.extend(extensions)

{eqc_models-0.9.9 → eqc_models-0.10.1}/docs/build/html/_static/pygments.css

@@ -6,9 +6,9 @@ span.linenos.special { color: #000000; background-color: #ffffc0; padding-left:
 .highlight .hll { background-color: #ffffcc }
 .highlight { background: #f8f8f8; }
 .highlight .c { color: #3D7B7B; font-style: italic } /* Comment */
-.highlight .err { border: 1px solid #FF0000 } /* Error */
+.highlight .err { border: 1px solid #F00 } /* Error */
 .highlight .k { color: #008000; font-weight: bold } /* Keyword */
-.highlight .o { color: #666666 } /* Operator */
+.highlight .o { color: #666 } /* Operator */
 .highlight .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */
 .highlight .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */
 .highlight .cp { color: #9C6500 } /* Comment.Preproc */
@@ -25,34 +25,34 @@ span.linenos.special { color: #000000; background-color: #ffffc0; padding-left:
 .highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */
 .highlight .gs { font-weight: bold } /* Generic.Strong */
 .highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
-.highlight .gt { color: #0044DD } /* Generic.Traceback */
+.highlight .gt { color: #04D } /* Generic.Traceback */
 .highlight .kc { color: #008000; font-weight: bold } /* Keyword.Constant */
 .highlight .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */
 .highlight .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */
 .highlight .kp { color: #008000 } /* Keyword.Pseudo */
 .highlight .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */
 .highlight .kt { color: #B00040 } /* Keyword.Type */
-.highlight .m { color: #666666 } /* Literal.Number */
+.highlight .m { color: #666 } /* Literal.Number */
 .highlight .s { color: #BA2121 } /* Literal.String */
 .highlight .na { color: #687822 } /* Name.Attribute */
 .highlight .nb { color: #008000 } /* Name.Builtin */
-.highlight .nc { color: #0000FF; font-weight: bold } /* Name.Class */
-.highlight .no { color: #880000 } /* Name.Constant */
-.highlight .nd { color: #AA22FF } /* Name.Decorator */
+.highlight .nc { color: #00F; font-weight: bold } /* Name.Class */
+.highlight .no { color: #800 } /* Name.Constant */
+.highlight .nd { color: #A2F } /* Name.Decorator */
 .highlight .ni { color: #717171; font-weight: bold } /* Name.Entity */
 .highlight .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */
-.highlight .nf { color: #0000FF } /* Name.Function */
+.highlight .nf { color: #00F } /* Name.Function */
 .highlight .nl { color: #767600 } /* Name.Label */
-.highlight .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
+.highlight .nn { color: #00F; font-weight: bold } /* Name.Namespace */
 .highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */
 .highlight .nv { color: #19177C } /* Name.Variable */
-.highlight .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
-.highlight .w { color: #bbbbbb } /* Text.Whitespace */
-.highlight .mb { color: #666666 } /* Literal.Number.Bin */
-.highlight .mf { color: #666666 } /* Literal.Number.Float */
-.highlight .mh { color: #666666 } /* Literal.Number.Hex */
-.highlight .mi { color: #666666 } /* Literal.Number.Integer */
-.highlight .mo { color: #666666 } /* Literal.Number.Oct */
+.highlight .ow { color: #A2F; font-weight: bold } /* Operator.Word */
+.highlight .w { color: #BBB } /* Text.Whitespace */
+.highlight .mb { color: #666 } /* Literal.Number.Bin */
+.highlight .mf { color: #666 } /* Literal.Number.Float */
+.highlight .mh { color: #666 } /* Literal.Number.Hex */
+.highlight .mi { color: #666 } /* Literal.Number.Integer */
+.highlight .mo { color: #666 } /* Literal.Number.Oct */
 .highlight .sa { color: #BA2121 } /* Literal.String.Affix */
 .highlight .sb { color: #BA2121 } /* Literal.String.Backtick */
 .highlight .sc { color: #BA2121 } /* Literal.String.Char */
@@ -67,9 +67,9 @@ span.linenos.special { color: #000000; background-color: #ffffc0; padding-left:
 .highlight .s1 { color: #BA2121 } /* Literal.String.Single */
 .highlight .ss { color: #19177C } /* Literal.String.Symbol */
 .highlight .bp { color: #008000 } /* Name.Builtin.Pseudo */
-.highlight .fm { color: #0000FF } /* Name.Function.Magic */
+.highlight .fm { color: #00F } /* Name.Function.Magic */
 .highlight .vc { color: #19177C } /* Name.Variable.Class */
 .highlight .vg { color: #19177C } /* Name.Variable.Global */
 .highlight .vi { color: #19177C } /* Name.Variable.Instance */
 .highlight .vm { color: #19177C } /* Name.Variable.Magic */
-.highlight .il { color: #666666 } /* Literal.Number.Integer.Long */
+.highlight .il { color: #666 } /* Literal.Number.Integer.Long */

{eqc_models-0.9.9 → eqc_models-0.10.1}/docs/source/dependencies.rst

@@ -9,5 +9,6 @@ Packages
 - ``numpy>=1.22.1, <2``
 - ``networkx>=2.6.3, <3``
 - ``pandas>=2.1.0``
+- ``scikit-learn>=1.2.1``
 - ``qci-client>=4.3.0, <5``
 - ``emucore-direct==1.0.6``

{eqc_models-0.9.9 → eqc_models-0.10.1}/docs/source/eqc_models.rst

@@ -38,6 +38,14 @@ eqc\_models.assignment
    :undoc-members:
    :show-inheritance:
 
+eqc\_models.combinatorics
+--------------------------
+
+.. automodule:: eqc_models.combinatorics
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
 eqc\_models.graph
 --------------------
 

{eqc_models-0.9.9 → eqc_models-0.10.1}/eqc_models/algorithms/penaltymultiplier.py

@@ -33,6 +33,14 @@ class PenaltyMultiplierAlgorithm(Algorithm):
     penalties : List
         The values for penalties found at each algorithm iteration. A penalty of 0
         indicates algorithm termination.
+    penalty_threshold : float
+        This value is the cutoff for penalty values that are threated as 0. Default
+        is 1e-6. 
+    progress_threshold : float
+        This value is the cutoff for checking for progress on reducing the penalty
+        value. The current penalty is compared to the average of the previous two
+        and if the absolute difference is less than this value, then the algorithm
+        stops, reporting progress has not been made. The default value is 1e-4.
     dynamic_range : List
         The values for the dynamic range of the unconstrained problem formulation,
         which is useful for identifying difficulty in representation of the problem
@@ -50,7 +58,7 @@ class PenaltyMultiplierAlgorithm(Algorithm):
     This example uses the quadratic assignment problem and the known multiplier to test 
     the implementation of the algorithm.
 
-    >>> from eqc_models.solvers.qciclient import Dirac3CloudSolver
+    >>> from eqc_models.solvers.qciclient import Dirac3IntegerCloudSolver
     >>> from eqc_models.assignment.qap import QAPModel
     >>> A = np.array([[0, 5, 8, 0, 1],
     ...               [0, 0, 0, 10, 15],
@@ -68,10 +76,10 @@ class PenaltyMultiplierAlgorithm(Algorithm):
     ...               [7, 5, 8, 5, 7],
     ...               [1, 9, 2, 9, 2.]])
     >>> model = QAPModel(A, B, C)
-    >>> solver = Dirac3CloudSolver() # must be configured with environment variables
+    >>> solver = Dirac3IntegerCloudSolver() # must be configured with environment variables
     >>> algo = PenaltyMultiplierAlgorithm(model, solver)
     >>> algo.upper_bound = 330.64
-    >>> algo.run(relaxation_schedule=2, mean_photon_number=0.15, normalized_loss_rate=4, num_samples=5) # doctest: +ELLIPSIS
+    >>> algo.run(relaxation_schedule=2, num_samples=5) # doctest: +ELLIPSIS
     2... RUNNING... COMPLETED...
     >>> algo.alphas[-1] # doctest: +SKIP
     106.25
@@ -80,7 +88,8 @@ class PenaltyMultiplierAlgorithm(Algorithm):
  
     """
 
-    def __init__(self, model : ConstraintModel, solver : ModelSolver):
+    def __init__(self, model : ConstraintModel, solver : ModelSolver, penalty_threshold:float=1e-6,
+                 progress_threshold : float = 1e-4):
         self.model = model
         self.solver = solver
         # ub = np.max(model.quad_objective)
@@ -95,6 +104,8 @@ class PenaltyMultiplierAlgorithm(Algorithm):
         self.alphas = None
         self.dynamic_range = None
         self.responses = None
+        self.penalty_threshold = penalty_threshold
+        self.progress_threshold = progress_threshold
 
     @property
     def upper_bound(self) -> float:
@@ -141,7 +152,7 @@ class PenaltyMultiplierAlgorithm(Algorithm):
         else:
             penalty = None
             
-        while penalty is None or penalty > 1e-6:
+        while penalty is None or penalty > self.penalty_threshold:
             log.info("NEW RUN")
             log.info("SETTING MULTIPLIER %f", alpha)
             model.penalty_multiplier = float(alpha)
@@ -162,8 +173,10 @@ class PenaltyMultiplierAlgorithm(Algorithm):
             energies.append(results["energies"][0])
             log.info("NEW SOLUTION OBJECTIVE %f LESS OFFSET %f ENERGY %f PENALTY %f", 
                      obj_val, less_offset, energies[-1], penalty)
-            if obj_val < ub:
+            if penalty < self.penalty_threshold:
+                pass
+            elif obj_val < ub:
                 alpha += (ub - obj_val) / penalty
-            if abs(sum(penalties[-2:])/2-penalty) < 1e-4:
+            if penalty > self.penalty_threshold and abs(sum(penalties[-2:])/2-penalty) < self.progress_threshold:
                 log.warn("SUFFICIENT PROGRESS NOT MADE FOR THREE ITERATIONS, QUITTING")
                 break

eqc_models-0.10.1/eqc_models/combinatorics/__init__.py

@@ -0,0 +1,5 @@
+# (C) Quantum Computing Inc., 2024.
+
+from .setcover import SetCoverModel
+
+__all__ = ["SetCoverModel"]

eqc_models-0.10.1/eqc_models/combinatorics/setcover.py

@@ -0,0 +1,94 @@
+r"""
+SetCoverModel solves the mathematical programming problem
+
+$$
+\mathrm{minimize}_x \sum_{x_i:X_i \in X} c_i x_i
+$$
+
+Subject to
+
+$$
+\sum_{i:a\in X_i} x_j \geq 1 \, \forall a \in A}
+$$$
+
+and 
+
+$$
+x_i \in \{0, 1\} \forall {x_i: X_i \in X}
+$$
+
+Where $S$ is a set of all elements, $X$ is a collection of sets $X_i$, and the union of all is equal to $S$. 
+
+"""
+
+from typing import List
+import numpy as np
+from eqc_models.base import ConstrainedQuadraticModel
+
+class SetCoverModel(ConstrainedQuadraticModel):
+    """
+    Parameters
+    -------------
+
+    subsets : List
+        List of sets where the union of all sets is S
+
+    weights : List
+        List of weights where each weight is the cost of choosing the subset
+        corresponding to the index of the weight.
+
+
+    >>> X = [set(['A', 'B']), set(['B', 'C']), set(['C'])]
+    >>> weights = [2, 2, 1]
+    >>> model = SetCoverModel(X, weights)
+    >>> model.penalty_multiplier = 2
+    >>> from eqc_models.solvers import Dirac3IntegerCloudSolver
+    >>> solver = Dirac3IntegerCloudSolver()
+    >>> response = solver.solve(model, relaxation_schedule=1, num_samples=5) #doctest: +ELLIPSIS
+    20...
+    >>> solutions = response["results"]["solutions"]
+    >>> solutions[0]
+    [1, 0, 1, 0, 0, 0]
+    >>> model.decode(solutions[0])
+    [{'B', 'A'}, {'C'}]
+
+    """
+
+    def __init__(self, subsets, weights):
+        # ensure that X is ordered
+        self.X = X = list(subsets)
+        self.S = S = set()
+
+        for x in subsets:
+            S = S.union(x)
+        # elements is sorted to maintain consistent output
+        elements = [a for a in S]
+        elements.sort()
+        # constraints 
+        A = []
+        b = []
+        variables = [f'x_{i}' for i in range(len(X))]
+        pos = 0
+        for a in elements:
+            variables.append(f"s_{pos}")
+            constraint = [1 if a in X[i] else 0 for i in range(len(X))]
+            slacks = [0 for i in range(len(S))]
+            slacks[pos] = -1
+            A.append(constraint + slacks)
+            pos += 1
+            b.append(1)
+        n = len(variables)
+        J = np.zeros((n, n))
+        h = np.zeros((n, ))
+        h[:len(weights)] = weights
+        # call the superclass constructor with the objective and constraints
+        super(SetCoverModel, self).__init__(h, J, np.array(A), np.array(b))
+        # set upper bound on the variables to be 1 for x_i and the length of X minus 1 for the slacks
+        self.upper_bound = np.array([1 for i in range(len(weights))] + [len(X)-1 for i in range(n-len(weights))])
+
+    def decode(self, solution) -> List:
+        xbar = []
+        for i in range(len(self.X)):
+            if solution[i] > 0.5:
+                xbar.append(self.X[i])
+        return xbar

eqc_models-0.10.1/eqc_models/graph/__init__.py

@@ -0,0 +1,6 @@
+# (C) Quantum Computing Inc., 2024.
+
+from .maxcut import MaxCutModel
+from .partition import GraphPartitionModel
+
+__all__ = ["MaxCutModel", "GraphPartitionModel"]

{eqc_models-0.9.9 → eqc_models-0.10.1}/eqc_models/graph/base.py

@@ -7,7 +7,34 @@ class GraphModel(QuadraticModel):
     """ """
     def __init__(self, G : nx.Graph):
         self.G = G
-        self.linear_objective, self.quad_objective = self.costFunction()
+        super().__init__(*self.costFunction())
+
+    @property
+    def linear_objective(self):
+        """Return linear terms as a vector."""
+        return self._H[0]
+
+    @property
+    def quad_objective(self):
+        """Return quadratic terms as a matrix."""
+        return self._H[1]
+
+    def costFunction(self):
+        """
+        Parameters
+        -------------
+
+        None
+
+        Returns
+        --------------
+
+        :C: linear operator (vector array of coefficients) for cost function
+        :J: quadratic operator (N by N matrix array of coefficients ) for cost function
+
+        """
+        raise NotImplementedError("GraphModel does not implement costFunction")
+
 
 class NodeModel(GraphModel):
     """ 
@@ -22,22 +49,6 @@ class NodeModel(GraphModel):
         names = [node for node in self.G.nodes]
         names.sort()
         return names
-
-    def costFunction(self):
-        """ 
-        Parameters
-        -------------
-        
-        None
-        
-        Returns
-        --------------
-        
-        :C: linear operator (vector array of coefficients) for cost function
-        :J: quadratic operator (N by N matrix array of coefficients ) for cost function
-        
-        """
-        raise NotImplementedError("NodeModel does not implement costFunction")
     
     def modularity(self, partition : Set[Set]) -> float:
         """ Calculate modularity from a partition (set of communities) """

eqc_models-0.10.1/eqc_models/graph/partition.py

@@ -0,0 +1,148 @@
+from typing import Tuple
+import numpy as np
+import scipy.sparse as sp
+import networkx as nx
+from math import modf
+from eqc_models.graph.base import GraphModel
+
+
+class GraphPartitionModel(GraphModel):
+    """
+    A model for graph partitioning into `k` parts with objective and constraints
+    derived from the Laplacian matrix and additional penalties for balance and constraints.
+    """
+
+    def __init__(self, G: nx.Graph, k: int = 2, weight: str = "weight", alpha: float = 1.0, beta_obj: float = 1.0,
+                 gamma: float = 1.0):
+        """
+        Parameters:
+        -----------
+        G : nx.Graph
+            The graph to partition.
+        k : int
+            The number of partitions.
+        weight : str
+            The key for edge weights in the graph.
+        alpha : float
+            The penalty multiplier for balance constraints.
+        beta_obj : float
+            The penalty multiplier for minimizing edge cuts (Laplacian term).
+        gamma : float
+            The penalty multiplier for assignment constraints.
+        """
+        self._G = G
+        self._k = k
+        self._weight = weight
+        self._alpha = alpha
+        self._beta_obj = beta_obj
+        self._gamma = gamma
+        self._laplacian = nx.laplacian_matrix(G, weight=weight)
+        self._num_nodes = G.number_of_nodes()
+        self._sorted_nodes = sorted(G.nodes)
+        self._constraints_offset = 0
+        self._balanced_partition_offset = 0
+        self.set_and_validate_k()
+        self._objective_matrix = self.initialize_model()
+        super().__init__(self._G)
+
+    def set_and_validate_k(self):
+        """
+        Sets k and encoding length for a graph problem
+        """
+        # modf(x) = (fractional, integer) decomposition.
+        # Make sure fractional portion is zero. Convert to int if so.
+        assert modf(self._k)[0] == 0, "'k' must be an integer."
+
+        # it's an int, so set self.k
+        self._k = int(self._k)
+
+        # Verify k >= 2
+        assert self._k >= 2, f"ERROR, k={self._k}: k must be greater than or equal to 2."
+
+        # Verify that k makes sense
+        assert self._k <= self._num_nodes, (
+            f"ERROR, k={self._k}: k must be less than number of nodes or variables. k = {self._k} and "
+            f"number of nodes = {self._num_nodes}"
+        )
+
+    def initialize_model(self):
+        """
+        Build the objective matrix and constraints for the k-partition problem.
+        """
+        if self._k == 2:
+            # For 2 partitions, construct a simpler QUBO from the Laplacian matrix
+            return self.get_two_partition_qubo()
+        else:
+            # For k > 2, construct a block-diagonal Laplacian with balance and constraints
+            laplacian_blocks = 0.5 * sp.block_diag([self._laplacian] * self._k, format="csr")
+            balance_term = self.get_balanced_partition_term()
+            constraints = self.get_constraints()
+            return (
+                self._alpha * balance_term
+                + self._gamma * constraints
+                + self._beta_obj * laplacian_blocks
+            )
+
+    def get_balanced_partition_term(self) -> sp.spmatrix:
+        """
+        Construct the quadratic penalty term for balanced partitions.
+        """
+        I_k = sp.identity(self._k)
+        Ones_n = np.ones((self._num_nodes, self._num_nodes))
+        balanced_partition_term = sp.kron(I_k, Ones_n, format="csr")
+        balanced_partition_term -= (
+            2 * self._num_nodes / self._k * sp.identity(balanced_partition_term.shape[0])
+        )
+        self._balanced_partition_offset = self._num_nodes**2 / self._k
+        return balanced_partition_term
+
+    def get_constraints(self) -> sp.spmatrix:
+        """
+        Construct the quadratic penalty term for assignment constraints.
+        """
+        I_n = sp.identity(self._num_nodes)
+        Ones_k = np.ones((self._k, self._k))
+        constraints = sp.kron(Ones_k, I_n, format="csr")
+        constraints -= 2 * sp.identity(constraints.shape[0])
+        self._constraints_offset = self._num_nodes
+        return constraints
+
+    def get_two_partition_qubo(self) -> sp.spmatrix:
+        """
+        Construct the QUBO matrix for two partitions using adjacency and penalties.
+        """
+        Garr = nx.to_scipy_sparse_matrix(self._G, weight=self._weight, nodelist=self._sorted_nodes)
+        Q = (
+            self._alpha * np.ones(Garr.shape, dtype=np.float32)
+            - self._beta_obj * Garr
+        )
+        degrees = Garr.sum(axis=1).A1  # Convert sparse matrix to 1D array
+        diag = self._beta_obj * degrees - self._alpha * (self._num_nodes - 1)
+        np.fill_diagonal(Q, diag)
+        return sp.csr_matrix(Q)
+
+    def evaluate(self, solution: np.ndarray) -> float:
+        """
+        Evaluate the objective function for a given solution.
+        """
+        assert len(solution) == self._objective_matrix.shape[0], "Solution size mismatch."
+        return float(solution.T @ self._objective_matrix @ solution)
+
+    def decode(self, solution: np.ndarray) -> dict:
+        """
+        Decode the solution vector into a partition assignment.
+        """
+        if self._k == 2:
+            return {node: int(solution[i]) for i, node in enumerate(self._sorted_nodes)}
+        else:
+            partitions, nodes = np.where(solution.reshape((self._k, self._num_nodes)) == 1)
+            return {self._sorted_nodes[node]: int(partition) for partition, node in zip(partitions, nodes)}
+
+    def costFunction(self) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Return the linear and quadratic components of the objective function.
+        """
+        Q = self._objective_matrix
+        h = Q.diagonal()
+        J = 2 * sp.triu(Q, k=1).tocsr() # Extract upper triangular part for quadratic terms
+        return h, J