Project: Cole Hollant - Math 313 -- Spring 2020 -- Shared
Path: Assignment #1 trial/Assignment 1 trial / assignment_04.sagews
Views: ⁹²⁴
#All three programs are good.

import math
import random
import functools

# '''
# ---====================---

#    Begin Helper Methods

# ---====================---
# '''

def merge(arr, l, m, r, cmp, reverse):
    cmp_helper = cmp
    if reverse: cmp_helper = lambda a, b: not cmp(a, b)
    left_midpoint = m - l + 1
    right_midpoint = r - m

    temp_arr_left = [arr[l + i] for i in range(left_midpoint)]
    temp_arr_right = [arr[m + 1 + i] for i in range(right_midpoint)]

    i = 0
    j = 0
    k = l

    while i < left_midpoint and j < right_midpoint:
        if cmp_helper(temp_arr_left[i], temp_arr_right[j]):
            arr[k] = temp_arr_left[i]
            i += 1
        else:
            arr[k] = temp_arr_right[j]
            j += 1
        k += 1

    while i < left_midpoint:
        arr[k] = temp_arr_left[i]
        i += 1
        k += 1
    while j < right_midpoint:
        arr[k] = temp_arr_right[j]
        j += 1
        k += 1

def merge_sort(arr, left_index=None, right_index=None, cmp=lambda a, b: a < b, reverse=False):
    if left_index is None:
        left_index = 0
    if right_index is None:
        right_index = len(arr) - 1
    if left_index < right_index:
        midpoint = math.floor((left_index + right_index - 1)/2)
        merge_sort(arr, left_index, midpoint, cmp, reverse)
        merge_sort(arr, midpoint + 1, right_index, cmp, reverse)
        merge(arr, left_index, midpoint, right_index, cmp, reverse)

def css_classes():
    '''
    pseudo-css-class generator!!
    dictionary mapping { pseudo-classname: inline-style }
    '''
    classes = {
        'border-light': 'border: 1px solid #a0aec0;',
        'text-light': 'color: #e6fffa;',
        'text-dark': 'color: #cbd5e0;',
        'rounded': 'border-radius: 3px;',
        'bg-dark': 'background-color: #1a202c;',
        'w-max': 'width: max-content;',
        'flex': 'display: flex;',
        'block': 'display: block;',
        'justify-between': 'justify-content: space-between;',
        'text-center': 'text-align: center;',
    }
    spacings = range(0, 12)
    scale_factor = 1.6 # note, cocalc uses rootFontSize=10px, I want to pretend it's 16px
    scale_rem = lambda x: str(round(x * scale_factor, 3))
    text_prefixes = 'xs sm base lg xl 2xl 3xl 4xl 5xl 6xl'.split()
    text_rem_sizes = [0.75, 0.875, 1, 1.125, 1.25, 1.5, 1.875, 2.25, 3, 4]
    classes.update({'text-{}'.format(text_prefixes[i]): 'font-size: {}rem;'.format(scale_rem(text_rem_sizes[i])) for i in range(len(text_prefixes))})
    spacing_opts = {
        'l': ['left: '],
        'r': ['right: '],
        't': ['top: '],
        'b': ['bottom: ']
    }
    spacing_opts.update({
        'x': spacing_opts['l'] + spacing_opts['r'],
        'y': spacing_opts['t'] + spacing_opts['b']
    })
    spacing_opts[''] = spacing_opts['x'] + spacing_opts['y']
    for spacing in spacings:
        space = str(round(spacing * 0.25, 2)) + 'rem; '
        for variant in ["margin", "padding"]:
            for prefix, rule_list in spacing_opts.items():
                classes[variant[0] + prefix + '-' + str(spacing)] = "".join([variant + "-" + rule + space for rule in rule_list])
    return classes

def apply_classes(raw_html, classes=None):
    '''
    pseudo-css-class injector!!
    note, doesn't actually support bem cause Im not caring about uniqueness (ie. card__header can be affected by card)

    params:
    - raw_html: string containing html!!
    - classes: object mapping classes to further either standard class names or inline styles (simulates @apply behavior from tw)
    '''
    if classes is not None:
        for k, v in classes.items():
            raw_html = raw_html.replace(k, v)
    rules = css_classes()
    for rule, definition in rules.items():
        raw_html = raw_html.replace(rule, definition)
    return raw_html


