From 7b3f3f8a234ca79b87df67430af7c3b3fc8e83be Mon Sep 17 00:00:00 2001 From: Maria Marchwicka Date: Mon, 11 Mar 2019 03:43:51 +0100 Subject: [PATCH] script from Wojtek and my first version --- my_signature.sage | 136 ++++++++++++++++++++++++++++++++++++++++++++++ signature.sage | 125 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 261 insertions(+) create mode 100644 my_signature.sage create mode 100644 signature.sage diff --git a/my_signature.sage b/my_signature.sage new file mode 100644 index 0000000..0e341f6 --- /dev/null +++ b/my_signature.sage @@ -0,0 +1,136 @@ +#!/usr/bin/env python +import collections + + +def mod_one(n): + """This function returns the fractional part of some number.""" + if n >= 1: + return mod_one(n - 1) + if n < 0: + return mod_one(n + 1) + return n + + +class av_signature_function(object): + ''' + This simple class encodes twisted and untwisted signature functions + of knots. Since the signature function is entirely encoded by its signature + jump, the class stores only information about signature jumps + in a dictionary self.data. + The dictionary stores data of the signature jump as a key/values pair, + where the key is the argument at which the functions jumps + and value encodes the value of the jump. Remember that we treat + signature functions as defined on the interval [0,1). + ''' + def __init__(self, values=[]): + # We will store data of signature jumps here. + self.data = collections.defaultdict(int) + # values contain initial data of singature jumps + for jump_arg, jump in values: + assert 0 <= jump_arg < 1, \ + "Signature function is defined on the interval [0, 1)." +################################### what for += ??? + self.data[jump_arg] = jump + + def value(self, arg): + # Compute the value of the signature function at the point arg. + # This requires summing all signature jumps that occur before arg. + assert 0 <= arg < 1, \ + "Signature function is defined on the interval [0, 1)." + val = 0 + for jump_arg, jump in self.data.items(): + if jump_arg < arg: + val += 2 * jump + elif jump_arg == arg: + val += jump + return val + +############## what for - it is == 0 + def total_sign_jump(self): + # Total signature jump is the sum of all jumps. + a = sum([j[1] for j in self.to_list()]) + b = sum(self.data.values()) + # print b + assert a == b + return sum(self.data.values()) + + def to_list(self): + # Return signature jumps formated as a list + return sorted(self.data.items(), key=lambda x: x[0]) + + def step_function_data(self): + # Transform the signature jump data to a format understandable + # by the plot function. + l = self.to_list() + vals = ([(d[0], sum(2 * j[1] for j in l[:l.index(d)+1])) for d in l] + + [(0, self.data[0]), (1, self.total_sign_jump())]) + return vals + + def plot(self): + # plot the signture function + plot_step_function(self.step_function_data()) + + def tikz_plot(self, file_name): + # Draw the graph of the signature and transform it into TiKz. + # header of the LaTeX file + output_file = open(file_name, "w") + output_file.write("\\documentclass[tikz]{standalone}\n") + output_file.write("\\usetikzlibrary{datavisualization,datavisualization.formats.functions}\n") + output_file.write("\\begin{document}\n") + output_file.write("\\begin{tikzpicture}\n") + data = sorted(self.step_function_data()) + output_file.write(" \\datavisualization[scientific axes,visualize as smooth line,\n") + output_file.write(" x axis={ticks={none,major={at={") + output_file.write(", " + str(N(data[0][0], digits=4)) + " as \\(" + str(data[0][0]) + "\\)") + for jump_arg, jump in data[1:]: + output_file.write(", " + str(N(jump_arg, digits=4)) + " as \\(" + str(jump_arg) + "\\)") + output_file.write("}}}}\n") + output_file.write(" ]\n") + output_file.write("data [format=function]{\n") + output_file.write("var x : interval [0:1];\n") + output_file.write("func y = \\value x;\n") + output_file.write("};\n") + # close LaTeX enviroments + output_file.write("\\end{tikzpicture}\n") + output_file.write("\\end{document}\n") + output_file.close() + + def __lshift__(self, shift): + # Shift of the signature functions correspond to the rotations. + return self.__rshift__(-shift) + + def __rshift__(self, shift): + new_data = [] + for jump_arg, jump in self.data.items(): + new_data.append((mod_one(jump_arg + shift), jump)) + return av_signature_function(new_data) + + def __sub__(self, other): + # we cn perform arithmetic operations on signature functions. + return self + other.__neg__() + + def __neg__(self): + for jump_arg in self.data.keys(): + self.data[jump_arg] *= -1 + return self + + def __add__(self, other): + for jump_arg, jump in other.data.items(): + self.data[jump_arg] += jump + return self + + def __str__(self): + return '\n'.join([str(jump_arg) + ": " + str(jump) + for jump_arg, jump in self.data.items()]) + + def __repr__(self): + return self.__str__() + + +def untw_signature(k): + # Return the signature function of the T_{2,2k+1} torus knot. + l = ([((2 * a + 1)/(4 * k + 2), -1) for a in range(k)] + + [((2 * a + 1)/(4 * k + 2), 1) for a in range(k + 1, 2 * k + 1)]) + # print l + # print type(l) + return av_signature_function(l) diff --git a/signature.sage b/signature.sage new file mode 100644 index 0000000..f53dcd6 --- /dev/null +++ b/signature.sage @@ -0,0 +1,125 @@ +#!/usr/bin/env python +import collections + +def mod_one(n): + """This function returns the fractional part of some number.""" + if n >= 1: + return mod_one(n - 1) + if n < 0: + return mod_one(n + 1) + else: + return n + + +class av_signature_function(object): + ''' + This simple class encodes twisted and untwisted signature functions + of knots. Since the signature function is entirely encoded by its signature + jump, the class stores only information about signature jumps + in a dictionary self.data. + The dictionary stores data of the signature jump as a key/values pair, + where the key is the argument at which the functions jumps + and value encodes the value of the jump. + Remember that we treat signature functions as defined on the interval [0,1). + ''' + def __init__(self,values=[]): + # We will store data of signature jumps here. + self.data = collections.defaultdict(int) + # values contain initial data of singature jumps + for jump_arg, jump in values: + assert 0 <= jump_arg and jump_arg < 1 + self.data[jump_arg] += jump + + def value(self, arg): + # Compute the value of the signature function at the point arg. + # This requires summing all signature jumps that occur before arg. + assert 0 <= arg and arg < 1 + val = 0 + for jump_arg, jump in self.data.items(): + if jump_arg < arg: + val += 2 * jump + elif jump_arg == arg: + val += jump + return val + + def total_sign_jump(self): + # Total signature jump is the sum of all jumps. + return sum([j[1] for j in self.to_list()]) + + def to_list(self): + # Return signature jumps formated as a list + return sorted(self.data.items(), key = lambda x: x[0]) + + def step_function_data(self): + # Transform the signature jump data to a format understandable + # by the plot function. + l = self.to_list() + vals = ([(d[0], sum(2 * j[1] for j in l[:l.index(d)+1])) for d in l] + + [(0,self.data[0]), (1,self.total_sign_jump())]) + return vals + + def plot(self): + # plot the signture function + plot_step_function(self.step_function_data()) + + def tikz_plot(self, file_name): + # Draw the graph of the signature and transform it into TiKz. + # header of the LaTeX file + output_file = open(file_name, "w") + output_file.write("\\documentclass[tikz]{standalone}\n") + output_file.write("\\usetikzlibrary{datavisualization,datavisualization.formats.functions}\n") + output_file.write("\\begin{document}\n") + output_file.write("\\begin{tikzpicture}\n") + data = sorted(self.step_function_data()) + output_file.write(" \\datavisualization[scientific axes,visualize as smooth line,\n") + output_file.write(" x axis={ticks={none,major={at={") + output_file.write(", " + str(N(data[0][0],digits=4)) + " as \\(" + str(data[0][0]) + "\\)") + for jump_arg,jump in data[1:]: + output_file.write(", " + str(N(jump_arg,digits=4)) + " as \\(" + str(jump_arg) + "\\)") + output_file.write("}}}}\n") + output_file.write(" ]\n") + output_file.write("data [format=function]{\n") + output_file.write("var x : interval [0:1];\n") + output_file.write("func y = \\value x;\n") + output_file.write("};\n") + # close LaTeX enviroments + output_file.write("\\end{tikzpicture}\n") + output_file.write("\\end{document}\n") + output_file.close() + + def __lshift__(self, shift): + # Shift of the signture functions correspond to the rotations. + return self.__rshift__(-shift) + + def __rshift__(self, shift): + new_data = list() + for jump_arg, jump in self.data.items(): + new_data.append((mod_one(jump_arg + shift),jump)) + return av_signature_function(new_data) + + def __sub__(self, other): + # we cn perform arithmetic operations on signature functions. + return self + other.__neg__() + + def __neg__(self): + for jump_arg in self.data.keys(): + self.data[jump_arg] *= (-1) + return self + + def __add__(self, other): + for jump_arg, jump in other.data.items(): + self.data[jump_arg] += jump + return self + + def __str__(self): + return '\n'.join([str(jump_arg) + ": " + str(jump) + for jump_arg, jump in self.data.items()]) + + def __repr__(self): + print self.__str__() + +def untw_signature(k): + # Return the signture function of the T_{2,2k+1} torus knot. + l = ([((2 * a + 1)/(4 * k + 2), -1) for a in range(k)] + + [((2 * a + 1)/(4 * k + 2), 1) for a in range(k + 1, 2 * k + 1)]) + return av_signature_function(l)