Initial Commit

README.md

@@ -11,3 +11,5 @@ license: apache-2.0
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+Just a space to visualise single variable calculus things

app.py

@@ -0,0 +1,117 @@
+import gradio as gr
+from src.main import get_fn, get_dev, get_tangent_line
+from src.piecewise import get_piecewise_fn, get_piecewise_dev
+from src.product_rule import get_pr_fn, get_pr_dev
+
+# to run app: python -m gr_app or gradio gr_app.py
+
+fn_fig, dev_fig = None, None
+tl_plot = None
+
+with gr.Blocks() as scatterplot:
+    with gr.Column():
+        with gr.Row():
+            inp = gr.Textbox(value = "x**2", 
+                            info = "eg 'np.sqrt(x)'", 
+                            label = "Enter Your Expression here")
+            inp_2 = gr.Textbox(value = "2", 
+                       info = "e.g. 2", 
+                       label = "Which point on x do you want to draw the tangent line?")
+        btn = gr.Button("Run!")
+
+    with gr.Row():
+        fn_scatter = gr.Plot(fn_fig)
+        dev_scatter = gr.Plot(dev_fig)
+
+    tl_scatter = gr.Plot(tl_plot)
+
+    gr.on(triggers = [inp.submit, btn.click], 
+          fn=get_fn, 
+          inputs = inp, 
+          outputs = fn_scatter)
+    gr.on(triggers = [inp.submit, btn.click], 
+          fn=get_dev, 
+          inputs = inp, 
+          outputs = dev_scatter)
+    gr.on(triggers = [inp.submit, inp_2.submit, btn.click], 
+          fn=get_tangent_line, 
+          inputs = [inp, inp_2], 
+          outputs=tl_scatter)
+    
+# dev_obj = None
+piecewise_fn_fig, piecewise_dev_fig = None, None
+    
+with gr.Blocks() as piecewise: 
+    with gr.Column():
+        with gr.Row():
+            with gr.Column():
+                inp_func_1 = gr.Textbox(value = "x**2", 
+                                info = "eg 'np.sqrt(x)'", 
+                                label = "Enter Your Expression here")
+                
+                inp_sign_1 = gr.Textbox(value = "<", 
+                                info = "eg <", 
+                                label = "Enter Your Sign Here")
+                
+            with gr.Column():
+
+                inp_func_2 = gr.Textbox(value = "x**3", 
+                        info = "e.g. x**3", 
+                        label = "Enter Your Expression here")
+                
+                inp_sign_2 = gr.Textbox(value = ">=", 
+                            info = "eg >=", 
+                            label = "Enter Your Sign Here")
+                
+            inp_point = gr.Textbox(value = "2", 
+                       info = "e.g. 2", 
+                       label = "Enter where your point will be separating your piecewise function")
+            
+        btn_3 = gr.Button("Run!")
+
+    with gr.Row():
+        piecewise_fn_scatter = gr.Plot(piecewise_fn_fig)
+        piecewise_dev_scatter = gr.Plot(piecewise_dev_fig)
+
+    gr.on(triggers = [inp_func_1.submit, inp_func_2.submit, inp_point.submit, inp_sign_1.submit, inp_sign_2.submit, btn_3.click], 
+        fn=get_piecewise_fn, 
+        inputs = [inp_func_1, inp_func_2, inp_point, inp_sign_1, inp_sign_2],
+        outputs = piecewise_fn_scatter)
+    
+    gr.on(triggers = [inp_func_1.submit, inp_func_2.submit, inp_point.submit, inp_sign_1.submit, inp_sign_2.submit, btn_3.click], 
+        fn=get_piecewise_dev, 
+        inputs = [inp_func_1, inp_func_2, inp_point, inp_sign_1, inp_sign_2],
+        outputs = piecewise_dev_scatter)
+    
+pr_fn_fig, pr_dev_fig = None, None
+    
+with gr.Blocks() as product_rule:
+    with gr.Column():
+        with gr.Row():
+            inp = gr.Textbox(value = "x**2", 
+                            info = "eg 'np.sqrt(x)'", 
+                            label = "Enter Your First Expression here")
+            inp_2 = gr.Textbox(value = "x**3", 
+                       info = "e.g. x**3", 
+                       label = "Enter Your Second Expression Here")
+        btn = gr.Button("Run!")
+
+    with gr.Row():
+        pr_fn_scatter = gr.Plot(pr_fn_fig)
+        dev_scatter = gr.Plot(pr_dev_fig)
+
+    gr.on(triggers = [inp.submit, inp_2.submit, btn.click], 
+          fn=get_pr_fn, 
+          inputs = [inp, inp_2], 
+          outputs = pr_fn_scatter)
+    
+    gr.on(triggers = [inp.submit, inp_2.submit, btn.click], 
+          fn=get_pr_dev, 
+          inputs = [inp, inp_2], 
+          outputs = dev_scatter)
+
+demo = gr.TabbedInterface([scatterplot, piecewise, product_rule], ["Single Function", "Piecewise Function", "Product Rule"])
+
+if __name__ == "__main__":
+
+    demo.launch()

