Example #1
0
    def testRead(self):
        field = Field()
        field.read("./Parameters/hsg1_rigid.maps.fld")
        em = ElectrostaticMap()
        em.read("./Maps/hsg1_rigid.C.map", field)

        # 1
        exp = [
            1.092, 0.806, 0.553, 0.263, 0.190, 0.598, 2.408, 8.181, 23.834,
            54.212
        ]
        for i in xrange(10):
            self.assertEquals(em.map[0][0][i], exp[i])

        # 316
        exp = [
            2165.672, 16349.299, 70409.602, 78148.484, 21661.604, 2812.866,
            387.952, 75.797, 21.270, 10.186
        ]
        for i in xrange(10):
            self.assertEquals(em.map[0][5][10 + i], exp[i])

        # 183110
        exp = [
            425.622, 1197.815, 4611.195, 22100.568, 57932.355, 44180.094,
            108190.430, 102640.172, 116771.336, 199047.891
        ]
        for i in xrange(10):
            self.assertEquals(em.map[49][12][48 + i], exp[i])

        # 226972
        exp = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
        for i in xrange(10):
            self.assertEquals(em.map[60][60][51 + i], exp[i])
Example #2
0
    def testRead(self):
        field = Field()
        field.read("./Parameters/hsg1_rigid.maps.fld")
        em = ElectrostaticMap()
        em.read("./Maps/hsg1_rigid.d.map", field)

        # 1
        exp = [
            0.704, 0.701, 0.693, 0.691, 0.685, 0.689, 0.689, 0.689, 0.694,
            0.690
        ]
        for i in xrange(10):
            self.assertEquals(em.map[0][0][i], exp[i])

        # 316
        exp = [
            0.766, 0.764, 0.751, 0.753, 0.741, 0.731, 0.730, 0.728, 0.722,
            0.721
        ]
        for i in xrange(10):
            self.assertEquals(em.map[0][5][10 + i], exp[i])

        # 183110
        exp = [
            1.218, 1.232, 1.238, 1.259, 1.259, 1.255, 1.242, 1.240, 1.244,
            1.243
        ]
        for i in xrange(10):
            self.assertEquals(em.map[49][12][48 + i], exp[i])

        # 226972
        exp = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
        for i in xrange(10):
            self.assertEquals(em.map[60][60][51 + i], exp[i])
Example #3
0
    def testRead(self):
        field = Field()
        field.read("./Parameters/hsg1_rigid.maps.fld")

        self.assertEquals(field.spacing, 0.375)
        self.assertEquals(str(field.num_points), str(Axis3(60, 60, 60)))
        self.assertEquals(str(field.num_points1), str(Axis3(61, 61, 61)))
        self.assertEquals(str(field.center), str(Axis3(2.500, 6.500, -7.500)))
        self.assertEquals(str(field.lo), str(Axis3(-8.750, -4.750, -18.750)))
        self.assertEquals(str(field.hi), str(Axis3(13.750, 17.750, 3.750)))
Example #4
0
 def testRead(self):
     field = Field()
     field.read("./Parameters/hsg1_rigid.maps.fld")
     
     self.assertEquals(field.spacing, 0.375)
     self.assertEquals(str(field.num_points), str(Axis3(60, 60, 60)))
     self.assertEquals(str(field.num_points1), str(Axis3(61, 61, 61)))
     self.assertEquals(str(field.center), str(Axis3(2.500, 6.500, -7.500)))
     self.assertEquals(str(field.lo), str(Axis3(-8.750, -4.750, -18.750)))
     self.assertEquals(str(field.hi), str(Axis3(13.750, 17.750, 3.750)))
Example #5
0
    def testRead(self):
        field = Field()
        field.read("./Parameters/hsg1_rigid.maps.fld")
        em = ElectrostaticMap()
        em.read("./Maps/hsg1_rigid.e.map", field)

        # 1
        exp = [
            -0.486, -0.436, -0.410, -0.408, -0.426, -0.459, -0.499, -0.555,
            -0.620, -0.680
        ]
        for i in xrange(10):
            self.assertEquals(em.map[0][0][i], exp[i])

        # 316
        exp = [
            -0.368, -0.175, 0.001, 0.053, -0.019, -0.117, -0.187, -0.249,
            -0.312, -0.395
        ]
        for i in xrange(10):
            self.assertEquals(em.map[0][5][10 + i], exp[i])

        # 183110
        exp = [
            -0.622, -0.730, -0.411, 0.367, 1.223, 1.625, 1.909, 2.677, 2.379,
            -0.580
        ]
        for i in xrange(10):
            self.assertEquals(em.map[49][12][48 + i], exp[i])

        # 226972
        exp = [
            -0.005, -0.006, -0.007, -0.007, -0.007, -0.008, -0.008, -0.007,
            -0.007, -0.007
        ]
        for i in xrange(10):
            self.assertEquals(em.map[60][60][51 + i], exp[i])