def assignment_html(exernum, assignment, funcs=None, params=None):
    '''
    returns html for the assignment definition!

    func=[{
                'name': 'listswitch(lis, i, k)',
                'params': ['lis: some list', 'i: index', 'k: index'],
                'returns': ['lis with indices i and k switched']
            }],

    params:
    - exernum: number of the exercise
    - assignment: problem statement
    - func: optional list of dictionaries describing functions. needs the following key-value pairs
      - name: <string>
      - params: <list<string>>
      - returns: <list<string>>
    - params: optional list of interactive inputs
    '''
    res = '''
        <div style="margin: 4rem 0;">
        <h1>Exercise {}</h1>
        <p><b>Assignment:</b> {}</p>
    '''.format(exernum, assignment)
    if funcs:
        for func in funcs:
            res += '<p><b>Function:</b><code style="block mt-4 ml-4">{}</code></p>'.format(func.get('name', ''))
            if 'params' in func:
                res += '<div style="ml-4"><i>params:</i><ul>'
                for param in func['params']:
                    res += "<li>{}</li>".format(param)
                res += "</ul></div>"
            if 'returns' in func:
                res += '<div style="ml-4"><i>returns:</i><ul>'
                for param in func['returns']:
                    res += "<li>{}</li>".format(param)
                res += "</ul></div>"
    if params:
        res += "<p><b>Interactive input:</b></p><ul>"
        for param in params:
            res += "<li>{}</li>".format(param)
        res += "</ul>"
    res += '</div>'
    return apply_classes(res)

def plot_arr(arr):
    '''
    helper for show so that we can pass lists
    '''
    return functools.reduce(lambda a,b : a + b, arr)

def show_all(arr):
    '''
    helper for show so that we can pass lists
    '''
    for el in arr:
        show(el)

def dist(point_a, point_b):
    '''
    helper to give distance between two points of equal dimension
    params:
    - point_a: tuple for point a
    - point_b: tuple for point b
    '''
    return sum([(a - b) ** 2 for a, b in zip(point_a, point_b)]) ** 0.5

def all_indices(arr, el):
    '''
    helper to give all indices of an element in an array
    '''
    return [i for i in range(len(arr)) if arr[i] == el]

def random_list(length, min_val=0, max_val=20):
    '''
    makes a random list
    '''
    return [random.randint(min_val, max_val) for _ in range(length)]

def arr_cmp(arr, cmp=lambda a, b: a < b, reverse=False):
    '''
    min/max helper with comparison function
    params:
    - arr: array
    - amp: comparison function
    - reverse: order of results
    returns extreme of arr according to cmp
    '''
    cmp_helper = cmp
    if reverse: cmp_helper = lambda a, b: not cmp(a, b)
    if len(arr) == 0:
        return None # maybe should raise an exception, not sure
    res = arr[0]
    for el in arr:
        if cmp_helper(el, res):
            res = el
    return res

def assignment(definition, func):
    '''
    assignment runner
    '''
    definition()
    interact(func)

random_points = lambda n, min_val=0, max_val=10: [(random.randint(min_val, max_val), random.randint(min_val, max_val)) for _ in range(n)]

class inputs:
    def __init__(self):
        pass

    @staticmethod
    def radio(val=[0, 1], label='selector'):
        return selector(val, label=label)

    @staticmethod
    def box(val=None, label='input'):
        return input_box(default=str(val), label=label)

    @staticmethod
    def num(num=None, label='number', min_val=-10, max_val=10):
        if not num:
            num = random.randint(min_val, max_val)
        return input_box(default=num, label=label)

    @staticmethod
    def arr(num=None, label='arr', min_val=-10, max_val=10):
        if not num:
            num = random.randint(3, 10)
        return input_box(default=str(random_list(num, min_val, max_val)), label=label)

    @staticmethod
    def switch(val=False, label='show'):
        return (label, val)



# '''
# ---========================---

#    End Helper Methods