src/main.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+import numpy as np
+import plotly.express as px
+import math
+import plotly.graph_objects as go
+
+class Derivative:
+    def __init__(self, start_stop_num: List[int, int, int] = [-10, 10, 200], expression: str = "x", function_name: str = None):
+        start, stop, num = start_stop_num
+        
+        self.x = np.linspace(start= start, stop= stop, num = num)
+        self.function_name = function_name if function_name else expression
+        self.expression = expression
+        self.h = 0.0001
+        self.y = None
+        self.delta_y = None
+
+    def _function(self):
+        
+        def _make_function(x):
+            return eval(self.expression)
+        
+        self.y = _make_function(self.x)
+        self.delta_y = _make_function(self.x + self.h)
+    
+    def _get_derivative(self):
+
+        if self.delta_y is None or self.y is None:
+            raise Exception("Define your y and delta_y first")
+        
+        self.derivative =  (self.delta_y - self.y) / self.h
+        return self.derivative
+
+    def _plot_f(self):
+
+        fig = px.scatter(x = self.x, y = self.y, title = self.function_name)
+        return fig
+
+    def _plot_derivative(self):
+
+        fig = px.scatter(x = self.x, y = self.derivative, title = f"Derivative of {self.function_name}")
+        return fig
+
+    def get_slope_one_point(self, x):
+        # using x and y, obtain the slope
+        # y = eval(self.expression)
+        math_expression = self.expression.replace("np", "math")
+
+        def _make_function(x): 
+            return eval(math_expression)
+        
+        y = _make_function(x)
+        delta_y = _make_function(x + self.h)
+        slope = (delta_y - y) / self.h
+
+        return slope, y
+
+    def get_tangent_line_vals(self, x):
+        slope, y = self.get_slope_one_point(x)
+        tangent_line_y_vals = slope * (self.x - x) + y
+        return y, tangent_line_y_vals
+
+    def draw_tangent_line(self, x):
+        y, tl_y_vals = self.get_tangent_line_vals(x)
+
+        title = f"Tangent line at point({x},{round(y, 2)}) of {self.function_name}"
+
+        if self.y is None:
+            self._function()
+
+        fig = go.Figure()
+        fig.update_layout(title = title)
+        fig.add_trace(go.Scatter(x = self.x, y = tl_y_vals, name = f"Tangent Line at ({x},{round(y, 2)})"))
+        fig.add_trace(go.Scatter(x = self.x, y = self.y, name = self.function_name))
+
+        return fig
+
+    def get_plots(self): 
+        return self._plot_f(), self._plot_derivative()
+
+    def __call__(self):
+        
+        self._function()
+        self._get_derivative()
+
+def get_fn(input: str):
+    dev_obj = Derivative(expression = input)
+    dev_obj()
+    fn_fig, _ = dev_obj.get_plots()
+    return fn_fig
+
+def get_dev(input: str):
+    dev_obj = Derivative(expression = input)
+    dev_obj()
+    _, dev_fig = dev_obj.get_plots()
+    return dev_fig
+
+def get_tangent_line(input_1: str, input_2: str):
+    dev_obj = Derivative(expression = input_1)
+    tl_fig = dev_obj.draw_tangent_line(int(input_2))
+    return tl_fig 