Example #6
0
    def testRead(self):
        field = Field()
        field.read("./Parameters/hsg1_rigid.maps.fld")
        em = ElectrostaticMap()
        em.read("./Maps/hsg1_rigid.d.map", field)

        # 1
        exp = [0.704,
               0.701,
               0.693,
               0.691,
               0.685,
               0.689,
               0.689,
               0.689,
               0.694,
               0.690]
        for i in xrange(10):
            self.assertEquals(em.map[0][0][i], exp[i])

        # 316
        exp = [0.766,
               0.764,
               0.751,
               0.753,
               0.741,
               0.731,
               0.730,
               0.728,
               0.722,
               0.721]
        for i in xrange(10):
            self.assertEquals(em.map[0][5][10 + i], exp[i])

        # 183110
        exp = [1.218,
               1.232,
               1.238,
               1.259,
               1.259,
               1.255,
               1.242,
               1.240,
               1.244,
               1.243]
        for i in xrange(10):
            self.assertEquals(em.map[49][12][48 + i], exp[i])

        # 226972
        exp = [0.0,
               0.0,
               0.0,
               0.0,
               0.0,
               0.0,
               0.0,
               0.0,
               0.0,
               0.0]
        for i in xrange(10):
            self.assertEquals(em.map[60][60][51 + i], exp[i])
Example #7
0
    def testRead(self):
        field = Field()
        field.read("./Parameters/hsg1_rigid.maps.fld")
        em = ElectrostaticMap()
        em.read("./Maps/hsg1_rigid.C.map", field)

        # 1
        exp = [1.092,
               0.806,
               0.553,
               0.263,
               0.190,
               0.598,
               2.408,
               8.181,
               23.834,
               54.212]
        for i in xrange(10):
            self.assertEquals(em.map[0][0][i], exp[i])

        # 316
        exp = [2165.672,
               16349.299,
               70409.602,
               78148.484,
               21661.604,
               2812.866,
               387.952,
               75.797,
               21.270,
               10.186]
        for i in xrange(10):
            self.assertEquals(em.map[0][5][10 + i], exp[i])

        # 183110
        exp = [425.622,
               1197.815,
               4611.195,
               22100.568,
               57932.355,
               44180.094,
               108190.430,
               102640.172,
               116771.336,
               199047.891]
        for i in xrange(10):
            self.assertEquals(em.map[49][12][48 + i], exp[i])

        # 226972
        exp = [0.0,
               0.0,
               0.0,
               0.0,
               0.0,
               0.0,
               0.0,
               0.0,
               0.0,
               0.0]
        for i in xrange(10):
            self.assertEquals(em.map[60][60][51 + i], exp[i])
Example #8
0
    def testRead(self):
        field = Field()
        field.read("./Parameters/hsg1_rigid.maps.fld")
        em = ElectrostaticMap()
        em.read("./Maps/hsg1_rigid.e.map", field)

        # 1
        exp = [-0.486,
               -0.436,
               -0.410,
               -0.408,
               -0.426,
               -0.459,
               -0.499,
               -0.555,
               -0.620,
               -0.680]
        for i in xrange(10):
            self.assertEquals(em.map[0][0][i], exp[i])

        # 316
        exp = [-0.368,
               -0.175,
                0.001,
                0.053,
               -0.019,
               -0.117,
               -0.187,
               -0.249,
               -0.312,
               -0.395]
        for i in xrange(10):
            self.assertEquals(em.map[0][5][10 + i], exp[i])

        # 183110
        exp = [-0.622,
               -0.730,
               -0.411,
                0.367,
                1.223,
                1.625,
                1.909,
                2.677,
                2.379,
               -0.580]
        for i in xrange(10):
            self.assertEquals(em.map[49][12][48 + i], exp[i])

        # 226972
        exp = [-0.005,
               -0.006,
               -0.007,
               -0.007,
               -0.007,
               -0.008,
               -0.008,
               -0.007,
               -0.007,
               -0.007]
        for i in xrange(10):
            self.assertEquals(em.map[60][60][51 + i], exp[i])
