示例#1
0
    def adaptive_init(self, f, d, a, b):
        self.f = f
        self.d = d
        self.a = a
        self.b = b
        self.q = self.d   # minimal nesting level
        self.init_ni = 3#11  # smallest degree along an axis
        ni = self.init_ni
        self.exps = [None]
        self.cheb_weights_cache = [None]
        self.xroot_cache = [list([None]) for j in range(self.d)] # cache for X coords of roots
        for i in range(self.q - self.d + 1 + 1):  # maximum degree is q - d + 1 by definition of Q
            self.exps.append(ni)
            self.cheb_weights_cache.append(cheb_weights(ni))
            for j in range(self.d):
                self.xroot_cache[j].append(cheb_nodes(ni, self.a[j], self.b[j]))
            if ni == 1:
                ni = 3
            else:
                ni = ni * 2 - 1
        self.ni = ni

        self.nodes, self.subgrid_map = self.get_nodes(self.q)
        Xs = [array([self.xroot_cache[j][self.q - self.d + 1][n[j]] for n in self.nodes]) for j in range(self.d)]
        self.Ys = atleast_1d(squeeze(self.f(*Xs)))
示例#2
0
    def adaptive_init(self, f, d, a, b):
        self.f = f
        self.d = d
        self.a = a
        self.b = b
        self.q = self.d  # minimal nesting level
        self.init_ni = 11  # smallest degree along an axis
        ni = self.init_ni
        self.exps = [None]
        self.cheb_weights_cache = [None]
        self.xroot_cache = [list([None]) for j in range(self.d)
                            ]  # cache for X coords of roots
        for i in range(self.q - self.d + 1 +
                       1):  # maximum degree is q - d + 1 by definition of Q
            self.exps.append(ni)
            self.cheb_weights_cache.append(cheb_weights(ni))
            for j in range(self.d):
                self.xroot_cache[j].append(cheb_nodes(ni, self.a[j],
                                                      self.b[j]))
            if ni == 1:
                ni = 3
            else:
                ni = ni * 2 - 1
        self.ni = ni

        self.nodes, self.subgrid_map = self.get_nodes(self.q)
        Xs = [
            array([
                self.xroot_cache[j][self.q - self.d + 1][n[j]]
                for n in self.nodes
            ]) for j in range(self.d)
        ]
        self.Ys = atleast_1d(squeeze(self.f(*Xs)))
示例#3
0
    def adaptive_interp(self, par=None):
        if par is None:
            par = params.interpolation_nd
        maxq = par.maxq
        q = self.q
        max_q = q - self.d + 1
        ni = self.ni
        old_err = None
        cm = convergence_monitor(par=par.convergence)

        while q <= maxq:
            self.exps.append(ni)
            self.cheb_weights_cache.append(cheb_weights(ni))
            for j in range(self.d):
                self.xroot_cache[j].append(cheb_nodes(ni, self.a[j],
                                                      self.b[j]))
            if ni == 1:
                ni = 3
            else:
                ni = ni * 2 - 1
                q = q + 1
            new_nodes, new_subgrid_map = self.get_nodes(q)
            # compute incremental nodes
            old_nodes = [tuple(2 * i for i in n) for n in self.nodes]
            inc_nodes = list(set(new_nodes) - set(old_nodes))
            inc_nodes.sort()
            max_q = q - self.d + 1
            inc_Xs = [
                array([self.xroot_cache[j][max_q][n[j]] for n in inc_nodes])
                for j in range(self.d)
            ]
            inc_Ys = atleast_1d(squeeze(self.f(*inc_Xs)))
            err = self.test_accuracy(inc_Xs, inc_Ys)
            maxy = max(abs(inc_Ys).max(), abs(self.Ys).max())
            if par.debug_info:
                print("interp. err", err, old_err, q)
            cm.add(err, maxy)
            if cm.test_convergence()[0]:
                break
            old_err = err
            # error too large, update the interpolator
            self.q = q
            self.ni = ni
            # now update nodes. TODO: cleanup!
            nodemap = dict((n, i) for i, n in enumerate(old_nodes))
            inc_nodemap = dict((n, i) for i, n in enumerate(inc_nodes))
            new_Xs = []
            new_Ys = []
            max_q = q - self.d + 1  # max degree
            for n in new_nodes:
                if n in nodemap:
                    Y = self.Ys[nodemap[n]]
                if n in inc_nodes:
                    Y = inc_Ys[inc_nodemap[n]]
                new_Ys.append(Y)
            self.nodes = new_nodes
            self.subgrid_map = new_subgrid_map
            self.Ys = array(new_Ys)
示例#4
0
    def adaptive_interp(self, par = None):
        if par is None:
            par = params.interpolation_nd
        maxq = par.maxq
        q = self.q
        max_q = q-self.d+1
        ni = self.ni
        old_err = None
        cm = convergence_monitor(par = par.convergence)

        while q <= maxq:
            self.exps.append(ni)
            self.cheb_weights_cache.append(cheb_weights(ni))
            for j in range(self.d):
                self.xroot_cache[j].append(cheb_nodes(ni, self.a[j], self.b[j]))
            if ni == 1:
                ni = 3
            else:
                ni = ni * 2 - 1
                q = q + 1
            new_nodes, new_subgrid_map = self.get_nodes(q)
            # compute incremental nodes
            old_nodes = [tuple(2*i for i in n) for n in self.nodes]
            inc_nodes = list(set(new_nodes) - set(old_nodes))
            inc_nodes.sort()
            max_q = q-self.d+1
            inc_Xs = [array([self.xroot_cache[j][max_q][n[j]] for n in inc_nodes]) for j in range(self.d)]
            inc_Ys = atleast_1d(squeeze(self.f(*inc_Xs)))
            err = self.test_accuracy(inc_Xs, inc_Ys)
            maxy = max(abs(inc_Ys).max(), abs(self.Ys).max())
            if par.debug_info:
                print("interp. err", err, old_err, q)
            cm.add(err, maxy)
            if cm.test_convergence()[0]:
                break
            old_err = err
            # error too large, update the interpolator
            self.q = q
            self.ni = ni
            # now update nodes. TODO: cleanup!
            nodemap = dict((n, i) for i, n in enumerate(old_nodes))
            inc_nodemap = dict((n, i) for i, n in enumerate(inc_nodes))
            new_Xs = []
            new_Ys = []
            max_q = q - self.d + 1 # max degree
            for n in new_nodes:
                if n in nodemap:
                    Y = self.Ys[nodemap[n]]
                if n in inc_nodes:
                    Y = inc_Ys[inc_nodemap[n]]
                new_Ys.append(Y)
            self.nodes = new_nodes
            self.subgrid_map = new_subgrid_map
            self.Ys = array(new_Ys)