Python Grid.createLinearBoundaryGrid方法代码示例

# 需要导入模块: from pysgpp import Grid [as 别名]
# 或者: from pysgpp.Grid import createLinearBoundaryGrid [as 别名]
def createGrid(grid, dim, deg=1, addTruncatedBorder=False):
    # create new grid
    gridType = grid.getType()

    if gridType in [Poly, PolyBoundary]:
        deg = max(deg, grid.getDegree())

    # print gridType, deg
    if deg > 1:
        if gridType in [LinearBoundary, PolyBoundary]:
            return Grid.createPolyBoundaryGrid(dim, deg)
        elif gridType == LinearL0Boundary:
            raise NotImplementedError("there is no full boundary polynomial grid")
        elif gridType in [Linear, Poly]:
            return Grid.createPolyGrid(dim, deg)
        else:
            raise Exception('unknown grid type %s' % gridType)
    else:
        if gridType == Linear:
            return Grid.createLinearGrid(dim)
        elif gridType == LinearBoundary:
            return Grid.createLinearBoundaryGrid(dim)
        elif gridType == LinearL0Boundary:
            return Grid.createLinearBoundaryGrid(dim, 0)
        else:
            raise Exception('unknown grid type %s' % gridType)

# 需要导入模块: from pysgpp import Grid [as 别名]
# 或者: from pysgpp.Grid import createLinearBoundaryGrid [as 别名]
 def testOperationB(self):
     from pysgpp import Grid, DataVector, DataMatrix
     factory = Grid.createLinearBoundaryGrid(1)
     gen = factory.createGridGenerator()
     gen.regular(2)
     
     alpha = DataVector(factory.getStorage().size())
     p = DataMatrix(1,1)
     beta = DataVector(1)
     
     
     alpha.setAll(0.0)
     p.set(0,0,0.25)
     beta[0] = 1.0
     
     opb = factory.createOperationB()
     opb.mult(beta, p, alpha)
     
     self.failUnlessAlmostEqual(alpha[0], 0.75)
     self.failUnlessAlmostEqual(alpha[1], 0.25)
     self.failUnlessAlmostEqual(alpha[2], 0.5)
     self.failUnlessAlmostEqual(alpha[3], 1.0)
     self.failUnlessAlmostEqual(alpha[4], 0.0)
     
     alpha.setAll(0.0)
     alpha[2] = 1.0
     
     p.set(0,0, 0.25)
     
     beta[0] = 0.0
     
     opb.multTranspose(alpha, p, beta)
     self.failUnlessAlmostEqual(beta[0], 0.5)

# 需要导入模块: from pysgpp import Grid [as 别名]
# 或者: from pysgpp.Grid import createLinearBoundaryGrid [as 别名]
    def testRefinement2d_two(self):
        from pysgpp import Grid, DataVector, SurplusRefinementFunctor
        factory = Grid.createLinearBoundaryGrid(2)
        storage = factory.getStorage()
        
        gen = factory.createGridGenerator()
        gen.regular(0)
        
        alpha = DataVector(4)
    
        for i in xrange(len(alpha)):
            alpha[i] = 0.0

        alpha[0] = 1.0
        func = SurplusRefinementFunctor(alpha)
            
        gen.refine(func)
        
        alpha2 = DataVector(8)
    
        for i in xrange(len(alpha2)):
            alpha2[i] = 0.0

        alpha2[4] = 1.0
        func = SurplusRefinementFunctor(alpha2)
            
        gen.refine(func)    
        self.failUnlessEqual(storage.size(), 13)        