Example #9
0
def spins_plot(grid):  #spin sectangles

    for x, y in grid:
        if grid.GetCell(x, y) == -1:
            col = 'red'
        else:
            col = '#28F'

        c.create_rectangle(51 + x * a,
                           51 + y * a,
                           51 + (x + 1) * a,
                           51 + (y + 1) * a,
                           fill=col,
                           outline=col,
                           width=0)


def latt(g):  #redraw of the screen
    c.delete(ALL)
    spins_plot(g)
    grid()
    c.update()


if __name__ == '__main__':
    x = 50
    y = 50
    g = Field(x, y)
    g.FlipSpin(2, 1)
    init(x, y)
    latt(g)
Example #10
0
               temperature,
               magneticField=0,
               show=False,
               showFrequency=100000):

    width = grid.width
    height = grid.height

    for i in range(iterationNumber):
        x = randint(0, width - 1)
        y = randint(0, height - 1)

        energyChange = grid.FlipEnergy(x, y, magneticField)

        if energyChange <= 0:
            grid.FlipSpin(x, y, magneticField)

        elif random() <= exp(-energyChange / temperature):
            grid.FlipSpin(x, y, magneticField)

        if show and (i % showFrequency == 0):
            latt(grid)


if __name__ == '__main__':

    print('start')
    g = Field(100, 100)
    init(100, 100)
    MonteCarlo(g, 10000000, 4, show=True)
    print('finish')
Example #11
0
    def run(self):
        with open(self.docking_parameter_file, 'r') as p_file:
            for line in p_file:
                if line.startswith("intelec"):
                    self.dock.dps.calc_inter_elec_e = True

                # Atomic bonding parameter file
                if line.startswith("b_prm"):
                    self.dock.bond.read(line.split()[1])

                if line.startswith("ligand_types"):
                    for type in line.split('#')[0].split()[1:]:
                        self.dock.ligand.atom_types.append(type)
                        self.atom_type_map_files[type] = ""
                    self.dock.bond.calc_internal_energy_tables(
                        self.dock.ligand)

                if line.startswith("fld"):
                    self.grid_field_file = "./Parameters/" + line.split()[1]
                    self.dock.grid.field = Field(self.grid_field_file)

                if line.startswith("map"):
                    filename = line.split()[1]
                    type = filename.split('.')[1]
                    self.atom_type_map_files[type] = "./Maps/" + filename
                    self.dock.grid.maps[type] = AtomTypeMap(
                        self.atom_type_map_files[type],
                        self.dock.grid.field).map

                if line.startswith("elecmap"):
                    self.electrostatic_map_file = "./Maps/" + line.split()[1]
                    self.dock.grid.maps['e'] = ElectrostaticMap(
                        self.electrostatic_map_file, self.dock.grid.field).map

                if line.startswith("desolvmap"):
                    self.desolvation_map_file = "./Maps/" + line.split()[1]
                    self.dock.grid.maps['d'] = DesolvationMap(
                        self.desolvation_map_file, self.dock.grid.field).map

                # Set movable molecule (ligand)
                if line.startswith("move"):
                    self.ligand_file = "./Inputs/" + line.split()[1]
                    self.dock.ligand.read_pdbqt(self.ligand_file)

                # Set flexible portion of molecule (normally protein receptor)
                if line.startswith("flexres"):
                    self.protein_file = "./Inputs/" + line.split()[1]
                    self.dock.protein.read_flex_pdbqt(self.protein_file)

                if line.startswith("about"):
                    about = Axis3(0.0, 0.0, 0.0)
                    about.xyz = [float(axis) for axis in line.split()[1:4]]
                    self.dock.ligand.about = about
                    # Zero-out central point. Applicable only for all ligand
                    # atoms (not protein atoms)
                    for i in xrange(len(self.dock.ligand.ori_atoms)):
                        self.dock.ligand.ori_atoms[i].tcoord -= about
                    self.dock.ligand.reset_atoms()

                # Pre-energy calculation
                if line.startswith("pre_energy_calc"):
                    # Get atomic non-bond lists
                    self.dock.get_non_bond_list()

                    # Calculate binding torsional free energy
                    self.dock.torsional_energy = self.dock.bond.torsional_dof * \
                                                 self.dock.bond.fec_tors

                # --------------------------------------- Empirical Settings ---
                # 1-4 interactions
                if line.startswith("include_1_4_interactions"):
                    # By default, 1-4 interactions is disabled. Only 1-1, 1-2,
                    # and 1-3 interactions are considered.
                    self.dock.bond.include_1_4_interactions = True

                # Torsional degrees of freedom (DoF)
                if line.startswith("torsdof"):
                    self.dock.bond.torsional_dof = int(line.split()[1])

                #---------------------------------------------- Optimization ---
                # Define optimization type to use
                if line.startswith("opt_type"):
                    type = line.split()[1]
                    if type == "ga":
                        if self.accelerator == "sequential":
                            self.optimization = \
                                Optimization.GeneticAlgorithm(self.dock)
                        if self.accelerator == "opencl":
                            self.optimization = \
                                Optimization.GeneticAlgorithmOpenCL(self.dock, \
                                                                    self.cl_device_type)

                # Run optimization
                if line.startswith("opt_run"):
                    self.optimization.run()

                #------------------------------------ Opt: Genetic Algorithm ---
                if line.startswith("opt_ga"):
                    words = line.split()
                    type = words[1]
                    value = words[2]
                    if type == "community_size":
                        self.optimization.community_size = int(value)
                    if type == "pop_size":
                        self.optimization.population_size = int(value)
                    if type == "num_generations":
                        self.optimization.num_gen = int(value)

                #----------------------------------------------- Accelerator ---
                # Define parallel processing accelerator
                if line.startswith("accelerator"):
                    self.accelerator = line.split()[1]
                    if self.accelerator == "sequential":
                        self.dock = Dock()
                    if self.accelerator == "opencl":
                        self.dock = DockOpenCL()

                # Define OpenCL device types
                if line.startswith("ocl_device_type"):
                    self.cl_device_type = line.split()[1]
