def __init__(self, F: fn.Function, G: fn.Function): assert F.get_vars() - {'x', 'y', 'z'} == set() assert G.get_vars() - {'x', 'y', 'z'} == set() self._F = F self._G = G self._vars = self._F.get_vars() self.x = fn.Var('x') self.y = fn.Var('y') self.z = fn.Var('z')
def osculating_plane(self): """ (R - r(t0), r'(t0), r''(t0)) = 0 R = (X, Y, Z) """ r = self.vector X = fn.Var('X') Y = fn.Var('Y') Z = fn.Var('Z') dr1 = r.derivative() dr2 = dr1.derivative() tmp = dr1.cross(dr2)
def __init__(self, x: fn.Function, y: fn.Function, z: fn.Function, t_1: float, t_2: float, str_repr=''): assert x.get_vars() - { 't', } == set() assert y.get_vars() - { 't', } == set() assert z.get_vars() - { 't', } == set() self._t = fn.Var('t') self._t.right = min(self._t.right, t_2) self._t.left = max(self._t.left, t_1) self.x = x self.y = y self.z = z self._str_repr = str_repr or f'{x}, {y}, {z}' self.left = self._t.left self.right = self._t.right
def _precompute_implicit(self, p0, eps=10e-6): x0, y0, z0 = p0 self._vals = {self.x: x0, self.y: y0, self.z: z0} for var in self._vars: if abs(self._get_jacobi(var)(x=x0, y=y0, z=z0)) > eps: break else: raise ImplicitFuncTheoremError(p0) self._z = var self._x, self._y = self._vars - { self._z, } # type: fn.Var self._x_found = {self._vals[self._z]: self._vals[self._x]} self._y_found = {self._vals[self._z]: self._vals[self._y]} self._t = fn.Var('t') self._t0 = self._vals[self._z] self._t.set_value(self._t0) def _x_func(t): if t in self._x_found: return self._x_found[t] else: raise NotFoundError() def _y_func(t): if t in self._y_found: return self._y_found[t] else: raise NotFoundError() self._x_func = fn.from_func_factory(_x_func, {self._t}) self._y_func = fn.from_func_factory(_y_func, {self._t}) self._z_func = fn.from_var_factory(self._t) self._kwargs1 = { self._x.name: fn.from_const_factory(self._vals[self._x]), self._y.name: fn.from_const_factory(self._vals[self._y]), self._z.name: fn.from_const_factory(self._vals[self._z]) } self._kwargs2 = { self._x.name: self._x_func, self._y.name: self._y_func, self._z.name: self._z_func } self._dFdx = self._F.partial_derivative(self._x) self._dFdy = self._F.partial_derivative(self._y) self._dFdz = self._F.partial_derivative(self._z) self._dGdx = self._G.partial_derivative(self._x) self._dGdy = self._G.partial_derivative(self._y) self._dGdz = self._G.partial_derivative(self._z) a11, a12 = self._dFdx.substitute(**self._kwargs1)(), \ self._dFdy.substitute(**self._kwargs1)() a21, a22 = self._dGdx.substitute(**self._kwargs1)(), \ self._dGdy.substitute(**self._kwargs1)() self._A = np.array([[a11, a12], [a21, a22]])
def __init__(self, x: fn.Function, y: fn.Function, z: fn.Function, u1=None, u2=None, v1=None, v2=None): assert x.get_vars() == {'u', 'v'} assert y.get_vars() == {'u', 'v'} assert z.get_vars() == {'u', 'v'} self.x = x self.y = y self.z = z self._u = fn.Var('u') self._v = fn.Var('v') self._u.right = min(self._u.right, u2) self._u.left = max(self._u.left, u1) self._v.right = min(self._v.right, v2) self._v.left = max(self._v.left, v1)
def _add_found(dvdz: float, _v_found: dict, v0: float): dvdz = dvdz * fn.Function.delta_x * 2 v1 = dvdz v2 = 0 _v_found[v0 + fn.Function.delta_x] = v1 _v_found[v0 - fn.Function.delta_x] = v2 @staticmethod def _add_found2(d2vdz2: float, _v_found: dict, v0: float): delta_x = fn.Function.delta_x _v_found[v0 + 2 * delta_x] = _v_found[v0 - 2 * delta_x] \ = 2 * delta_x ** 2 * d2vdz2 + _v_found[v0] if __name__ == "__main__": x_func = fn.from_var_factory(fn.Var('x')) y_func = fn.from_var_factory(fn.Var('y')) z_func = fn.from_var_factory(fn.Var('z')) test_F = x_func + fn.sinh(x_func) - fn.sin(y_func) - y_func + z_func * 0 test_G = z_func + fn.exp(z_func) - x_func - fn.log(1 + x_func) - 1 + y_func * 0 p = (0, 0, 0) test = ImplicitCurve3D(test_F, test_G) res = test.implicit_theorem(p) curve = ParamCurve3D(res) print(res(1))
def plot(self, dots=1000, start=-100, end=100): self.reset_axes() start = max(start, self.vector.left) end = min(end, self.vector.right) t = np.linspace(start, end, dots) x, y, z = self(t) self.ax.plot(x, y, z, c='r') def frenet(self, t0): tau = self.tangent_unit()(t=t0) beta = self.binormal_unit()(t=t0) nu = self.normal_unit()(t=t0) point = self(t=t0) x0, y0, z0 = point X = [x0, x0, x0] Y = [y0, y0, y0] Z = [z0, z0, z0] return self.ax.quiver(X, Y, Z, tau, beta, nu) if __name__ == '__main__': t = fn.Var('t') r = VectorFunc(1 + fn.cos(t), fn.sin(t), 2 * fn.sin(fn.from_var_factory(t) / 2), 0, 4 * np.pi) curve = ParamCurve3D(r) curve.plot() curve.frenet(2) plt.show()