def __getattribute__(self, name): instance = LazyApproximation.__getattribute__(self, "_instance") attr = instance.__getattribute__(name) try: vars = inspect.getargspec(attr)[0] vars.index("wrapper") except (TypeError, ValueError): return attr ref = Approximation.__getattribute__(self, "_ref") def modified_attr(*args, **kwargs): kwargs["wrapper"] = ref return attr(*args, **kwargs) return modified_attr
def __init__(self, parent, x, max_workprec=None, **kwargs): Approximation.__init__(self, parent) self._length = -1 self._current_workprec = None self._current_approximation = None self._dict_max_workprec = {} if isinstance(x, Approximation) and x.parent() is parent: if isinstance(x, LazyApproximation): raise TypeError("can't lazy something already lazy") self._current_workprec = Infinity self._current_approximation = x self.repr = lambda: "%s" % x self._length = length = x._length base = parent.base_ring() if length >= 0: zero = base._lazy_zero lazy_class = base._lazy_class @cached_function def getitem_by_num(i): if i < length: return lazy_class(base, x._getitem_by_num(i)).new_wrapper() else: return zero self._getitem_by_num = getitem_by_num elif isinstance(x, list): self.name = "element_from_list" if parent.dimension() < Infinity: zeros = [parent.base_ring()._zero] * (parent.dimension() - len(x)) self.function = lambda workprec: parent([item.at_workprec(workprec) for item in x] + zeros) else: self.function = lambda workprec: parent([item.at_workprec(workprec) for item in x]) x_wrapper = [c.new_wrapper() for c in x] self._length = length = len(x) zero = parent.base_ring()._lazy_zero def getitem_by_num(i): if i < length: return x_wrapper[i] else: return zero self._getitem_by_num = getitem_by_num self.args = self._dependances = x_wrapper if len(x) == 0: if max_workprec is None: max_workprec = 0 else: if max_workprec is None: max_workprec = max([item.max_workprec() for item in x]) elif isinstance(x, dict): raise NotImplementedError elif isinstance(x, FunctionType): self.function = x import re self.name = re.sub("^(lazy)?_*", "", x.__name__) self.name = re.sub("_*$", "", self.name) else: raise TypeError("x must be an approximation, a list, a dictionary or a function") if max_workprec is None: self._max_workprec = Infinity else: self._max_workprec = max_workprec if kwargs.has_key("parenthesis_level"): self._parenthesis_level = kwargs["parenthesis_level"] del kwargs["parenthesis_level"] else: self._parenthesis_level = 3 try: if self.name == "add" or self.name == "sub" or self.name == "neg": self._parenthesis_level = 0 elif self.name == "mul" or self.name == "div" or self.name == "invert": self._parenthesis_level = 1 elif self.name == "pow": self._parenthesis_level = 2 except AttributeError: pass for key in kwargs: if key[:1] != "_": self.__dict__[key] = kwargs[key]
Approximation.verbose_learn = False Approximation.verbose_probe = False #input_range = np.array([-3.5, 3.5]) #output_range = np.array([0.0, fn_square(input_range[0])]) input_range = np.array([(-1.0, 1.0), (-1.0, 1.0)]) output_range = np.array([-2.0, 2.0]) print("input_range: {} output_range: {}".format(input_range, output_range)) #HRR.incremental_weight = 0.5 #appr = Approximation(fn=fn_2dparab, size=3000) #appr.learn(input_range=input_range, output_range=output_range, n_samples=200, stddev=0.02, use_incremental=False) #appr.plot_result(input_range=input_range, output_range=output_range, n_samples=19) appr = Approximation(fn=fn_plane, size=10000) appr.learn(input_range=input_range, output_range=output_range, n_samples=(10, 10), stddev=0.01, use_incremental=False) n_samples = (10, 10) if True: input_tuples = [] X = np.linspace(-1.0, 1.0, n_samples[0]) Y = np.linspace(-1.0, 1.0, n_samples[1]) for x in X: for y in Y: input_tuples.append((x, y))
HRR.verbose = False armlengths = [1.0, 1.0] def fn(x, y): tcp = TCP([x, y], arms=2, armlengths=armlengths) tcp.computeTcp() return tcp.tcp # should be list of length 3 input_range = [(0.0, 360.0), (0.0, 360.0)] sr = np.sum(armlengths) output_range = [(-sr, sr), (-sr, sr)] appr = Approximation(fn=fn, size=3000) appr.learn(input_range=input_range, output_range=output_range, n_samples=(20, 20), stddev=0.02, use_incremental=False) input_tuples = [] S = np.linspace(0.0, 360.0, 10) for joint1 in S: for joint2 in S: input_tuples.append((joint1, joint2)) appr.verify(input_tuples=input_tuples, input_range=input_range, output_range=output_range)
def __init__(self): self.approximation = Approximation()
name = "Y=X²-6" if __name__ == '__main__': ys = [] num = 0 for x in range(-10, 11): if random.randint(1, 100) < 60: temp = [x] xs.append([]) xs[num] = (temp) ys += [x * x - 6] num += 1 for degree in range(2, 13): approximation = Approximation.fit(xs, ys, degree) graph = Graph(xs, ys, approximation, degree, name) graph.draw() data = { "data": { "coef": approximation.coef, "names": approximation.names, "json": approximation.json, "latex": approximation.latex, } } with open('data.json', 'w') as outfile: json.dump(data, outfile)