Example #12
0
    def testCalcEnergy(self):
        ligand = Ligand()
        ligand.read_pdbqt("./Inputs/ind.pdbqt")
        ligand.update_tcoord_model("./Results/ind_1.model")

        grid = Grid()
        grid.field = Field("./Parameters/hsg1_rigid.maps.fld")
        grid.maps['e'] = ElectrostaticMap("./Maps/hsg1_rigid.e.map", grid.field).map
        grid.maps['d'] = DesolvationMap("./Maps/hsg1_rigid.d.map", grid.field).map
        grid.maps['A'] = AtomTypeMap("./Maps/hsg1_rigid.A.map", grid.field).map
        grid.maps['C'] = AtomTypeMap("./Maps/hsg1_rigid.C.map", grid.field).map
        grid.maps['HD'] = AtomTypeMap("./Maps/hsg1_rigid.HD.map", grid.field).map
        grid.maps['N'] = AtomTypeMap("./Maps/hsg1_rigid.N.map", grid.field).map
        grid.maps['NA'] = AtomTypeMap("./Maps/hsg1_rigid.NA.map", grid.field).map
        grid.maps['OA'] = AtomTypeMap("./Maps/hsg1_rigid.OA.map", grid.field).map
        
        dock = Dock()
        dock.ligand = ligand
        dock.grid = grid
        dock.calc_energy()

        exp_elecs = [-0.037623435264000013, -0.11408866126250672, \
                     -0.13002690236871114, -0.11316478799697538, \
                     0.079400682425344024, 0.16382104147968005, \
                     0.35572237014565938, -0.13983584352051195, \
                     -0.14455922704497778, -0.2437679729095111, \
                     -0.2233031453627734, -0.057756149112888927, \
                     -0.079042238535680001, -0.032257681663999997, \
                     -0.14416303698488891, 0.10750629826486036, \
                     0.24778700799999992, -0.084038775587896894, \
                     -0.106404338719744, -0.052751354779306661, \
                     0.024654531648227552, -0.0042321141760000005, \
                     -0.00035986557866666673, -0.00033659216281599992, \
                     -0.0041046807466666672, 0.012465198300672001, \
                     -0.090822509727725043, -0.17177248957202962, \
                     1.1082351947605333, -0.89707293013333311, \
                     0.026757765866666665, -0.0020757145903407409, \
                     -0.00025216804266666674, -0, -0.00048987137962666649, \
                     -0.0041342845067377787, -0.077292167626752006, \
                     0.0028771771022222214, -0.035468487893333331, \
                     0.061588514183964438, -0.025041379570346665, \
                     -0.0055949960533333357, -0.0031704985600000007, \
                     -0.0069595652002702214, -0.012058230703198818, \
                     -0.0079140675343170441, -0.012375409536000002, \
                     0.3866265132258988, -0.20299363642879997]
        self.assertEquals(dock.elecs, exp_elecs)

        exp_elec_total = -0.689862915434
        self.assertLessEqual(dock.elec_total - exp_elec_total, 0.000000000001)
        self.assertGreaterEqual(dock.elec_total - exp_elec_total, -0.000000000001)

        exp_emaps = [-0.27127903027200001, -0.16588333043273959, \
                     -0.20299416690915556, -0.21193308408991288, \
                     -0.22342833248403907, -0.10887097308672009, \
                     -0.069412406582518515, -0.32392036196890539, \
                     -0.22020219191751092, -0.35971221242311113, \
                     -0.36151369650175996, -0.33589534698001067, \
                     -0.31399731050837326, -0.37602125178402135, \
                     -0.18051097352533335, -0.17621873305273847, \
                     -0.092143525887999983, -0.2309628750124183, \
                     -0.24049173290393594, -0.30815793025564453, \
                     -0.39344854528779372, -0.50645809636693317, \
                     -0.53159663755332287, -0.49475817361601443, \
                     -0.34577077998990213, -0.31340080937233067, \
                     0.083165888601903395, -0.37009113352391104, \
                     -0.26495262599680025, -0.35829845333333321, \
                     -0.27628956787200004, -0.36140396483508141, \
                     -0.31815226712832012, -0.2094688831146666, \
                     -0.23815943764081771, -0.24906767845688918, \
                     -0.22192987677536707, -0.25745685461333312, \
                     -0.19937555381333344, -0.2350488774924894, \
                     -0.19400907040085333, -0.14228789478968887, \
                     -0.23528794258204436, -0.4346495467977386, \
                     -0.44998934942632773, -0.52384750919471401, \
                     -0.51774914410666673, -0.26729886470788744, \
                     0.052065064174933465]
        self.assertEquals(dock.emaps, exp_emaps)

        exp_emap_total = -13.5485660526
        self.assertLessEqual(dock.emap_total - exp_emap_total, 0.0000000001)
        self.assertGreaterEqual(dock.emap_total - exp_emap_total, -0.0000000001)
