jrmoserbaltimore

from amaranth import *
from amaranth.lib.coding import *
from numpy import log2, ceil

# FIXME:  New Amaranth release indicates we should be deriving from Component, not
# Elaboratable
class MyCore(Elaboratable):

    def __init__(self):
        self.clock = Signal(1)

jrmoserbaltimore

with FSM():
    with m.State("Begin"):
        with m.If(self.strobe):
            m.next = "Process"
    with m.State("Process"):
        # Automatically create pipe.mult, pipe.shift
        with m.Pipeline([self.mult, self.shift]) as pipe:
            with pipe.Stage():
                # manually set up pipe.xor

jrmoserbaltimore

# Python 3.10 required
import numpy as np
from numpy import pi, sin, tan
from typing import Optional
import matplotlib.pyplot as plt
import scipy.fft as fft

class FilterModes:
    DSVF_CHAMBERLIN = 'Chamberlin'
    DSVF_LAZZARINI_TIMONEY = 'Lazzarini-Timoney'

jrmoserbaltimore

`default_nettype uwire

interface ICORDIC
#(
    parameter width=40 // 48 max
)
(
    wire logic [width-1:0] x,
    wire logic [width-1:0] y,
    wire logic [width-1:0] z,

jrmoserbaltimore

             +----------------------------------------------+
             |                                         /|   |
             |             +------------------------->| |   |
             |    +----+   |     /|            +----->| |---+
             +--->|    |   |    | |--->Acc1    | +--->| |
                  |Op 1|---+--->| |--->Acc2    | |     \|
                  +----+   |    | |--->Acc3    | |
               +-----------+     \|            | |
               |                               | |

| +-------------------+ |

jrmoserbaltimore

An attempt to explain step-by-step how FM synthesis calculation works.

OPL3

Using the OPL3 as an example, there are several components:

• Vibrato feeds into the phase generator (PG) to modulate its frequency
• Tremolo feeds into the envelope generator (EG) to modulate its amplitude
• PG and EG feed into the operator
• Operator outputs to the next operator

jrmoserbaltimore

These papers cover social choice, public choice, and voting theory. See the Handbook of Social Choice and Voting by Heckelman and Miller; or Collective Decisions and Voting by Nicolaus Tideman.

Voting rules and analysis

These are analyses of voting rules or other theoretical analysis independent of political conditions. This stretches as far as analyzing how and when voters behave strategically under particular systems, although that's more blurry.

• The Schulze Method of Voting
• Fine-grained Complexity and Algorithms for the Schulze Voting Method
• A Continuous Rating Method for Preferential Voting
• Prior version

jrmoserbaltimore

Ordered preferences X≻A → if X is not a candidate, voter votes for A

14: Alex≻Bobbie≻Chris≻Dane  \
12: Bobbie≻Alex≻Chris≻Dane   | ← 51% majority, doesn't count.
25: Chris≻Bobbie≻Alex≻Dane  /
49: Dane≻Chris≻Bobbie≻Alex  ← Most votes, wins plurality

Instant runoff voting:

jrmoserbaltimore

// Not valid

namespace Boilerplate
{
    public boilerplate BCompareOperators<T>
    {
        bool operator >(T lhs, T rhs) => lhs.CompareTo(rhs) > 0;
        bool operator <(T lhs, T rhs) => lhs.CompareTo(rhs) < 0;
        bool operator >=(T lhs, T rhs) => lhs.CompareTo(rhs) >= 0;
        bool operator <=(T lhs, T rhs) => lhs.CompareTo(rhs) <= 0;

jrmoserbaltimore

        protected virtual void OrderVotes()
        {
            int priorValue = 0;
            Votes.Sort();
            /* One vote, always rank 1 */
            if (Votes.Count >= 1 && Votes[0].Value != 1)
            {
                priorValue = Votes[0].Value;
                Votes[0] = new Vote(Votes[0].Candidate, 1);
            }