# 需要导入模块: from pysgpp import Grid [as 别名]
# 或者: from pysgpp.Grid import createLinearBoundaryGrid [as 别名]
    def testSerializationLinearBoudaryBoundingBox(self):
        """Uses Linear grid for tests"""
        from pysgpp import Grid
        
        factory = Grid.createLinearBoundaryGrid(2)
        self.failIfEqual(factory, None)

        gen = factory.createGridGenerator()
        gen.regular(3)

        boundingBox = factory.getBoundingBox()
        tempBound = boundingBox.getBoundary(0)
        tempBound.leftBoundary = 0.0
        tempBound.rightBoundary = 100.0
        tempBound.bDirichletLeft = False;
        tempBound.bDirichletRight = False;
        boundingBox.setBoundary(0, tempBound)

        str = factory.serialize()
        self.assert_(len(str) > 0)
        
        newfac = Grid.unserialize(str)
        self.failIfEqual(newfac, None)
        
        self.assertEqual(factory.getStorage().size(), newfac.getStorage().size())
            
        boundingBox = newfac.getBoundingBox()
        tempBound = boundingBox.getBoundary(0)
        self.assertEqual(0.0, tempBound.leftBoundary)
        self.assertEqual(100.0, tempBound.rightBoundary)
        self.assertEqual(False, tempBound.bDirichletLeft)
        self.assertEqual(False, tempBound.bDirichletRight)

# 需要导入模块: from pysgpp import Grid [as 别名]
# 或者: from pysgpp.Grid import createLinearBoundaryGrid [as 别名]
    def testOperationTest_test(self):
        from pysgpp import Grid, DataVector, DataMatrix

        factory = Grid.createLinearBoundaryGrid(1)
        gen = factory.createGridGenerator()
        gen.regular(1)
        
        alpha = DataVector(factory.getStorage().size())        
        
        data = DataMatrix(1,1)
        data.setAll(0.25)
        classes = DataVector(1)
        classes.setAll(1.0)

        testOP = factory.createOperationTest()

        alpha[0] = 0.0
        alpha[1] = 0.0
        alpha[2] = 1.0
        
        c = testOP.test(alpha, data, classes)
        self.failUnless(c > 0.0)
        
        alpha[0] = 0.0
        alpha[1] = 0.0
        alpha[2] = -1.0
        c = testOP.test(alpha, data, classes)
        self.failUnless(c == 0.0)

# 需要导入模块: from pysgpp import Grid [as 别名]
# 或者: from pysgpp.Grid import createLinearBoundaryGrid [as 别名]
 def testHierarchisationDBoundary(self):
     from pysgpp import Grid
     
     dim = 3
     level = 5
     function = buildParableBoundary(dim)
     grid = Grid.createLinearBoundaryGrid(dim)
     testHierarchisationDehierarchisation(self, grid, level, function)

# 需要导入模块: from pysgpp import Grid [as 别名]
# 或者: from pysgpp.Grid import createLinearBoundaryGrid [as 别名]
 def test34(self):
     from pysgpp import Grid, DataVector, FullGrid, FullGridSet
     
     dim = 2
     level = 9
     function = buildParableBoundary(dim)
     grid = Grid.createLinearBoundaryGrid(dim)
     testFG(self, grid, level, function)

# 需要导入模块: from pysgpp import Grid [as 别名]
# 或者: from pysgpp.Grid import createLinearBoundaryGrid [as 别名]
    def testHatRegulardD_two(self):
        from pysgpp import Grid
        
        factory = Grid.createLinearBoundaryGrid(3)

        m = generateLaplaceMatrix(factory, 4)
        m_ref = readReferenceMatrix(self, factory.getStorage(), 'data/C_laplace_phi_li_hut_l0_rand_dim_3_nopsgrid_297_float.dat.gz')

        # compare
        compareStiffnessMatrices(self, m, m_ref)    

# 需要导入模块: from pysgpp import Grid [as 别名]
# 或者: from pysgpp.Grid import createLinearBoundaryGrid [as 别名]
    def testHatRegulardD_two(self):
        from pysgpp import Grid

        factory = Grid.createLinearBoundaryGrid(3)
        training = buildTrainingVector(readDataVector('data/data_dim_3_nops_512_float.arff.gz'))
        level = 3
        gen = factory.createGridGenerator()
        gen.regular(level)

        m = generateBBTMatrix(factory, training)
        m_ref = readReferenceMatrix(self, factory.getStorage(), 'data/BBT_phi_li_hut_trapezrand_dim_3_nopsgrid_225_float.dat.gz')

        # compare
        compareBBTMatrices(self, m, m_ref)

