Python, pomoc s optimalizaci

Python

def calculate(self):
    # HORIZONT-ČELO
    # vzorec A0°C0° ; (chyba) + (A) + (B) + (Cy) = 0
    # vzorec A0°C180° ; (chyba) + (A) + (B) - (Cy) = 0
    # vzorec A0°C+90° ; (chyba) + (A) + (B) - (Cx) = 0
    # vzorec A0°C-90° ; (chyba) + (A) + (B) + (Cx) = 0

    # VERTIKAL-VRCH
    # vzorec A180°C0 ; (chyba) - (A) + (B) + (Cy) = 0
    # vzorec A180°C180° ; (chyba) + (A) - (B) + (Cy) = 0
    # vzorec A180°C+90° ; (chyba) + (Cy) = 0
    # vzorec A180°C-90° ; (chyba) + (Cy) = 0

    # VERTIKAL-BOK
    # vzorec xA180°C0° ; (chyba) + (Cx) = 0
    # vzorec A180°C180° ; (chyba) + (Cx) = 0
    # vzorec A180°C+90° ; (chyba) + (A) - (B) + (Cx) = 0
    # vzorec A180°C-90° ; (chyba) - (A) + (B) + (Cx) = 0

    def set_label(label, a, b, c):
        label.set(str(get_magic_number(label, a, b, c)))
 
    def get_magic_number(label, a, b, c):
        return float(label.get()) + (a) + (b) + (c)

    def spec_print(name, data):
        print(name+str(get_magic_number(data[0], data[1], data[2], data[3])))


    CyOK = False
    CxOK = False
    self.labelCy_p.set("")
    for error in self.frange(0, 2.5, 0.25):
        for A in self.frange(-10, 11, 0.25):
            for B in self.frange(-10, 11, 0.25):
                if not CyOK:
                    for Cy in self.frange(-10, 11, 0.25):
                        something = (abs(get_magic_number(self.A0C0, +A, +B, +Cy)) <= error,
                                    abs(get_magic_number(self.A0C180, +A, +B, -Cy)) <= error,
                                    abs(get_magic_number(self.A180C0_t, -A, +B, +Cy)) <= error,
                                    abs((float(self.A180C180_t.get())) + (A) - (B) + (Cy)) <= error,
                                    abs(float(self.A180C90_p_t.get()) + (Cy)) <= error,
                                    abs(float(self.A180C90_m_t.get()) + (Cy)) <= error)

                        if not 0 in something:
                            set_label(self.labelA0C180, A, B, -Cy)
                            set_label(self.labelA0C0, A, B, Cy)

                            set_label(self.A180C0_t, -A, +B, +Cy)
                            set_label(self.A180C180_t, -A, +B, -Cy)
                            set_label(self.A180C90_m_t, 0, 0, +Cy)
                            set_label(self.A180C90_p_t, 0, 0, +Cy)
                            CyOK = True
                            break


                if not CxOK:
                    for Cx in self.frange(-10, 11, 0.25):
                        something = (abs(get_magic_number(self.A0C90_p, +A, +B, -Cx)) <= error,
                                    abs(get_magic_number(self.A0C90_m, +A, +B, +Cx)) <= error,
                                    abs((float(self.A180C90_p_s.get())) + (A) - (B) + (Cx)) <= error,
                                    abs(float(self.A180C90_m_s.get()) - (A) + (B) + (Cx)) <= error,
                                    abs(float(self.A180C0_s.get()) + (Cx)) <= error,
                                    abs(float(self.A180C180_s.get()) + (Cx)) <= error)

                        if not 0 in something:
                            set_label(self.A0C90_m, +A, +B, +Cx)
                            set_label(self.A0C90_p, +A, +B, -Cx)
                            set_label(self.A180C90_p_s, -A, +B, -Cx)
                            set_label(self.A180C90_m_s, -A, +B, +Cx)
                            set_label(self.A180C0_s, 0, 0, Cx)
                            set_label(self.A180C180_s, 0, 0, +Cx)
                            CxOK = True
                            break

                if CyOK and CxOK:

                    print("Cx---")
                    spec_print("A0C90 ", (self.A0C90_p, +A, +B, -Cx))
                    spec_print("A0C-90 ", (self.A0C90_m, +A, +B, +Cx))
                    spec_print("A180C90 side ", (self.A180C90_p_s, -A, +B, -Cx))
                    spec_print("A180C-90 side ", (self.A180C90_m_s, -A, +B, +Cx))
                    spec_print("A180C0 side ", (self.A180C0_s, 0, 0, +Cx))
                    spec_print("A180C180 side", (self.A180C180_s, 0, 0, +Cx))
                    print("A "+str(A))
                    print("B "+str(B))
                    print("Cx "+str(Cx))

                    print("Cy---")
                    spec_print("A0C0 ", (self.A0C0, +A, +B, +Cy))
                    spec_print("A0C180 ", (self.A0C180, +A, +B, -Cy))
                    spec_print("A180C0 top", (self.A180C0_t, -A, +B, +Cy))
                    spec_print("A180C180 top", (self.A180C180_t, -A, +B, -Cy))
                    spec_print("A180C90 top", (self.A180C90_p_t, 0, 0, +Cy))
                    spec_print("A180C-90 top", (self.A180C90_m_t, 0, 0, +Cy))
                    print("A "+str(A))
                    print("B "+str(B))
                    print("Cy "+str(Cy))

                    if A < 0:
                        self.labelA_m.set(A)
                    else:
                        self.labelA_p.set(-A)
                    if B < 0:
                        self.labelB_m.set(B)
                    else:
                        self.labelB_p.set(-B)
                    if Cx < 0:
                        self.labelCx_m.set(Cx)
                    else:
                        self.labelCx_p.set(-Cx)
                    if Cy < 0:
                        self.labelCy_m.set(Cy)
                    else:
                        self.labelCy_p.set(-Cy)
                    return
                else:
                    CyOK = False
                    CxOK = False

Neformátovaný

Přidáno: 20.9.2015
Expirace: Neuvedeno

Autor: Drakeman