#      --------

#    Begin Assignment Defs

# ---========================---
# '''

assignment_defs = {
    '1.8.2': lambda: html(assignment_html(
        '1.8.2',
        'Take a number a, and use a while loop to write all numbers a<sup>2</sup>, (a + 3)<sup>2</sup>, . . ., stopping when (5a)<sup>2</sup> is passed.',
        params=['(a) A number, denoted a.']
    )),
    '1.9.2': lambda: html(assignment_html(
        '1.9.2',
        'Make a function that takes a list of points in the plane and a number t (that can be either 0 or 1) and returns the list of the t-coordinates of the points.',
        funcs=[{
            'name': 'listcoord(lis, t)',
            'params': ['a list off points in the plane <code>lis</code> and a number <code>t</code> (that can be either 0 or 1)'],
            'returns': ['the list of the <i>t</i>-coordinates of the points']
        }],
        params=[
            '(a) A list of points in the plane.',
            '(b) A choice of 0 or 1 for the coordinate.',
        ]
    )),
    '1.9.3': lambda: html(assignment_html(
        '1.9.3',
        'Take a list of points in the plane and plot the polygon with vertices in the list.',
        params=['(a) A list of points in the plane.']
    ))
}


# '''
# ---========================---

#    End Assignment Defs

#      --------

#    Begin Assignment Methods

# ---========================---
# '''


def show_sequence(val):
    # predefine the limit, continue til it's reached
    res = []
    lim = (5 * val) ** 2
    while (val - 3) ** 2 < lim:
        res += [val ** 2]
        val += 3
    return res

# just a map with an index selector
show_index = lambda arr, ind: list(map(lambda a: a[ind], arr))

# connect all points in order
draw_polygon = lambda points: [
        point(a, rgbcolor="blue", size=30) +
        text(i, (a[0] + 0.1, a[1] + 0.1), horizontal_alignment='left', color='green') +
        line([points[i-1], points[i]], rgbcolor="red")
    for i, a in enumerate(points)]

# '''
# ---==========================---

#    End Assignment Methods

#      --------

#    Begin Interactive Methods

# ---==========================---
# '''

interact_show_sequence = lambda a=inputs.num(min_val=0, label='a'): show_all(["a = {}".format(a), show_sequence(a)])

interact_show_index = lambda lis=inputs.box(val=random_points(10), label='List'), coordinate=inputs.radio(): show_all(
    ["List: {}".format(lis), "List of {} coordinates: {}".format(coordinate, show_index(lis, coordinate))])

interact_draw_polygon = lambda points=inputs.box(val=random_points(10), label='List of Vertices of Polygon'): show(
    plot_arr(draw_polygon(points)), figsize=[5,5])

interactive = {
    '1.8.2': interact_show_sequence,
    '1.9.2': interact_show_index,
    '1.9.3': interact_draw_polygon
}

def run_interactive(run=interactive):
    for exernum, func in run.items():
        assignment(assignment_defs[exernum], func)


# '''
# ---=======================---

#    End Interactive Methods

#      ---------

#    Begin Main

# ---=======================---
# '''

def main():
    run_interactive()


main()
Exercise 1.9.3

Assignment: Take a list of points in the plane and plot the polygon with vertices in the list.
Interactive input:
(a) A list of points in the plane.
Interact: please open in CoCalc
Exercise 1.9.2

Assignment: Make a function that takes a list of points in the plane and a number t (that can be either 0 or 1) and returns the list of the t-coordinates of the points.
Function:listcoord(lis, t)
params:
a list off points in the plane lis and a number t (that can be either 0 or 1)
returns:
the list of the t-coordinates of the points
Interactive input:
(a) A list of points in the plane.
(b) A choice of 0 or 1 for the coordinate.
Interact: please open in CoCalc
Exercise 1.8.2

Assignment: Take a number a, and use a while loop to write all numbers a², (a + 3)², . . ., stopping when (5a)² is passed.
Interactive input:
(a) A number, denoted a.
Interact: please open in CoCalc
Exercise 1.9.3

Exercise 1.9.2

Exercise 1.8.2

Product

Resources

Company