src/piecewise.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+from src.main import Derivative
+import numpy as np
+import plotly.express as px
+from varname import nameof
+
+
+class Piecewise():
+    def __init__(self, func_1: str, func_2: str, point: float, signs = ["<", ">="], start_stop_num: List[int, int, int] = [-10, 10, 200]):
+        start, stop, num = start_stop_num
+        x_values = np.linspace(start= start, stop= stop, num = num)
+        left_x_values_range =  f"{nameof(x_values)} {signs[0]} {str(point)}"
+        right_x_values_range =  f"{nameof(x_values)} {signs[1]} {str(point)}"
+        left_x_values = x_values[eval(left_x_values_range)]
+        right_x_values = x_values[eval(right_x_values_range)]
+
+        self.left_func = Derivative(expression = func_1)
+        self.right_func = Derivative(expression = func_2)
+
+        self.left_func.x = left_x_values
+        self.right_func.x = right_x_values
+
+        self.left_func()
+        self.right_func()
+        
+        self.piecewise_func_x = x_values
+        self.piecewise_func_y = np.append(self.left_func.y, self.right_func.y)
+        self.piecewise_func_derivative = np.append(self.left_func.derivative, self.right_func.derivative)
+
+    def _plot_f(self):
+
+        fig = px.scatter(x = self.piecewise_func_x, y = self.piecewise_func_y, title = "Piecewise Function")
+        return fig
+    
+    def _plot_dev(self):
+        fig = px.scatter(x = self.piecewise_func_x, y = self.piecewise_func_derivative, title = "Derivative")
+        return fig
+    
+    def plot(self):
+        return self._plot_f(), self._plot_dev()
+
+def get_piecewise_fn(input_1: str, input_2: str, input_3: str, sign_1: str, sign_2: str):
+    piecewise_obj = Piecewise(input_1, input_2, float(input_3), [sign_1, sign_2])
+    f_fig, _ = piecewise_obj.plot()
+    return f_fig
+
+def get_piecewise_dev(input_1: str, input_2: str, input_3: str, sign_1: str, sign_2: str):
+    piecewise_obj = Piecewise(input_1, input_2, float(input_3), [sign_1, sign_2])
+    _, dev_fig = piecewise_obj.plot()
+    return dev_fig

src/product_rule.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from src.main import Derivative
+import plotly.express as px
+
+class ProductRule:
+    
+    def __init__(self, func1_expression, func2_expression, start_stop_num: List[int, int, int] = [-10, 10, 200]):
+        
+        self.func1 = Derivative(expression = func1_expression)
+        self.func2 = Derivative(expression = func2_expression)
+
+        self.func1()
+        self.func2()
+
+        self.derivative = self._get_derivative()
+        self.y_values = self._get_y_values()  
+
+    def _get_derivative(self):
+        
+        product_rule = self.func1.y * self.func2.derivative + self.func1.derivative * self.func2.y
+        
+        return product_rule
+    
+    def _get_y_values(self):
+
+        return self.func1.y * self.func2.y
+    
+    def _plot_f(self):
+
+        fig = px.scatter(x = self.func1.x, y = self.y_values, title = "Product Function")
+        return fig
+    
+    def _plot_dev(self):
+        fig = px.scatter(x = self.func1.x, y = self.derivative, title = "Derivative")
+        return fig
+    
+    def plot(self):
+
+        return self._plot_f(), self._plot_dev()
+        
+def get_pr_fn(input1: str, input2: str):
+    pr_obj = ProductRule(input1, input2)
+    f_fig, _ = pr_obj.plot()
+    return f_fig
+
+def get_pr_dev(input1: str, input2: str):
+    pr_obj = ProductRule(input1, input2)
+    _, dev_fig = pr_obj.plot()
+    return dev_fig