def checkRemovePoints(self): ''' tests removePointsByHierarchicalCoefficient() ''' grid = TasmanianSG.makeLocalPolynomialGrid(2, 1, 1) aPoints = grid.getNeededPoints() grid.loadNeededValues(np.exp(-aPoints[:,0]**2 -0.5*aPoints[:,1]**2).reshape((grid.getNumNeeded(), 1))) reduced = TasmanianSG.TasmanianSparseGrid() reduced.copyGrid(grid) reduced.removePointsByHierarchicalCoefficient(0.6) self.assertEqual(reduced.getNumPoints(), 3, "failed to remove points with threshold 0.6") np.testing.assert_almost_equal(reduced.getLoadedPoints(), np.array([[0.0, 0.0], [-1.0, 0.0], [1.0, 0.0]]), 14, "failed reduce 1", True) reduced.copyGrid(grid) reduced.removePointsByHierarchicalCoefficient(0.7) self.assertEqual(reduced.getNumPoints(), 1, "failed to remove points with threshold 0.7") np.testing.assert_almost_equal(reduced.getLoadedPoints(), np.array([[0.0, 0.0]]), 14, "failed reduce 2", True) reduced.copyGrid(grid) reduced.removePointsByHierarchicalCoefficient(0.0, iNumKeep = 3) self.assertEqual(reduced.getNumPoints(), 3, "failed to remove points down to 3") np.testing.assert_almost_equal(reduced.getLoadedPoints(), np.array([[0.0, 0.0], [-1.0, 0.0], [1.0, 0.0]]), 14, "failed reduce 3", True) reduced.copyGrid(grid) reduced.removePointsByHierarchicalCoefficient(0.0, iNumKeep = 1) self.assertEqual(reduced.getNumPoints(), 1, "failed to remove points down to 1") np.testing.assert_almost_equal(reduced.getLoadedPoints(), np.array([[0.0, 0.0]]), 14, "failed reduce 4", True) reduced.copyGrid(grid) reduced.removePointsByHierarchicalCoefficient(0.0, aScaleCorrection = np.array([[1.0], [1.0], [1.0], [0.1], [0.1]]), iNumKeep = 3) self.assertEqual(reduced.getNumPoints(), 3, "failed to remove corrected points") np.testing.assert_almost_equal(reduced.getLoadedPoints(), np.array([[0.0, 0.0], [0.0, -1.0], [0.0, 1.0]]), 14, "failed reduce 5", True)
def main(): #valList = [] start_time = time.clock() output = dict() output[0] = [] for shock in range(5): paramL['curr_theta'] = paramL['theta_list'][shock] valnew = TasmanianSG.TasmanianSparseGrid() valnew = interpol.sparse_grid(paramL) valold = TasmanianSG.TasmanianSparseGrid() valold = valnew output[0].append(valold) valnew.write("valnew_1." + str(paramL['numstart']) + ".s{}".format(shock) + ".txt") #write file to disk for restart for i in range(paramL['numstart'] + 1, paramL['numits'] + 1): output[i] = list() for shock in range(5): paramL['curr_theta'] = paramL['theta_list'][shock] valnew = TasmanianSG.TasmanianSparseGrid() valnew = interpol_iter.sparse_grid_iter(paramL, list(output[i - 1])) valold = TasmanianSG.TasmanianSparseGrid() valold = valnew output[i].append(valold) valnew.write("valnew_1." + str(i) + ".s{}".format(shock) + ".txt") avg_err = post.ls_error(paramL) end_time = time.clock() - start_time print('END') print(end_time) return output
def checkPathsVersions(self): ''' Check different ways to specify the library path and check the version number. ''' if (tdata.bEnableSyncTests): grid = TasmanianSG.TasmanianSparseGrid(tdata.sLibPath) sVersion = grid.getVersion() self.assertEqual(sVersion, TasmanianSG.__version__, "version mismatch") pLibTSG = cdll.LoadLibrary(tdata.sLibPath) grid = TasmanianSG.TasmanianSparseGrid(pLibTSG) sVersion = grid.getVersion() self.assertEqual(sVersion, TasmanianSG.__version__, "version mismatch") grid = TasmanianSG.TasmanianSparseGrid() sVersion = grid.getVersion() self.assertEqual(sVersion, TasmanianSG.__version__, "version mismatch") sLicense = grid.getLicense() self.assertEqual(sLicense, TasmanianSG.__license__, "license mismatch") iVM = int(sVersion.split('.')[0]) iVm = int(sVersion.split('.')[1]) self.assertEqual(iVM, grid.getVersionMajor(), "version major mismatch") self.assertEqual(iVm, grid.getVersionMinor(), "version minor mismatch")
def checkFileIO(self): ''' Read/Write regular refinement. ''' grid = TasmanianSG.TasmanianSparseGrid() sRefinementIOGrids = [ "grid.makeGlobalGrid(2, 1, 2, 'level', 'clenshaw-curtis')", "grid.makeSequenceGrid(2, 1, 2, 'level', 'rleja')" ] for sTest in sRefinementIOGrids: exec(sTest) ttc.loadExpN2(grid) grid.setAnisotropicRefinement('iptotal', 20, 0) self.assertTrue(grid.getNumNeeded() > 0, 'did not refine') gridB = TasmanianSG.TasmanianSparseGrid() gridB.copyGrid(grid) ttc.compareGrids(grid, gridB) grid.write("refTestFlename.grid", bUseBinaryFormat=True) gridB.makeLocalPolynomialGrid(1, 1, 0, 1) gridB.read("refTestFlename.grid") ttc.compareGrids(grid, gridB) grid.write("refTestFlename.grid", bUseBinaryFormat=False) gridB.makeLocalPolynomialGrid(1, 1, 0, 1) gridB.read("refTestFlename.grid") ttc.compareGrids(grid, gridB)
def ls_error(n_agents, t1, t2, num_points): file=open('errors.txt', 'w') np.random.seed(0) unif=np.random.rand(num_points, n_agents) k_sample=k_bar+(unif)*(k_up-k_bar) to_print=np.empty((1,3)) for i in range(t1, t2): sum_diffs=0 diff = 0 v_prev=TasmanianSG.TasmanianSparseGrid() v_next=TasmanianSG.TasmanianSparseGrid() v_prev.read("valnew_1." + str(i) + ".txt") v_next.read("valnew_1." + str(i+1) + ".txt") diff=v_next.evaluateBatch(k_sample) - v_prev.evaluateBatch(k_sample) max_abs_diff=np.amax(np.fabs(diff)) average = np.average(np.fabs(diff)) to_print[0,0]=i+1 to_print[0,1]=max_abs_diff to_print[0,2]= average np.savetxt(file, to_print, fmt='%2.16f') file.close() return
def main(): start_time = time.clock() paramL['curr_theta'] = paramL['theta_list'][rank] valnew = TasmanianSG.TasmanianSparseGrid() valnew = interpol.sparse_grid(paramL) valold = TasmanianSG.TasmanianSparseGrid() valold = valnew valnew.write("valnew_1." + str(paramL['numstart']) + ".s{}".format(rank) + ".txt") #write file to disk for restart comm.barrier() for i in range(paramL['numstart'] + 1, paramL['numits'] + 1): print('Size: ', size, ' rank ', rank) paramL['curr_theta'] = paramL['theta_list'][rank] valnew = TasmanianSG.TasmanianSparseGrid() output = get_iteration_list(i - 1) valnew = interpol_iter.sparse_grid_iter(paramL, list(output)) valold = TasmanianSG.TasmanianSparseGrid() valold = valnew valnew.write("valnew_1." + str(i) + ".s{}".format(rank) + ".txt") comm.barrier() end_time = time.clock() - start_time print('END') if rank == 0: avg_err = post.ls_error(paramL) print(end_time)
def sparse_grid_iter(n_agents, iDepth, iG, Lvalold): grid = TasmanianSG.TasmanianSparseGrid() k_range = np.array([k_bar, k_up]) ranges = np.empty((n_agents, 2)) for i in range(n_agents): ranges[i] = k_range iDim = n_agents grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp") grid.setDomainTransform(ranges) aPoints = grid.getPoints() iNumP1 = aPoints.shape[0] aVals = np.empty([iNumP1, iOut]) file = open("comparison1.txt", 'w') for iI in range(iNumP1): aVals[iI] = solveriter.iterate(aPoints[iI], n_agents, Lvalold, phi[iG])[0] grid.loadNeededPoints(aVals) # Get interpolant at sparse grid #refinement level for iK in range(refinement_level): grid.setSurplusRefinement(fTol, 1, "fds") #also use fds, or other rules aPoints = grid.getNeededPoints() #grid.plotPoints2D() print("Number of Points", grid.getNumPoints()) aVals = np.empty([aPoints.shape[0], iOut]) for iI in range(aPoints.shape[0]): # Solve the value function problem for all grid points aVals[iI] = solveriter.iterate(aPoints[iI], n_agents, Lvalold, phi[iG])[0] # Update interpolant grid.loadNeededPoints(aVals) #print(" {0:9d} {1:9d} {2:1.2e}".format(iK+1, grid.getNumPoints())) grid2 = TasmanianSG.TasmanianSparseGrid() grid2.makeLocalPolynomialGrid(iDim, iOut, refinement_level + iDepth, which_basis, "localp") print("Max Number of Points", grid2.getNumPoints()) #f=open("grid_iter.txt", 'w') #np.savetxt(f, aPoints, fmt='% 2.16f') #f.close() return grid #======================================================================
def checkConstruction(self): ''' Test read/write when using construction. ''' for sFormat in [False, True]: # test binary and ascii format gridA = TasmanianSG.TasmanianSparseGrid() gridB = TasmanianSG.TasmanianSparseGrid() gridA.makeGlobalGrid(3, 2, 2, "level", "clenshaw-curtis") gridB.makeGlobalGrid(3, 2, 2, "level", "clenshaw-curtis") gridA.beginConstruction() gridB.beginConstruction() gridB.write("testSave", bUseBinaryFormat=sFormat) gridB.makeSequenceGrid(1, 1, 0, "level", "rleja") # clean the grid gridB.read("testSave") ttc.compareGrids(gridA, gridB) for t in range(5): # use 5 iterations aPointsA = gridA.getCandidateConstructionPoints("level", 0) aPointsB = gridB.getCandidateConstructionPoints("level", 0) np.testing.assert_almost_equal(aPointsA, aPointsB, decimal=11) iNumPoints = int(aPointsA.shape[0] / 2) if (iNumPoints > 32): iNumPoints = 32 # use the first samples (up to 32) and shuffle the order # add one of the samples further in the list liSamples = list(range(iNumPoints + 1)) shuffle(liSamples) liSamples = map( lambda i: i if i < iNumPoints else iNumPoints + 1, liSamples) for iI in liSamples: # compute and load the samples aPoint = aPointsA[iI, :] aValue = np.array([ np.exp(aPoint[0] + aPoint[1]), 1.0 / ((aPoint[0] - 1.3) * (aPoint[1] - 1.6) * (aPoint[2] - 2.0)) ]) gridA.loadConstructedPoint(aPoint, aValue) gridB.loadConstructedPoint(aPoint, aValue) # using straight construction or read/write should produce the same result gridB.write("testSave", bUseBinaryFormat=sFormat) gridB.makeSequenceGrid(1, 1, 0, "level", "rleja") gridB.read("testSave") ttc.compareGrids(gridA, gridB) gridA.finishConstruction() gridB.finishConstruction() gridB.write("testSave", bUseBinaryFormat=sFormat) gridB.makeSequenceGrid(1, 1, 0, "level", "rleja") gridB.read("testSave") ttc.compareGrids(gridA, gridB)
def checkGlobalGridCustom(self): ''' Test makeGlobalGridCustom(), which creates a grid from a CustomTabulated instance. ''' gridA = TasmanianSG.makeGlobalGrid(1, 1, 3, "level", "custom-tabulated", [], 0.0, 0.0, tdata.sGaussPattersonTableFile) ct = TasmanianSG.makeCustomTabulatedFromFile(tdata.sGaussPattersonTableFile) gridB = TasmanianSG.makeGlobalGridCustom(1, 1, 3, "level", ct) ttc.compareGrids(gridA, gridB) gridA = TasmanianSG.makeGlobalGrid(2, 1, 3, "level", "custom-tabulated", [], 0.0, 0.0, tdata.sGaussPattersonTableFile) gridB = TasmanianSG.makeGlobalGridCustom(2, 1, 3, "level", ct) ttc.compareGrids(gridA, gridB)
def checkReadWriteMisc(self): ''' Test reading and writing of domain transforms and testing all rules. ''' lGrids = ['gridA.makeGlobalGrid(3, 2, 4, "level", "clenshaw-curtis"); gridA.setDomainTransform(aTransform); gridA.setConformalTransformASIN(np.array([3,4,5]))', 'gridA.makeGlobalGrid(3, 2, 4, "level", "gauss-legendre"); gridA.setConformalTransformASIN(np.array([3,5,1]))', 'gridA.makeSequenceGrid(2, 2, 5, "level", "leja"); gridA.setConformalTransformASIN(np.array([0,4]))', 'gridA.makeLocalPolynomialGrid(3, 1, 4, 2, "localp"); gridA.setDomainTransform(aTransform); gridA.setConformalTransformASIN(np.array([5,3,0]))', 'gridA.getNumPoints()'] aTransform = np.array([[0.0,1.0],[0.0,1.0],[-2.0,-1.0]]) for sGrid in lGrids: gridA = TasmanianSG.TasmanianSparseGrid() gridB = TasmanianSG.TasmanianSparseGrid() exec(sGrid) gridA.write("testSave", bUseBinaryFormat = False) gridB.read("testSave") ttc.compareGrids(gridA, gridB) gridA.write("testSave", bUseBinaryFormat = True) gridB.makeLocalPolynomialGrid(1, 1, 0) gridB.read("testSave") ttc.compareGrids(gridA, gridB) gridB.makeSequenceGrid(1, 1, 0, "level", "leja"); gridB.makeLocalPolynomialGrid(1, 1, 0) gridB.copyGrid(gridA) ttc.compareGrids(gridA, gridB) # Make a grid with every possible rule (catches false-positive and memory crashes) for sType in TasmanianSG.lsTsgGlobalTypes: for sRule in TasmanianSG.lsTsgGlobalRules: if ("custom-tabulated" in sRule): gridA.makeGlobalGrid(2, 0, 2, sType, sRule, sCustomFilename = tdata.sGaussPattersonTableFile) else: gridA.makeGlobalGrid(2, 0, 2, sType, sRule) gridA.write("testSave", bUseBinaryFormat = False) gridB.read("testSave") ttc.compareGrids(gridA, gridB) gridB.makeGlobalGrid(1, 0, 0, "level", "clenshaw-curtis") gridA.write("testSave", bUseBinaryFormat = True) gridB.read("testSave") for sType in TasmanianSG.lsTsgGlobalTypes: for sRule in TasmanianSG.lsTsgSequenceRules: gridA.makeSequenceGrid(2, 1, 3, sType, sRule) gridA.write("testSave", bUseBinaryFormat = False) gridB.read("testSave") ttc.compareGrids(gridA, gridB) gridB.makeGlobalGrid(1, 0, 0, "level", "clenshaw-curtis") gridA.write("testSave", bUseBinaryFormat = True) gridB.read("testSave") ttc.compareGrids(gridA, gridB)
def sparse_grid_iter(n_agents, iDepth, valold, itheta): grid = TasmanianSG.TasmanianSparseGrid() k_range=np.array([k_bar, k_up]) ranges=np.empty((n_agents, 2)) for i in range(n_agents): ranges[i]=k_range iDim=n_agents iOut=1 grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp") grid.setDomainTransform(ranges) aPoints=grid.getPoints() iNumP1=aPoints.shape[0] aVals=np.empty([iNumP1, 1]) for iI in range(iNumP1): aVals[iI]=solveriter.iterate(aPoints[iI], n_agents, valold, itheta)[0] v=aVals[iI]*np.ones((1,1)) file=open("comparison1.txt", 'w') grid.loadNeededPoints(aVals) for iK in range(refinement_level): grid.setSurplusRefinement(fTol, 1, "fds") #also use fds, or other rules aPoints = grid.getNeededPoints() aVals = np.empty([aPoints.shape[0], 1]) for iI in range(iNumP1): aVals[iI]=solveriter.iterate(aPoints[iI], n_agents, valold, itheta)[0] v=aVals[iI]*np.ones((1,1)) to_print=np.hstack((aPoints[iI].reshape(1,n_agents), v)) np.savetxt(file, to_print, fmt='%2.16f') file.close() grid.loadNeededPoints(aVals) f2=open("Adaptive_sparse_grid.txt", 'a') np.savetxt(f2, aPoints, fmt='% 2.16f') f2.close() grid2 = TasmanianSG.TasmanianSparseGrid() grid2.makeLocalPolynomialGrid(iDim, iOut, refinement_level+iDepth, which_basis, "localp") a = grid2.getNumPoints() f=open("grid_iter.txt", 'w') np.savetxt(f, aPoints, fmt='% 2.16f') f.close() return grid
def sparse_grid(n_agents, iDepth): grid = TasmanianSG.TasmanianSparseGrid( ) #grid. calls all the tasmanian stuff! k_range = np.array([k_bar, k_up]) ranges = np.empty((n_agents, 2)) for i in range(n_agents): ranges[i] = k_range iDim = n_agents grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp") grid.setDomainTransform(ranges) aPoints = grid.getPoints() iNumP1 = aPoints.shape[0] aVals = np.empty([iNumP1, 1]) file = open("comparison0.txt", 'w') for iI in range(iNumP1): aVals[iI] = solver.initial(aPoints[iI], n_agents)[0] v = aVals[iI] * np.ones((1, 1)) to_print = np.hstack((aPoints[iI].reshape(1, n_agents), v)) np.savetxt(file, to_print, fmt='%2.16f') file.close() grid.loadNeededPoints(aVals) f = open("grid.txt", 'w') np.savetxt(f, aPoints, fmt='% 2.16f') f.close() return grid
def checkMeta(self): ''' Check if the CMake options are propagated to the C++ library and the correct acceleration options are passed between C++ and Python. ''' grid = TasmanianSG.TasmanianSparseGrid() if (tdata.bEnableSyncTests): self.assertTrue( (grid.isAccelerationAvailable("cpu-blas") == tdata.bHasBlas), "failed to match blas") self.assertTrue((grid.isAccelerationAvailable("gpu-cublas") == tdata.bHasCuBlas), "failed to match cublas") self.assertTrue( (grid.isAccelerationAvailable("gpu-cuda") == tdata.bHasCuda), "failed to match cuda") self.assertTrue((grid.isAccelerationAvailable("gpu-default") == (tdata.bHasCuBlas or tdata.bHasCuda)), "failed to match cuda") # acceleration meta-data lsAvailableAcc = [] if (tdata.bHasBlas): lsAvailableAcc.append("cpu-blas") if (tdata.bHasCuBlas): lsAvailableAcc.append("gpu-cublas") if (tdata.bHasCuda): lsAvailableAcc.append("gpu-cuda") grid.makeLocalPolynomialGrid(2, 1, 2, 1, 'semi-localp') for accel in lsAvailableAcc: grid.enableAcceleration(accel) sA = grid.getAccelerationType() bTest = ((accel not in sA) or (sA not in accel)) self.assertFalse(bTest, "set/get Acceleration")
def checkPolynomialSpace(self): ''' Construct grids with specific parameters and check the polynomial space against known (pen-and-paper) exact spaces. ''' grid = TasmanianSG.TasmanianSparseGrid() aA = np.array([[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2], [3, 0], [4, 0]]) grid.makeGlobalGrid(2, 1, 2, 'level', 'clenshaw-curtis') aP = grid.getGlobalPolynomialSpace(True) np.testing.assert_equal(aP, aA, "poly space mismatch", True) aA = np.array([[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [1, 0], [1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [2, 0], [2, 1], [2, 2], [2, 3], [3, 0], [3, 1], [3, 2], [3, 3], [4, 0], [4, 1], [5, 0], [5, 1]]) grid.makeGlobalGrid(2, 1, 2, 'level', 'clenshaw-curtis') aP = grid.getGlobalPolynomialSpace(False) np.testing.assert_equal(aP, aA, "poly space mismatch", True) aA = np.array([[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [2, 0]]) grid.makeSequenceGrid(2, 1, 2, 'level', 'rleja') aP = grid.getGlobalPolynomialSpace(True) np.testing.assert_equal(aP, aA, "poly space mismatch", True) grid.makeSequenceGrid(2, 1, 2, 'level', 'rleja') aP = grid.getGlobalPolynomialSpace(False) np.testing.assert_equal(aP, aA, "poly space mismatch", True) aA = np.array([[0, 0], [0, 1], [0, 2], [0, 3], [1, 0], [1, 1], [1, 2], [1, 3], [2, 0], [2, 1], [3, 0], [3, 1]]) grid.makeGlobalGrid(2, 1, 1, 'level', 'leja-odd') aP = grid.getGlobalPolynomialSpace(False) np.testing.assert_equal(aP, aA, "poly space mismatch", True) grid.makeSequenceGrid(2, 1, 2, 'level', 'leja') aP = grid.getGlobalPolynomialSpace(False) np.testing.assert_equal(aP, aA, "poly space mismatch", True)
def checkAnisoCoeff(self): ''' Check anisotropic coefficients ''' grid = TasmanianSG.TasmanianSparseGrid() grid.makeGlobalGrid(2, 1, 9, 'level', 'rleja') aP = grid.getPoints() aV = np.exp(aP[:, 0] + aP[:, 1]**2) grid.loadNeededPoints(aV.reshape([aP.shape[0], 1])) aC = grid.estimateAnisotropicCoefficients('iptotal', 0) self.assertEqual(len(aC.shape), 1, 'dimensions of the estimated anisotropic weight') self.assertEqual(aC.shape[0], 2, 'dimensions of the estimated anisotropic weight') self.assertLess(np.abs(float(aC[0]) / float(aC[1]) - 2.0), 0.2, 'wrong anisotropic weights estimated') aC = grid.estimateAnisotropicCoefficients('ipcurved', 0) self.assertEqual(len(aC.shape), 1, 'dimensions of the estimated anisotropic weight') self.assertEqual(aC.shape[0], 4, 'dimensions of the estimated anisotropic weight') self.assertLess(np.abs(float(aC[0]) / float(aC[1]) - 2.0), 0.2, 'wrong anisotropic weights estimated, alpha curved') self.assertLess(aC[2], 0.0, 'wrong anisotropic weights estimated, beta 1') self.assertLess(aC[3], 0.0, 'wrong anisotropic weights estimated, beta 2')
def sparse_grid(n_agents, iDepth, sIdx): grid = TasmanianSG.TasmanianSparseGrid() k_range = np.array([k_bar, k_up]) ranges = np.empty((n_agents, 2)) for i in range(n_agents): ranges[i] = k_range iDim = n_agents # TODO: parameterize this refinement_level = 1 fTol = 1.E-5 grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp") grid.setDomainTransform(ranges) aPoints = grid.getPoints() iNumP1 = aPoints.shape[0] aVals = np.empty([iNumP1, 1]) for iI in range(iNumP1): aValTemp = 0 for sIdx in range(5): aValTemp += (1. / 5) * solver.initial(aPoints[iI], n_agents, sIdx)[0] aVals[iI] = aValTemp grid.loadNeededPoints(aVals) for ik in range(refinement_level): grid.setSurplusRefinement(fTol, 1, "fds") #also use fds, or other rules aPoints = grid.getNeededPoints() iNumP1 = aPoints.shape[0] aVals = np.empty([iNumP1, 1]) print(ik) file = open("comparison1.txt", 'w') for iI in range(iNumP1): aValTemp = 0 for sIdx in range(5): aValTemp += (1. / 5) * solver.initial(aPoints[iI], n_agents, sIdx)[0] aVals[iI] = aValTemp v = aVals[iI] * np.ones((1, 1)) to_print = np.hstack((aPoints[iI].reshape(1, n_agents), v)) np.savetxt(file, to_print, fmt='%2.16f') print(aVals) file.close() grid.loadNeededPoints(aVals) f = open("grid.txt", 'w') np.savetxt(f, aPoints, fmt='% 2.16f') f.close() return grid
def checkMetaIO(self): ''' Test the version I/O, available acceleration, gpu info, print stats ''' grid = TasmanianSG.TasmanianSparseGrid() print("Tasmanian Sparse Grids version: {0:1s}".format( grid.getVersion())) print(" version major: {0:1d}".format( grid.getVersionMajor())) print(" version minor: {0:1d}".format( grid.getVersionMinor())) print(" License: {0:1s}".format( grid.getLicense())) if (grid.isOpenMPEnabled()): sStatus = "Enabled" else: sStatus = "Disabled" print(" OpenMP: {0:1s}".format(sStatus)) sAvailableAcceleration = "" for s in ["cpu-blas", "gpu-cublas", "gpu-cuda", "gpu-magma"]: if (grid.isAccelerationAvailable(s)): sAvailableAcceleration += " " + s print(" Available acceleration:{0:1s}".format( sAvailableAcceleration)) print(" Available GPUs:") if (grid.getNumGPUs() > 0): for iGPU in range(grid.getNumGPUs()): sName = "" if ("@CMAKE_CXX_COMPILER_ID@" == "MSVC"): sName = "Unavailable under Windows" else: sName = grid.getGPUName(iGPU) sMem = grid.getGPUMemory(iGPU) print(" {0:2d}: {1:20s} with{2:6d}MB RAM".format( iGPU, sName, sMem)) else: print(" none") # covers the printStats() in python and C++ grid.printStats() # empty grid grid.makeGlobalGrid(2, 0, 1, "level", "gauss-gegenbauer", [], 3.0) grid.printStats() grid.makeGlobalGrid(2, 0, 1, "level", "gauss-jacobi", [], 3.0, 3.0) grid.printStats() grid.makeGlobalGrid(2, 1, 1, "level", "custom-tabulated", [], 0.0, 0.0, tdata.sGaussPattersonTableFile) grid.printStats() grid.makeSequenceGrid(2, 1, 3, "level", "rleja") ttc.loadExpN2(grid) grid.printStats() grid.makeLocalPolynomialGrid(1, 1, 3) grid.setDomainTransform(np.array([[2.0, 3.0]])) grid.printStats() grid.makeWaveletGrid(2, 1, 1) grid.printStats() grid.makeFourierGrid(3, 1, 1, "level") grid.enableAcceleration("gpu-cuda") grid.printStats()
def read_previous(iteration): output = [] for shock in range(5): v = TasmanianSG.TasmanianSparseGrid() v.read("valnew_1." + str(iteration) + '.s{}'.format(shock) + ".txt") output.append(v) return output
def checkReadWriteLocalp(self): ''' Test reading and writing of Localp grids. ''' # iDimension, iOutputs, iDepth, iorder, sRule, useTransform, loadFunciton, limitLevels lGrids = [ [3, 2, 2, 0, "localp", False, False, False], [3, 0, 2, 0, "localp-boundary", False, False, False], [2, 1, 4, 1, "semi-localp", False, False, False], [3, 1, 3, 2, "localp", True, False, False], [3, 1, 2, 3, "localp-zero", False, True, False], [3, 1, 2, 3, "localp-zero", False, True, True], [3, 1, 3, 4, "semi-localp", True, True, False], [3, 1, 3, -1, "semi-localp", True, True, False], [3, 1, 3, -1, "semi-localp", True, True, True], ] for lT in lGrids: gridA = TasmanianSG.TasmanianSparseGrid() gridB = TasmanianSG.TasmanianSparseGrid() if (lT[7]): gridA.makeLocalPolynomialGrid(lT[0], lT[1], lT[2], lT[3], lT[4], [3, 1, 2]) else: gridA.makeLocalPolynomialGrid(lT[0], lT[1], lT[2], lT[3], lT[4]) if (lT[5]): gridA.setDomainTransform( np.array([[0.0, 1.0], [0.0, 1.0], [-2.0, -1.0]])) if (lT[6]): ttc.loadExpN2(gridA) gridA.write("testSave", bUseBinaryFormat=False) gridB.read("testSave") ttc.compareGrids(gridA, gridB) gridA.write("testSave", bUseBinaryFormat=True) gridB.makeLocalPolynomialGrid(1, 1, 0) gridB.read("testSave") ttc.compareGrids(gridA, gridB) gridB.makeGlobalGrid(1, 0, 1, "level", "rleja") gridB.makeLocalPolynomialGrid(1, 1, 0) gridB.copyGrid(gridA) ttc.compareGrids(gridA, gridB)
def sparse_grid(n_agents, iDepth): grid = TasmanianSG.TasmanianSparseGrid() k_range = np.array([k_bar, k_up]) ranges = np.empty((n_agents, 2)) for i in range(n_agents): ranges[i] = k_range iDim = n_agents grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp") grid.setDomainTransform(ranges) # Change domain to K low and upper bar aPoints = grid.getPoints() iNumP1 = aPoints.shape[0] aVals = np.empty([iNumP1, 1]) file = open("comparison0.txt", 'w') for iI in range(iNumP1): aVals[iI] = solver.initial(aPoints[iI], n_agents)[ 0] # Solve the value function problem for all grid points v = aVals[iI] * np.ones((1, 1)) to_print = np.hstack((aPoints[iI].reshape(1, n_agents), v)) np.savetxt(file, to_print, fmt='%2.16f') file.close() grid.loadNeededPoints(aVals) # evaluate interpolant at grid points #refinement level for iK in range(refinement_level): grid.setSurplusRefinement(fTol, 1, "fds") #also use fds, or other rules aPoints = grid.getNeededPoints() aVals = np.empty([aPoints.shape[0], 1]) for iI in range(aPoints.shape[0]): aVals[iI] = solver.initial(aPoints[iI], n_agents)[ 0] # Solve the value function problem for all grid points # Update interpolant grid.loadNeededPoints(aVals) #print(" {0:9d} {1:9d} {2:1.2e}".format(iK+1, grid.getNumPoints())) #grid2 = TasmanianSG.TasmanianSparseGrid() #grid2.makeLocalPolynomialGrid(iDim, iOut, refinement_level+iDepth, which_basis, "localp") #a = grid2.getNumPoints() #f=open("grid.txt", 'w') #np.savetxt(f, aPoints, fmt='% 2.16f') #f.close() return grid #======================================================================
def get_iteration_list(iteration): # Gets all the sparse grids from the iteration specified. output = [] for shock in range(5): v = TasmanianSG.TasmanianSparseGrid() v.read("valnew_1." + str(iteration) + '.s{}'.format(shock) + ".txt") output.append(v) return output
def checkReadWriteSequence(self): ''' Test reading and writing of Sequence grids. ''' # iDimension, iOutputs, iDepth, sType, sRule, useTransform, loadFunciton, limitLevels lGrids = [ [3, 2, 2, "level", "leja", False, False, False], [2, 1, 4, "level", "max-lebesgue", False, False, False], [3, 1, 3, "level", "rleja", True, False, False], [3, 1, 3, "level", "rleja", True, False, True], [3, 1, 2, "iptotal", "min-delta", False, True, False], [3, 1, 3, "level", "leja", True, True, False], [3, 1, 3, "level", "leja", True, True, True], ] for lT in lGrids: gridA = TasmanianSG.TasmanianSparseGrid() gridB = TasmanianSG.TasmanianSparseGrid() if (lT[7]): gridA.makeSequenceGrid(lT[0], lT[1], lT[2], lT[3], lT[4], [], [2, 3, 1]) else: gridA.makeSequenceGrid(lT[0], lT[1], lT[2], lT[3], lT[4]) if (lT[5]): gridA.setDomainTransform( np.array([[0.0, 1.0], [0.0, 1.0], [-2.0, -1.0]])) if (lT[6]): ttc.loadExpN2(gridA) gridA.write("testSave", bUseBinaryFormat=False) gridB.read("testSave") ttc.compareGrids(gridA, gridB) gridA.write("testSave", bUseBinaryFormat=True) gridB.makeLocalPolynomialGrid(1, 1, 0) gridB.read("testSave") ttc.compareGrids(gridA, gridB) gridB.makeGlobalGrid(1, 0, 1, "level", "rleja") gridB.makeLocalPolynomialGrid(1, 1, 0) gridB.copyGrid(gridA) ttc.compareGrids(gridA, gridB)
def checkReadWriteCustomTabulated(self): ''' Test reading and writing of the CustomTabulated class. ''' description = "testCT" def create_nodes(j): return np.linspace(-1.0, 1.0, num=j) def create_weights(j): weights = np.linspace(0.0, 1.0, num=j) weights = 2.0 * weights / weights.sum() return weights # Read and write from explicitly given data. for i in range(4): num_levels = i num_nodes = np.array([3*(j+1) for j in range(i)]) precision = np.array([2*(j+1)-1 for j in range(i)]) nodes = [create_nodes(j) for j in num_nodes] weights = [create_weights(j) for j in num_nodes] ctA = TasmanianSG.makeCustomTabulatedFromData(num_levels, num_nodes, precision, nodes, weights, description) # . ctB = TasmanianSG.CustomTabulated() ctA.write("testSave") ctB.read("testSave") for i in range(num_levels): read_weights, read_nodes = ctB.getWeightsNodes(i) np.testing.assert_almost_equal(read_weights, weights[i]) np.testing.assert_almost_equal(read_nodes, nodes[i]) # Read and write from a file. ctA = TasmanianSG.makeCustomTabulatedFromFile(tdata.sGaussPattersonTableFile) ctB = TasmanianSG.CustomTabulated() ctA.write("testSave") ctB.read("testSave") ttc.compareCustomTabulated(ctA, ctB) for i in range(ctB.getNumLevels()): read_weights, read_nodes = ctB.getWeightsNodes(i) grid = TasmanianSG.makeGlobalGrid(1, 0, i, "level", "gauss-patterson") np.testing.assert_almost_equal(read_weights, grid.getQuadratureWeights()) np.testing.assert_almost_equal(read_nodes, grid.getPoints().flatten()) # Test an error message from wrong read. try: ctB.read("Test_If_Bogus_Filename_Produces_an_Error") except TasmanianSG.TasmanianInputError as TSGError: TSGError.bShowOnExit = False self.assertEqual(TSGError.sVariable, "sFilename", "Reading a bogus file properly failed, but the error information is wrong.")
def checkReadWriteFourier(self): ''' Test reading and writing of Fourier grids. ''' # iDimension, iOutputs, iDepth, useTransform, loadFunction, useLevelLimits lGrids = [ [3, 2, 2, False, False, False], [2, 1, 4, False, False, False], [3, 1, 1, True, False, False], [3, 1, 1, True, False, True], [3, 1, 2, False, True, False], [3, 1, 2, True, True, True], [3, 1, 2, True, True, False], ] for lT in lGrids: gridA = TasmanianSG.TasmanianSparseGrid() gridB = TasmanianSG.TasmanianSparseGrid() if (lT[5]): gridA.makeFourierGrid(lT[0], lT[1], lT[2], 'level', [1, 1, 2]) else: gridA.makeFourierGrid(lT[0], lT[1], lT[2], 'level') if (lT[3]): gridA.setDomainTransform( np.array([[0.0, 1.0], [0.0, 1.0], [-2.0, -1.0]])) if (lT[4]): ttc.loadExpN2(gridA) gridA.write("testSave", bUseBinaryFormat=False) gridB.read("testSave") ttc.compareGrids(gridA, gridB) gridA.write("testSave", bUseBinaryFormat=True) gridB.makeLocalPolynomialGrid(1, 1, 0) gridB.read("testSave") ttc.compareGrids(gridA, gridB) gridB.makeGlobalGrid(1, 0, 1, "level", "rleja") gridB.makeLocalPolynomialGrid(1, 1, 0) gridB.copyGrid(gridA) ttc.compareGrids(gridA, gridB)
def sparse_grid(n_agents, iDepth, adaptive=False): grid = TasmanianSG.TasmanianSparseGrid() # range of k grid k_range=np.array([k_bar, k_up]) ranges=np.empty((n_agents, 2)) # lower and upper bound for each agent (dimension) for i in range(n_agents): ranges[i]=k_range iDim=n_agents grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp") grid.setDomainTransform(ranges) ### Sets the lower and upper bound for each dimension aPoints=grid.getPoints() ### returns the points needed to form the interpolant or the next ### level of refinement following a set***Refinement() call iNumP1=aPoints.shape[0] aVals=np.empty([iNumP1, 1]) # space to store value for value function at that interpolation evaluated point if adaptive: file=open("comparison0.txt", 'w') for i in range(refinement_level): grid.setSurplusRefinement(fTol, -1, "fds") #also use fds, or other rules aPoints = grid.getNeededPoints() aVals = np.empty([aPoints.shape[0], 1]) for iI in range(iNumP1): aVals[iI] = solver.initial(aPoints[iI], n_agents)[0] v=aVals[iI]*np.ones((1,1)) to_print=np.hstack((aPoints[iI].reshape(1,n_agents), v)) np.savetxt(file, to_print, fmt='%2.16f') else: file=open("comparison0.txt", 'w') for iI in range(iNumP1): aVals[iI]=solver.initial(aPoints[iI], n_agents)[0] v=aVals[iI]*np.ones((1,1)) to_print=np.hstack((aPoints[iI].reshape(1,n_agents), v)) np.savetxt(file, to_print, fmt='%2.16f') file.close() grid.loadNeededPoints(aVals) f=open("grid.txt", 'w') np.savetxt(f, aPoints, fmt='% 2.16f') f.close() return grid
def sparse_grid(n_agents, iDepth, refinement_level, fTol, theta): grid = TasmanianSG.TasmanianSparseGrid() k_range=np.array([k_bar, k_up]) ranges=np.empty((n_agents, 2)) for i in range(n_agents): ranges[i]=k_range iDim=n_agents # level of grid before refinement grid.makeLocalPolynomialGrid(iDim, iOut, iDepth, which_basis, "localp") grid.setDomainTransform(ranges) aPoints=grid.getPoints() iNumP1=aPoints.shape[0] aVals=np.empty([iNumP1, 1]) file=open("comparison0.txt", 'w') for iI in range(iNumP1): aVals[iI]=solver.initial(aPoints[iI], n_agents, theta)[0] v=aVals[iI]*np.ones((1,1)) to_print=np.hstack((aPoints[iI].reshape(1,n_agents), v)) np.savetxt(file, to_print, fmt='%2.16f') #file.close() grid.loadNeededPoints(aVals) #refinement level for iK in range(refinement_level): grid.setSurplusRefinement(fTol, 1, "fds") #also use fds, or other rules aPoints = grid.getNeededPoints() aVals = np.empty([aPoints.shape[0], 1]) for iI in range(aPoints.shape[0]): aVals[iI]=solver.initial(aPoints[iI], n_agents, theta)[0] v = aVals[iI]*np.ones((1, 1)) to_print=np.hstack((aPoints[iI].reshape(1,n_agents), v)) np.savetxt(file, to_print, fmt='%2.16f') grid.loadNeededPoints(aVals) #aRes = grid.evaluateBatch(aPnts) #fError1 = max(np.fabs(aRes[:,0] - aTres)) file.close() f=open("grid.txt", 'w') np.savetxt(f, aPoints, fmt='% 2.16f') f.close() return grid
def checkSetClear(self): ''' Set refinement and clear refinement ''' grid = TasmanianSG.TasmanianSparseGrid() grid.makeLocalPolynomialGrid(2, 1, 2, 1, 'semi-localp') ttc.loadExpN2(grid) self.assertEqual(grid.getNumNeeded(), 0, "num needed") grid.setSurplusRefinement(0.0001, 0, 'classic') self.assertTrue((grid.getNumNeeded() > 0), "num needed") grid.clearRefinement() self.assertEqual(grid.getNumNeeded(), 0, "num needed")
def run_all(n_agents): valnew=TasmanianSG.TasmanianSparseGrid() if (numstart==0): valnew=interpol.sparse_grid(n_agents, iDepth) valnew.write("valnew_1." + str(numstart) + ".txt") #write file to disk for restart # value function during iteration else: valnew.read("valnew_1." + str(numstart) + ".txt") #write file to disk for restart valold=TasmanianSG.TasmanianSparseGrid() valold=valnew for i in range(numstart, numits): valnew=TasmanianSG.TasmanianSparseGrid() valnew=interpol_iter.sparse_grid_iter(n_agents, iDepth, valold) valold=TasmanianSG.TasmanianSparseGrid() valold=valnew valnew.write("valnew_1." + str(i+1) + ".txt") #====================================================================== print "===============================================================" print " " print " Computation of a growth model of dimension ", n_agents ," finished after ", numits, " steps" print " " print "===============================================================" #====================================================================== # compute errors avg_err, max_err =post.ls_error(n_agents, numstart, numits, No_samples) #====================================================================== print "===============================================================" print " " print " Errors are computed -- see errors.txt" print " " print "===============================================================" #====================================================================== return avg_err, max_err
def checkLocalpSurplus(self): ''' Check surplus refinement for local polynomial grids ''' grid = TasmanianSG.TasmanianSparseGrid() grid.makeLocalPolynomialGrid(2, 1, 4, 1, 'semi-localp') ttc.loadExpN2(grid) aPoints = grid.getPoints() aScale = np.array([[1.0 if aPoints[i,0] > 0.0 else 0.0] for i in range(aPoints.shape[0])]) grid.setSurplusRefinement(1.E-9, 0, 'classic', [], aScale) aNeeded = grid.getNeededPoints() for iI in range(aNeeded.shape[0]): self.assertLess(0.0, aNeeded[iI, 0], 'wrong set of needed points after rescaling')
def ls_error(paramL): k_bar = paramL['k_bar'] k_up = paramL['k_up'] n_agents = paramL['n_agents'] t1 = paramL['numstart'] t2 = paramL['numits'] num_points = paramL['No_samples'] for state in range(5): file=open('errors.'+'s{}'.format(state)+'.txt', 'w') np.random.seed(0) unif=np.random.rand(num_points, n_agents) k_sample=k_bar+(unif)*(k_up-k_bar) to_print=np.empty((1,3)) for i in range(t1, t2): sum_diffs=0 diff = 0 v_prev=TasmanianSG.TasmanianSparseGrid() v_next=TasmanianSG.TasmanianSparseGrid() v_prev.read("valnew_1." + str(i) +'.s{}'.format(state)+ ".txt") v_next.read("valnew_1." + str(i+1) +'.s{}'.format(state)+ ".txt") #print(v_next.evaluateBatch(v_next.getGrid())) diff=v_next.evaluateBatch(k_sample) - v_prev.evaluateBatch(k_sample) max_abs_diff=np.amax(np.fabs(diff)) average = np.average(np.fabs(diff)) to_print[0,0]=i+1 to_print[0,1]=max_abs_diff to_print[0,2]= average np.savetxt(file, to_print, fmt='%2.16f') file.close()