Example #13
0
    def testCalcLinInterp3(self):
        ligand = Ligand()
        ligand.read_pdbqt("./Inputs/ind.pdbqt")
        ligand.update_tcoord_model("./Results/ind_1.model")

        grid = Grid()
        grid.field = Field("./Parameters/hsg1_rigid.maps.fld")
        grid.maps['e'] = ElectrostaticMap("./Maps/hsg1_rigid.e.map", grid.field).map
        grid.maps['d'] = DesolvationMap("./Maps/hsg1_rigid.d.map", grid.field).map
        grid.maps['A'] = AtomTypeMap("./Maps/hsg1_rigid.A.map", grid.field).map
        grid.maps['C'] = AtomTypeMap("./Maps/hsg1_rigid.C.map", grid.field).map
        grid.maps['HD'] = AtomTypeMap("./Maps/hsg1_rigid.HD.map", grid.field).map
        grid.maps['N'] = AtomTypeMap("./Maps/hsg1_rigid.N.map", grid.field).map
        grid.maps['NA'] = AtomTypeMap("./Maps/hsg1_rigid.NA.map", grid.field).map
        grid.maps['OA'] = AtomTypeMap("./Maps/hsg1_rigid.OA.map", grid.field).map

        protein = Protein()

        u0, v0, w0, u1, v1, w1, \
            p000, p001, p010, p011, p100, p101, p110, p111 = \
            Dock.calc_linInterp3(grid, ligand, protein)

        exp_u0 = [24, 27, 30, 33, 33, 36, 28, 24, 22, 29, 29, 32, 32, 35, 29, \
                  28, 27, 25, 25, 21, 18, 15, 13, 15, 19, 21, 36, 28, 29, 28, \
                  35, 36, 36, 35, 35, 35, 22, 23, 25, 26, 26, 25, 23, 40, 41, \
                  40, 42, 26, 23]
        self.assertEquals(u0, exp_u0)
                
        exp_v0 = [29, 30, 27, 29, 31, 28, 25, 25, 27, 22, 23, 25, 25, 27, 27, \
                  30, 26, 28, 27, 28, 28, 27, 27, 27, 27, 28, 26, 24, 19, 18, \
                  28, 31, 31, 28, 25, 25, 31, 33, 37, 38, 36, 32, 31, 29, 28, \
                  33, 27, 24, 22]
        self.assertEquals(v0, exp_v0)

        exp_w0 = [18, 19, 21, 22, 24, 20, 24, 23, 21, 26, 30, 32, 36, 37, 37, \
                  35, 40, 42, 46, 47, 44, 44, 41, 38, 38, 41, 18, 41, 31, 29, \
                  41, 43, 46, 49, 47, 43, 16, 13, 12, 10, 7, 6, 10, 20, 24, \
                  19, 18, 46, 46]
        self.assertEquals(w0, exp_w0)

        exp_u1 = [25, 28, 31, 34, 34, 37, 29, 25, 23, 30, 30, 33, 33, 36, 30, \
                  29, 28, 26, 26, 22, 19, 16, 14, 16, 20, 22, 37, 29, 30, 29, \
                  36, 37, 37, 36, 36, 36, 23, 24, 26, 27, 27, 26, 24, 41, 42, \
                  41, 43, 27, 24]
        self.assertEquals(u1, exp_u1)
                
        exp_v1 = [30, 31, 28, 30, 32, 29, 26, 26, 28, 23, 24, 26, 26, 28, 28, \
                  31, 27, 29, 28, 29, 29, 28, 28, 28, 28, 29, 27, 25, 20, 19, \
                  29, 32, 32, 29, 26, 26, 32, 34, 38, 39, 37, 33, 32, 30, 29, \
                  34, 28, 25, 23]
        self.assertEquals(v1, exp_v1)
                
        exp_w1 = [19, 20, 22, 23, 25, 21, 25, 24, 22, 27, 31, 33, 37, 38, 38, \
                  36, 41, 43, 47, 48, 45, 45, 42, 39, 39, 42, 19, 42, 32, 30, \
                  42, 44, 47, 50, 48, 44, 17, 14, 13, 11, 8, 7, 11, 21, 25, \
                  20, 19, 47, 47]
        self.assertEquals(w1, exp_w1)

        exp_p000 = [0.0049920000000003, 0.07082279822222158, \
                    0.010670762666666705, 0.014893662814814962, \
                    0.05954753422222141, 0.06692323555555484, \
                    0.02218827851851877, 0.05730432948148176, \
                    0.09164231111110999, 0.11063039999999903, \
                    0.07689557333333293, 0.05574929066666695, \
                    0.15205717333333324, 0.510503367111111, \
                    0.13600474074074018, 0.3160871632592622, \
                    0.14260223999999969, 0.020969604740741634, \
                    0.07576166400000024, 0.43352632888888754, \
                    0.24339291022222376, 0.11683840000000191, \
                    0.06234385066666788, 0.0069254826666658295, \
                    0.049472398222222956, 0.004077568000000049, \
                    0.005478324148148441, 0.001810014814814871, \
                    0.04792319999999972, 0.0, 0.11909688888888928, \
                    0.06675531851851867, 0.34005930666666545, \
                    0.019190670222224544, 0.022714595555556102, \
                    0.02363960888888848, 0.04932630755555612, \
                    0.028551111111111964, 0.0027955200000004095, \
                    0.002817744592593219, 0.013583075555555114, \
                    0.2548221724444463, 0.007528391111110991, \
                    0.04061548088888999, 0.031737780148146724, \
                    0.017002571851849876, 0.1769813333333323, \
                    0.061945476740739906, 0.7125060266666654]
        self.assertEquals(p000, exp_p000)
        
        exp_p001 = [0.0046080000000002855, 0.028647423999999776, \
                    0.052845681777776904, 0.038809448296297094, \
                    0.010895132444444356, 0.12177009777777835, \
                    0.06019394370370367, 0.010699226074073875, \
                    0.0982243555555557, 0.40154737777778016, \
                    0.22347775999999855, 0.18181870933333166, \
                    0.3616494933333342, 0.1806112995555552, \
                    0.14577303703703634, 0.0034079478518515044, \
                    0.2535150933333334, 0.04401883970370486, \
                    0.17345433599999888, 0.17308700444444436, \
                    0.018132423111111077, 0.022254933333333133, \
                    0.052258816000000166, 0.010048739555554584, \
                    0.06794626844444453, 0.004370432000000051, \
                    0.02819989807407561, 0.006367762962963142, \
                    0.6432768000000015, 0.2736355555555557, \
                    0.05954844444444527, 0.16720023703703696, \
                    0.009316693333334796, 0.5805177742222254, \
                    0.032240071111111795, 0.01006705777777773, \
                    0.06143635911111165, 0.3997155555555576, \
                    8.448000000000805e-05, 0.5255093665185175, \
                    0.28604359111111133, 0.012100494222221909, \
                    0.3957782755555553, 0.008835185777778117, \
                    0.009876442074073755, 0.0010596503703702597, \
                    0.039907555555555606, 0.0033060788148146308, \
                    0.01752064000000065]
        self.assertEquals(p001, exp_p001)
                
        exp_p010 = [0.01580800000000109, 0.43991853511111095, \
                    0.02382523733333365, 0.1596414482962953, \
                    0.5130249102222195, 0.10615409777777662, \
                    0.002949499259259329, 0.10673478162962986, \
                    0.004891022222222317, 0.013209599999999733, \
                    0.10332842666666649, 0.1244747093333352, \
                    0.03738282666666654, 0.2064957440000002, \
                    0.024884148148148186, 0.15615461451851684, \
                    0.11083775999999886, 0.010866839703704239, \
                    0.004494336000000094, 0.014331448888888855, \
                    0.4986586453333299, 0.017561600000000257, \
                    0.23359214933333552, 0.22917051733333157, \
                    0.05838893511111133, 0.0383970986666671, \
                    0.001462120296296389, 0.06606554074074122, \
                    0.011980799999999877, 0.0, 0.4462364444444414, \
                    0.0664002370370377, 0.0726340266666656, \
                    0.004958663111111672, 0.02357873777777808, \
                    0.08857372444444203, 0.0029261368888889743, \
                    0.020337777777778118, 0.20686847999999752, \
                    0.0013920331851854889, 0.018452479999999438, \
                    0.00484716088888932, 0.006658275555555493, \
                    0.04261296355555679, 0.006903997629629396, \
                    0.6205938725925908, 0.36701866666666505, \
                    0.1253896343703712, 0.19322197333333457]
        self.assertEquals(p010, exp_p010)
                
        exp_p011 = [0.01459200000000103, 0.17794457600000016, \
                    0.11799165155555476, 0.41598877392592776, \
                    0.09386575644444448, 0.19315256888888976, \
                    0.008001611851851947, 0.019928329481481058, \
                    0.005242311111111285, 0.04794595555555529, \
                    0.3002982399999991, 0.4059572906666669, \
                    0.08891050666666664, 0.07305625599999993, \
                    0.026671407407407432, 0.001683607703703498, \
                    0.19704490666666513, 0.02281138251851927, \
                    0.010289664000000117, 0.0057218844444444465, \
                    0.0371493546666661, 0.003345066666666631, \
                    0.19580518399999866, 0.3325219271111166, \
                    0.08019239822222142, 0.04115490133333377, \
                    0.007526324148148633, 0.2324233481481492, \
                    0.16081919999999966, 0.5156977777777759, \
                    0.22311822222222305, 0.16631087407407527, \
                    0.0019899733333336236, 0.14999955911111074, \
                    0.033466595555555895, 0.03771960888888834, \
                    0.0036445297777778743, 0.2847288888888866, \
                    0.006251519999999605, 0.2596141890370355, \
                    0.38858752000000113, 0.0002301724444444573, \
                    0.3500350577777798, 0.009269703111111484, \
                    0.002148446814814769, 0.03867723851851886, \
                    0.08275911111111132, 0.00669214340740717, \
                    0.004751360000000215]
        self.assertEquals(p011, exp_p011)
                
        exp_p100 = [0.11980799999999879, 0.027907868444444307, \
                    0.04129723733333381, 0.008772114962962983, \
                    0.028367132444444516, 0.0702145422222216, \
                    0.21554327703703846, 0.23706722607407538, \
                    0.36656924444444156, 0.082329599999999, \
                    0.03233109333333362, 0.016840931555555577, \
                    0.08553215999999973, 0.015427299555555727, \
                    0.2720094814814818, 0.34610661451852076, \
                    0.059957760000000714, 0.19156017303703798, \
                    0.21121433600000142, 0.2582710044444453, \
                    0.061865756444445814, 0.6134016000000012, \
                    0.05225881600000055, 0.005042517333332682, \
                    0.1437791573333353, 0.042258432000000005, \
                    0.12291989807407339, 0.004092207407407501, \
                    0.007543466666666573, 0.0, 0.021347555555555793, \
                    0.07629179259259218, 0.4619673599999994, \
                    0.006238663111111675, 0.18009429333333427, \
                    0.12410794666666769, 0.37106835911111075, \
                    0.010382222222222482, 0.010146702222223856, \
                    0.0007520331851853598, 0.005638257777777585, \
                    0.6820240497777759, 0.002377386666666608, \
                    0.36019518577777554, 0.5946657754074057, \
                    0.008099650370369561, 0.0884906666666671, \
                    0.2519674121481454, 0.05528063999999922]
        self.assertEquals(p100, exp_p100)
                
        exp_p101 = [0.11059199999999907, 0.011288575999999958, \
                    0.2045196515555538, 0.022858107259259554, \
                    0.005190200888888931, 0.12775879111111194, \
                    0.5847411674074044, 0.044262551703702906, \
                    0.3928974222222245, 0.2988259555555563, \
                    0.09396224000000072, 0.05492440177777706, \
                    0.20342783999999997, 0.0054580337777778275, \
                    0.29154607407407424, 0.0037316077037033123, \
                    0.10659157333333487, 0.4021180491851807, \
                    0.48356966399999857, 0.10311566222222283, \
                    0.0046089102222222865, 0.11683839999999726, \
                    0.04380518399999974, 0.00731659377777701, \
                    0.19746884266666664, 0.045293567999999985, \
                    0.6327352130370342, 0.014396681481481769, \
                    0.10125653333333291, 0.07303111111111188, \
                    0.010673777777778011, 0.19108598518518363, \
                    0.012656640000002016, 0.18871955911110633, \
                    0.2556177066666673, 0.05285205333333443, \
                    0.46216897422222053, 0.14535111111111115, \
                    0.00030663111111114483, 0.14025418903703818, \
                    0.11873507555555546, 0.03238661688888772, \
                    0.12498261333333217, 0.07835414755555593, \
                    0.18505333570370552, 0.0005047940740740295, \
                    0.019953777777778015, 0.01344769896296225, \
                    0.0013593600000000336]
        self.assertEquals(p101, exp_p101)
                
        exp_p110 = [0.3793919999999994, 0.1733507982222229, \
                    0.09220676266666863, 0.09402610725925796, \
                    0.24439375644444714, 0.11137479111111008, \
                    0.028652278518519068, 0.4415603294814827, \
                    0.019564088888889355, 0.009830399999999769, \
                    0.0434449066666672, 0.03760173511111153, \
                    0.021027839999999878, 0.006240256000000077, \
                    0.04976829629629663, 0.1709849410370347, \
                    0.04660224000000018, 0.09927004918518634, \
                    0.012529664000000305, 0.00853788444444448, \
                    0.12674935466666779, 0.09219840000000003, \
                    0.19580518400000008, 0.16686148266666403, \
                    0.1696928426666671, 0.3979335679999997, \
                    0.0328063241481483, 0.14936557037037024, \
                    0.0018858666666666348, 0.0, 0.07998577777777786, \
                    0.07588598518518534, 0.09867263999999876, \
                    0.0016120035555556883, 0.18694570666666555, \
                    0.4650120533333325, 0.022012529777778147, \
                    0.007395555555555644, 0.7508559644444464, \
                    0.0003715223703704551, 0.007659519999999756, \
                    0.012973283555556579, 0.0021026133333332956, \
                    0.3779097031111094, 0.12935911348148255, \
                    0.29563723851852247, 0.18350933333333447, \
                    0.5100308100740788, 0.01499135999999991]
        self.assertEquals(p110, exp_p110)
                
        exp_p111 = [0.3502080000000001, 0.07011942400000036, \
                    0.45664301511111166, 0.2450103371851844, \
                    0.04471557688888963, 0.2026518755555568, \
                    0.07772994370370429, 0.08244322607407237, \
                    0.020969244444445232, 0.03568071111111079, \
                    0.1262617600000014, 0.12263293155555516, \
                    0.05001215999999986, 0.002207744000000023, \
                    0.05334281481481515, 0.0018435034074071772, \
                    0.08284842666666718, 0.20838506192592499, \
                    0.02868633600000042, 0.0034087822222222453, \
                    0.009442645333333338, 0.01756159999999956, \
                    0.1641308159999974, 0.2421127395555576, \
                    0.23305915733333074, 0.4265144319999994, \
                    0.16887189807407502, 0.5254788740740721, \
                    0.025314133333333114, 0.13763555555555645, \
                    0.039992888888889355, 0.19006957037037026, \
                    0.0027033600000004004, 0.048763107555553936, \
                    0.26534229333333104, 0.19802794666666879, \
                    0.02741680355555594, 0.10353777777777645, \
                    0.02269070222222112, 0.06928892207407435, \
                    0.16130048000000022, 0.0006160497777778058, \
                    0.11053738666666636, 0.08220763022222277, \
                    0.040255108740741584, 0.018424983703704163, \
                    0.041379555555556106, 0.027220745481480586, \
                    0.0003686400000000121]
        self.assertEquals(p111, exp_p111)