def generate_cond_init()

in src/envs/ode.py [0:0]

• 70 lines of code
• 15 McCabe index (conditional complexity)

    def generate_cond_init(self, max_delay, dimension, unariesexp, unariesfk):
        pol = set()
        nfactor = self.rng.randint(1, max_delay + 1)
        # print(nfactor)
        delay = np.zeros(dimension)
        bounds = []
        vars = set()
        for j in range(nfactor):
            vars.add(
                (self.rng.randint(0, dimension), self.rng.randint(0, len(unariesexp)))
            )
        pol.add(tuple(vars))
        # print(pol)
        for i in range(len(pol)):
            v = list(pol)[i]
            # print(len(v))
            # print(v[len(v)-1])
            # print(v[len(v)-1][0])
            # print(v[0][0])
            # print(delay)
            for j in range(len(v)):
                op = unariesexp[v[j][1]]
                var = Node(self.variables[f"x{v[j][0]}"])
                if op == "id":
                    term = var
                elif len(op) > 3 and op[:3] == "pow":
                    term = Node("^", [var, Node(int(op[3:]))])
                elif op == "expi":
                    a_d = self.rng.randint(-100, 100)
                    # b = self.rng.randint(-100, 100)#Not needed for now
                    b_d = 0
                    term = Node(
                        "exp",
                        [
                            Node(
                                "+",
                                [
                                    Node("*", [Node(a_d), Node("*", [Node("I"), var])]),
                                    Node(b_d),
                                ],
                            )
                        ],
                    )
                    delay[v[j][0]] = delay[v[j][0]] + a_d
                    # print(delay[v[j][0]])
                else:
                    term = Node(op, [var])
                p = term if j == 0 else Node("*", [p, term])
        expr_delay = p
        # print(sp.S(expr_delay))
        for i in range(dimension):
            k = self.rng.randint(0, len(unariesfk))
            op = unariesfk[k]
            var = Node(self.variables[f"x{i}"])
            a = self.rng.randint(-100, 100)
            # b = self.rng.randint(-100, 100)
            # inclure b plus tard not needed now avec les delays
            b = 0
            var = Node("+", [Node("*", [Node(a), var]), Node(b)])
            if op == "sinc":
                bounds.append(
                    [-abs(a) / (2 * np.pi), abs(a) / (2 * np.pi)]
                )  # fouriertiser
                term = Node("/", [Node("sin", [var]), var])
                # print(sp.S(term))
            elif op == "1":
                bounds.append([0, 0])
                term = Node(1)
            elif op == "delta0":
                bounds.append([-np.inf, np.inf])
                term = Node(op, [var])
            elif op == "gauss":
                bounds.append([-np.inf, np.inf])
                term = Node(
                    "exp", [Node("*", [Node(-1), Node("^", [var, Node(2)])])]
                )  # checker
            else:
                return None
            # Message d'erreur
            # print(sp.S(term))
            p = term if i == 0 else Node("*", [p, term])
            bounds[i][0] = bounds[i][0] + delay[i] / (2 * np.pi)
            bounds[i][1] = bounds[i][1] + delay[i] / (2 * np.pi)
            # print(delay[i])
        u0 = Node("*", [expr_delay, p])
        # u0f = Node('*', [exprf, pf])

        return u0, bounds