# 需要导入模块: from pysgpp import Grid [as 别名]
# 或者: from pysgpp.Grid import createLinearBoundaryGrid [as 别名]
 def testGeneration(self):
     from pysgpp import Grid, DataVector
     factory = Grid.createLinearBoundaryGrid(2)
     storage = factory.getStorage()
     
     gen = factory.createGridGenerator()
     self.failIfEqual(gen, None)
     
     self.failUnlessEqual(storage.size(), 0)
     gen.regular(3)
     self.failUnlessEqual(storage.size(), 37)
     
     #This should fail
     self.failUnlessRaises(Exception, gen.regular, 3)

# 需要导入模块: from pysgpp import Grid [as 别名]
# 或者: from pysgpp.Grid import createLinearBoundaryGrid [as 别名]
    def testHatRegular1D_one(self):
        from pysgpp import Grid
        
        factory = Grid.createLinearBoundaryGrid(1, 0)
        training = buildTrainingVector(readDataVector('data/data_dim_1_nops_8_float.arff.gz'))
        level = 4
        gen = factory.createGridGenerator()
        gen.regular(level)

        m = generateBTMatrix(factory, training)
        m_ref = readReferenceMatrix(self, factory.getStorage(), 'data/BT_phi_li_hut_l0_rand_dim_1_nopsgrid_17_float.dat.gz')

        # compare
        compareBTMatrices(self, m, m_ref) 

# 需要导入模块: from pysgpp import Grid [as 别名]
# 或者: from pysgpp.Grid import createLinearBoundaryGrid [as 别名]
    def testOperationEval_eval(self):
        from pysgpp import Grid, DataVector

        factory = Grid.createLinearBoundaryGrid(1)
        gen = factory.createGridGenerator()
        gen.regular(1)
        
        alpha = DataVector(factory.getStorage().size())        
        alpha.setAll(1.0)

        p = DataVector(1)
        p.setAll(0.25)
        
        eval = factory.createOperationEval()

        self.failUnlessAlmostEqual(eval.eval(alpha, p), 1.5)

# 需要导入模块: from pysgpp import Grid [as 别名]
# 或者: from pysgpp.Grid import createLinearBoundaryGrid [as 别名]
def eval_fullGrid(level, dim, border=True):
    if border:
        grid = Grid.createLinearBoundaryGrid(dim)
    else:
        grid = Grid.createLinearGrid(dim)

    grid.createGridGenerator().full(level)
    gs = grid.getStorage()
    ans = DataMatrix(gs.size(), dim)
    p = DataVector(dim)

    for i in xrange(gs.size()):
        gs.get(i).getCoords(p)
        ans.setRow(i, p)

    return ans

# 需要导入模块: from pysgpp import Grid [as 别名]
# 或者: from pysgpp.Grid import createLinearBoundaryGrid [as 别名]
    def testSerializationLinearBoudary(self):
        """Uses Linear grid for tests"""
        from pysgpp import Grid
        
        factory = Grid.createLinearBoundaryGrid(2)
        self.failIfEqual(factory, None)

        gen = factory.createGridGenerator()
        gen.regular(3)

        str = factory.serialize()
        self.assert_(len(str) > 0)
        
        newfac = Grid.unserialize(str)
        self.failIfEqual(newfac, None)
        
        self.assertEqual(factory.getStorage().size(), newfac.getStorage().size())        

# 需要导入模块: from pysgpp import Grid [as 别名]
# 或者: from pysgpp.Grid import createLinearBoundaryGrid [as 别名]
def createGrid(dim, level, borderType, isFull=False):
    from pysgpp.extensions.datadriven.learner.Types import BorderTypes
    if borderType == BorderTypes.NONE:
        grid = Grid.createLinearGrid(dim)
    elif borderType == BorderTypes.TRAPEZOIDBOUNDARY:
        grid = Grid.createLinearTrapezoidBoundaryGrid(dim)
    elif borderType == BorderTypes.COMPLETEBOUNDARY:
        grid = Grid.createLinearBoundaryGrid(dim, 0)
    else:
        raise Exception('Unknown border type')

    # create regular grid of level accLevel
    gridGen = grid.createGridGenerator()
    if isFull:
        gridGen.full(level)
    else:
        gridGen.regular(level)

    return grid