#!/bin/bash

# cksum.sh Performs a POSIX cksum in Bash.
#
# Copyright (C) 2026 Remington Furman
#
# SPDX-License-Identifier: MIT
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.


# Refer to the POSIX specification for details:
# https://pubs.opengroup.org/onlinepubs/9799919799/utilities/cksum.html

table=(
    0x00000000 0x04c11db7 0x09823b6e 0x0d4326d9 0x130476dc 0x17c56b6b
    0x1a864db2 0x1e475005 0x2608edb8 0x22c9f00f 0x2f8ad6d6 0x2b4bcb61
    0x350c9b64 0x31cd86d3 0x3c8ea00a 0x384fbdbd 0x4c11db70 0x48d0c6c7
    0x4593e01e 0x4152fda9 0x5f15adac 0x5bd4b01b 0x569796c2 0x52568b75
    0x6a1936c8 0x6ed82b7f 0x639b0da6 0x675a1011 0x791d4014 0x7ddc5da3
    0x709f7b7a 0x745e66cd 0x9823b6e0 0x9ce2ab57 0x91a18d8e 0x95609039
    0x8b27c03c 0x8fe6dd8b 0x82a5fb52 0x8664e6e5 0xbe2b5b58 0xbaea46ef
    0xb7a96036 0xb3687d81 0xad2f2d84 0xa9ee3033 0xa4ad16ea 0xa06c0b5d
    0xd4326d90 0xd0f37027 0xddb056fe 0xd9714b49 0xc7361b4c 0xc3f706fb
    0xceb42022 0xca753d95 0xf23a8028 0xf6fb9d9f 0xfbb8bb46 0xff79a6f1
    0xe13ef6f4 0xe5ffeb43 0xe8bccd9a 0xec7dd02d 0x34867077 0x30476dc0
    0x3d044b19 0x39c556ae 0x278206ab 0x23431b1c 0x2e003dc5 0x2ac12072
    0x128e9dcf 0x164f8078 0x1b0ca6a1 0x1fcdbb16 0x018aeb13 0x054bf6a4
    0x0808d07d 0x0cc9cdca 0x7897ab07 0x7c56b6b0 0x71159069 0x75d48dde
    0x6b93dddb 0x6f52c06c 0x6211e6b5 0x66d0fb02 0x5e9f46bf 0x5a5e5b08
    0x571d7dd1 0x53dc6066 0x4d9b3063 0x495a2dd4 0x44190b0d 0x40d816ba
    0xaca5c697 0xa864db20 0xa527fdf9 0xa1e6e04e 0xbfa1b04b 0xbb60adfc
    0xb6238b25 0xb2e29692 0x8aad2b2f 0x8e6c3698 0x832f1041 0x87ee0df6
    0x99a95df3 0x9d684044 0x902b669d 0x94ea7b2a 0xe0b41de7 0xe4750050
    0xe9362689 0xedf73b3e 0xf3b06b3b 0xf771768c 0xfa325055 0xfef34de2
    0xc6bcf05f 0xc27dede8 0xcf3ecb31 0xcbffd686 0xd5b88683 0xd1799b34
    0xdc3abded 0xd8fba05a 0x690ce0ee 0x6dcdfd59 0x608edb80 0x644fc637
    0x7a089632 0x7ec98b85 0x738aad5c 0x774bb0eb 0x4f040d56 0x4bc510e1
    0x46863638 0x42472b8f 0x5c007b8a 0x58c1663d 0x558240e4 0x51435d53
    0x251d3b9e 0x21dc2629 0x2c9f00f0 0x285e1d47 0x36194d42 0x32d850f5
    0x3f9b762c 0x3b5a6b9b 0x0315d626 0x07d4cb91 0x0a97ed48 0x0e56f0ff
    0x1011a0fa 0x14d0bd4d 0x19939b94 0x1d528623 0xf12f560e 0xf5ee4bb9
    0xf8ad6d60 0xfc6c70d7 0xe22b20d2 0xe6ea3d65 0xeba91bbc 0xef68060b
    0xd727bbb6 0xd3e6a601 0xdea580d8 0xda649d6f 0xc423cd6a 0xc0e2d0dd
    0xcda1f604 0xc960ebb3 0xbd3e8d7e 0xb9ff90c9 0xb4bcb610 0xb07daba7
    0xae3afba2 0xaafbe615 0xa7b8c0cc 0xa379dd7b 0x9b3660c6 0x9ff77d71
    0x92b45ba8 0x9675461f 0x8832161a 0x8cf30bad 0x81b02d74 0x857130c3
    0x5d8a9099 0x594b8d2e 0x5408abf7 0x50c9b640 0x4e8ee645 0x4a4ffbf2
    0x470cdd2b 0x43cdc09c 0x7b827d21 0x7f436096 0x7200464f 0x76c15bf8
    0x68860bfd 0x6c47164a 0x61043093 0x65c52d24 0x119b4be9 0x155a565e
    0x18197087 0x1cd86d30 0x029f3d35 0x065e2082 0x0b1d065b 0x0fdc1bec
    0x3793a651 0x3352bbe6 0x3e119d3f 0x3ad08088 0x2497d08d 0x2056cd3a
    0x2d15ebe3 0x29d4f654 0xc5a92679 0xc1683bce 0xcc2b1d17 0xc8ea00a0
    0xd6ad50a5 0xd26c4d12 0xdf2f6bcb 0xdbee767c 0xe3a1cbc1 0xe760d676
    0xea23f0af 0xeee2ed18 0xf0a5bd1d 0xf464a0aa 0xf9278673 0xfde69bc4
    0x89b8fd09 0x8d79e0be 0x803ac667 0x84fbdbd0 0x9abc8bd5 0x9e7d9662
    0x933eb0bb 0x97ffad0c 0xafb010b1 0xab710d06 0xa6322bdf 0xa2f33668
    0xbcb4666d 0xb8757bda 0xb5365d03 0xb1f740b4
)

cksum() {
    # Calculate CRC for file contents.
    local byte crc len LANG=C IFS=
    while read -r -d '' -n 1 byte ; do
        byte=$(printf "%d" \'$byte)
        ((len++))
        ((crc = 0xffffffff & ((crc<<8) ^ table[(crc >> 24) ^ byte])))
    done

    # Include file size in the CRC.
    n=len
    while ((n)) ; do
        ((byte = n & 255))
        ((n >>= 8))
        ((crc = 0xffffffff & ((crc << 8) ^ table[(crc >> 24) ^ byte])))
    done
    ((crc = 0xffffffff & ~crc))
    printf "%u %d" $crc $len
}

if [ "$*" ] ; then
    for file in "$@" ; do
        cksum < "$file" && echo " $file"
    done
else
    cksum
    echo
fi

NB. tides.ijs, sonify the tides using harmonic constituent data from
NB. NOAA.
NB.
NB. Copyright © 2025 Remington Furman
NB.
NB. SPDX-License-Identifier: MIT
NB.
NB. Permission is hereby granted, free of charge, to any person
NB. obtaining a copy of the software demonstrated in code cells (the
NB. "Software"), to deal in the Software without restriction, including
NB. without limitation the rights to use, copy, modify, merge, publish,
NB. distribute, sublicense, and/or sell copies of the Software, and to
NB. permit persons to whom the Software is furnished to do so, subject
NB. to the following conditions:
NB.
NB. The above copyright notice and this permission notice shall be
NB. included in all copies or substantial portions of the Software.
NB.
NB. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
NB. EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
NB. MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NB. NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
NB. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
NB. ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
NB. CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
NB. SOFTWARE.

NB. Exit on error:
9!:29]1[9!:27'2!:55]1'

NB. Use ASCII boxes:
boxdraw_j_ 1

NB. wav.ijs customizes some code from the media/wav addon.
load './wav.ijs'

NB. Save as a .wav file.
save_wav=: dyad define
  (SAMPLE_RATE wavmake x) 1!:2 <y
)

NB. Adapted from https://code.jsoftware.com/wiki/User:Devon_McCormick/Palettes
round_even=: monad define
  <.y+0.5*(0~:2|<.y)+.0.5~:1|y
)

NB. Audio setup
SAMPLE_RATE=: 44100 NB. Hz
SAMPLE_SIZE=: 16    NB. bits

NB. Scaling factors
NB. TODO: Determine max amplitude encountered at any station.
GAIN=: 0.3  NB. Allow for headroom.
MAX_PCM_AMP=: (2^(SAMPLE_SIZE-1))*GAIN
FT_TO_AMP=: MAX_PCM_AMP % 13.0
DPH_TO_RPS=: 2p1%(60*60*360.0)  NB. (degrees/hour) to (rad/second)
FREQ_SCALE=: 60*60*10000.0      NB. times realtime

NB. Synthesize a single harmonic constituent.
NB. x: number of output samples
NB. y: harmonic constituents (amplitude, phase, speed)
synth_harcon=: dyad define "0 1
  amp=. 0{y
  phase=. 360 %~ 2p1 * 1{y
  ang_vel=. FREQ_SCALE * DPH_TO_RPS*(2{y) % SAMPLE_RATE
  phases=. phase + 2p1|ang_vel*(i. x)
  ]samps=. amp * 1 o. phases
)

NB. Synthesize all the harmonic constituents at a tide station and
NB. save the waveform as a .wav audio file.
NB. x: number of output samples
NB. y: boxed station info
synth_station=: dyad define
  id=.".>{.{.{. y
  harcons=.".>(3 4 5) {"1 y NB. Just the facts, please.
  feet=.+/ x synth_harcon harcons
  samps=. round_even FT_TO_AMP*feet
  echo (":id)

  samps save_wav './output/', (":id), '.wav'
  0  NB. We only care about side-effects, so return a dummy value.
)

NB. Read harmonic constituents:
load 'tables/csv'
dat=: readcsv jpath 'harcon_amp.csv'

NB. Group and box each station:
stations=: ({."1 dat) </. dat

NB. Uncomment to use a short dataset for testing:
NB. stations=: 100{.stations

main=: monad define
  DUR_SEC=. 10.0
  DUR_SAMP=. round_even SAMPLE_RATE*DUR_SEC

  if. 0 do.
    NB. Single threaded
    DUR_SAMP (synth_station >)"0 stations
  else.
    NB. Multi-threaded.
    NB. Initialize threadpool 0 with N-1 threads.
    {{0 T.0}}^:] <: {. 8 T. ''
    ]&.> DUR_SAMP (synth_station >)t.''"0 stations
    NB. The ]&.> verb waits for every pyx to be populated, but is
    NB. otherwise a no-op.
    NB. J9.6 will crash if exit is called and tasks are still running.
    NB. J9.7 won't crash, but also doesn't wait for unfinished threads.
  end.
)

main''
exit''

/* tiger -- Tiger print standard input to standard output.
   Copyright (C) 2022 Remington Furman
   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <getopt.h>
#include "tiger.h"
#include "leopard.h"

void usage(char *name) {
    printf("usage: cat file | %s [-i] [-h] \n", name);
    printf("  -i    invert pattern\n");
    printf("  -h    print this help\n");
}

int main(int argc, char **argv) {
    int width  = tiger_width;
    int height = tiger_height;
    unsigned char *image = tiger_bits;

    int opt_invert = 0;

    if (strstr(argv[0], "tiger") != NULL) {
        width  = tiger_width;
        height = tiger_height;
        image  = tiger_bits;
    }
    else if (strstr(argv[0], "leopard") != NULL) {
        width  = leopard_width;
        height = leopard_height;
        image  = leopard_bits;
    }

    int opt;
    while ((opt = getopt(argc, argv, "ih")) != -1) {
        switch (opt) {
            case 'i':
                opt_invert = 0x1;
                break;
            case 'h':
                usage(argv[0]);
                exit(EXIT_SUCCESS);
                break;
            default:
                usage(argv[0]);
                exit(EXIT_FAILURE);
        }
    }

    int x = 0;
    int y = 0;
    char c;
    while ((c = getc(stdin)) != EOF) {
        if (c == '\n') {
            x = 0;
            y = (y+1) % height;
        }
        else if (c == '\t') {
            x = (x+8) % width;
        }
        else if (isgraph(c)) {
            x = (x+1) % width;
            unsigned char byte  = image[y*width + x>>3];
            unsigned char pixel = (byte >> (x&7)) & 1;
            pixel ^= opt_invert;
            c = pixel ? c : ' ';
        }
        putchar(c);
    }
}

#include <stdio.h>

/*
  Silly math trick:
  Generating square numbers with only addition.
  At each step, add n, then n+1.

  Example: from 4*4 to 5*5
  ssss n
  ssss n
  ssss n
  ssss n
  nnnn 1

Read more...
*/

int main(void) {
  int n = 1;
  int square = 1;

  while (square <= 256) {
    printf("%d * %d = %d\n", n, n, square);
    square += n++;
    square += n;
  }
}

stackoverflow.com##.ps-relative.js-pinned-left-sidebar.left-sidebar
stackoverflow.com##.mb16.s-anchors__grayscale.s-anchors.s-sidebarwidget__yellow.s-sidebarwidget
stackoverflow.com##.mb16.js-join-leave-container.s-sidebarwidget
stackoverflow.com##.tex2jax_ignore.module
stackoverflow.com##.js-feed-link
stackoverflow.com##.js-footer.site-footer

stackexchange.com##.ps-relative.js-pinned-left-sidebar.left-sidebar
stackexchange.com##.mb16.s-anchors__grayscale.s-anchors.s-sidebarwidget__yellow.s-sidebarwidget
stackexchange.com##.mb16.js-join-leave-container.s-sidebarwidget
stackexchange.com##.tex2jax_ignore.module
stackexchange.com##.js-feed-link
stackexchange.com##.js-footer.site-footer

askubuntu.com##.ps-relative.js-pinned-left-sidebar.left-sidebar
askubuntu.com##.mb16.s-anchors__grayscale.s-anchors.s-sidebarwidget__yellow.s-sidebarwidget
askubuntu.com##.mb16.js-join-leave-container.s-sidebarwidget
askubuntu.com##.tex2jax_ignore.module
askubuntu.com##.js-feed-link
askubuntu.com##.js-footer.site-footer

serverfault.com##.ps-relative.js-pinned-left-sidebar.left-sidebar
serverfault.com##.mb16.s-anchors__grayscale.s-anchors.s-sidebarwidget__yellow.s-sidebarwidget
serverfault.com##.mb16.js-join-leave-container.s-sidebarwidget
serverfault.com##.tex2jax_ignore.module
serverfault.com##.js-feed-link
serverfault.com##.js-footer.site-footer

superuser.com##.ps-relative.js-pinned-left-sidebar.left-sidebar
superuser.com##.mb16.s-anchors__grayscale.s-anchors.s-sidebarwidget__yellow.s-sidebarwidget
superuser.com##.mb16.js-join-leave-container.s-sidebarwidget
superuser.com##.tex2jax_ignore.module
superuser.com##.js-feed-link
superuser.com##.js-footer.site-footer

#!/usr/bin/awk -f
# Copyright Remington Furman, January 2023.

# Generate a Sankey diagram to track the Speaker of the House votes
# from House Clerk XML data.
#
# Generate diagram here:
# https://sankeymatic.com/build/?layout_style=auto&default_node_colorset=a&default_flow_inherit=outside_in&label_first_pos=before&font_face=sans-serif

BEGIN {
    r_color  = "#900"
    d_color  = "#009"
    p_color  = "#909"
    nv_color = "#999"

    candidate_colors["Jeffries_"]       = d_color
    candidate_colors["McCarthy_"]       = r_color
    candidate_colors["Banks_"]          = r_color
    candidate_colors["Biggs_"]          = r_color
    candidate_colors["Donalds_"]        = r_color
    candidate_colors["Jordan_"]         = r_color
    candidate_colors["Zeldin_"]         = r_color
    candidate_colors["Hern_"]           = r_color
    candidate_colors["Donald_J_Trump_"] = r_color
    candidate_colors["Present_"]        = p_color
    candidate_colors["Not_Voting_"]     = nv_color
}

FNR==1 {
  FNUM++
}

/<recorded-vote>/ {
    match($0,/>([^<]+)<\/legislator>.*>([^<]+)<\/vote>/,m)
    voter = m[1]
    candidate = m[2]"_"
    gsub(/ /, "_", voter) # Replace spaces.
    gsub(/ /, "_", candidate)
    gsub(/[\(\)\.,]/, "", voter) # Remove punctuation.
    gsub(/[\(\)\.,]/, "", candidate)

    votes[FNUM][voter]=candidate
    candidate_totals[FNUM][candidate]++
}

END {
    for (round in votes) {
        split("", defections) # Clear array.
        PROCINFO["sorted_in"] = "@val_str_asc"
        for (voter in votes[round]) {
            candidate = votes[round][voter]
            node_colors[candidate round]=candidate_colors[candidate]
            if (round == 1) {
                printf("%s%d [1] %s%d\n",
                       voter, round,
                       candidate, round)
            }
            else {
                previous_candidate = votes[round-1][voter]
                if (candidate != previous_candidate) {
                    defections[candidate]++
                    printf("%s%d [1] %s%d\n",
                           previous_candidate, round-1,
                           voter, round)
                    printf("%s%d [1] %s%d\n",
                           voter, round,
                           candidate, round)
                }
            }
        }
        if (round != 1) {
            for(candidate in candidate_totals[round]) {
                same_votes = candidate_totals[round][candidate] - defections[candidate]
                if (same_votes != 0) {
                    node_colors[candidate "voters" round]=candidate_colors[candidate]
                    printf("%s%d [%d] %svoters%d\n",
                           candidate, round-1,
                           same_votes,
                           candidate, round)
                    printf("%svoters%d [%d] %s%d\n",
                           candidate, round,
                           same_votes,
                           candidate, round)
                }
            }
        }
    }
    for (node in node_colors) {
        printf(":%s %s\n", node, node_colors[node])
        printf(":%s %s << >>\n", node, node_colors[node])
    }
}

#!/bin/bash

FILES=$(ls roll*.xml | sort -n)

./speaker_sankey.awk $FILES > speaker.sankey

#!/bin/env python3

# Evaluate exp(x) with an infinite series, as requested by the
# Operator in Seldom Seen Smith's nightmare in The Monkey Wrench Gang
# by Edward Abbey.  The Operator describes the assembly language for a
# simple computer which is simulated here.  It took me more than
# 0.000015 milliseconds to write this.

import math

x = 1.0                         # Input argument
expected_result = math.exp(x)

print(f"Input: {x}")
print(f"Expecting: {expected_result}")

w = x                           # Working register
s = [0.0] * 6                   # Storage locations

s[0] = 2.0                      # Iteration counter
s[1] = 1.0                      # Factorial
s[2] = 1.0                      # Partial sum
s[3] = x                        # Powers of x
s[4] = 1.0                      # Unity (constant)
s[5] = x                        # Input argument (constant)

# Functions to simulate the machine's op-codes.
def T(n):                       # Store working register.
    global w, s
    s[n] = w

def B(n):                       # Load working register.
    global w, s
    w = s[n]

def add(n):
    global w, s
    w = w + s[n]

def sub(n):
    global w, s
    w = w - s[n]

def mul(n):
    global w, s
    w = w * s[n]

def div(n):
    global w, s
    w = w / s[n]

def Z():
    exit(0)                     # End program.

print(w, s)

add(4)                          # Add 1 to x.
T(2)                            # Save the result.
B(1)                            # Load factorial.
mul(0)                          # Multiply by iteration count.
T(1)                            # Save result.
B(3)                            # Load power of x.
mul(5)                          # Multiply by x.
T(3)                            # Save result.
div(1)                          # Divide by factorial.
add(2)                          # Add to partial sum.
T(2)                            # Save result.

print(w, s)

for i in range(0,15):
    B(0)                        # Increment iteration counter.
    add(4)
    T(0)
    B(1)                        # Update factorial.
    mul(0)
    T(1)
    B(3)                        # Update power of x (x^n).
    mul(5)
    T(3)
    div(1)                      # Divide by factorial.
    add(2)                      # Add to partial sum.
    T(2)                        # Save result.

    print(w, expected_result, w - expected_result, s)

Z()

#include <stdio.h>
#include <complex.h>

/*
#!/bin/usr/env python3
import itertools
for perm in itertools.permutations(["static", "const", "float", "complex"]):
    print(" ".join(perm))
*/

int main (void) {
    static const float complex static_const_float_complex = 0 + 1 * I;
    static const complex float static_const_complex_float = 0 + 1 * I;
    static float const complex static_float_const_complex = 0 + 1 * I;
    static float complex const static_float_complex_const = 0 + 1 * I;
    static complex const float static_complex_const_float = 0 + 1 * I;
    static complex float const static_complex_float_const = 0 + 1 * I;
    const static float complex const_static_float_complex = 0 + 1 * I;
    const static complex float const_static_complex_float = 0 + 1 * I;
    const float static complex const_float_static_complex = 0 + 1 * I;
    const float complex static const_float_complex_static = 0 + 1 * I;
    const complex static float const_complex_static_float = 0 + 1 * I;
    const complex float static const_complex_float_static = 0 + 1 * I;
    float static const complex float_static_const_complex = 0 + 1 * I;
    float static complex const float_static_complex_const = 0 + 1 * I;
    float const static complex float_const_static_complex = 0 + 1 * I;
    float const complex static float_const_complex_static = 0 + 1 * I;
    float complex static const float_complex_static_const = 0 + 1 * I;
    float complex const static float_complex_const_static = 0 + 1 * I;
    complex static const float complex_static_const_float = 0 + 1 * I;
    complex static float const complex_static_float_const = 0 + 1 * I;
    complex const static float complex_const_static_float = 0 + 1 * I;
    complex const float static complex_const_float_static = 0 + 1 * I;
    complex float static const complex_float_static_const = 0 + 1 * I;
    complex float const static complex_float_const_static = 0 + 1 * I;

    printf("static_const_float_complex: (%f,%f)\n", crealf(static_const_float_complex), cimagf(static_const_float_complex));
    printf("static_const_complex_float: (%f,%f)\n", crealf(static_const_complex_float), cimagf(static_const_complex_float));
    printf("static_float_const_complex: (%f,%f)\n", crealf(static_float_const_complex), cimagf(static_float_const_complex));
    printf("static_float_complex_const: (%f,%f)\n", crealf(static_float_complex_const), cimagf(static_float_complex_const));
    printf("static_complex_const_float: (%f,%f)\n", crealf(static_complex_const_float), cimagf(static_complex_const_float));
    printf("static_complex_float_const: (%f,%f)\n", crealf(static_complex_float_const), cimagf(static_complex_float_const));
    printf("const_static_float_complex: (%f,%f)\n", crealf(const_static_float_complex), cimagf(const_static_float_complex));
    printf("const_static_complex_float: (%f,%f)\n", crealf(const_static_complex_float), cimagf(const_static_complex_float));
    printf("const_float_static_complex: (%f,%f)\n", crealf(const_float_static_complex), cimagf(const_float_static_complex));
    printf("const_float_complex_static: (%f,%f)\n", crealf(const_float_complex_static), cimagf(const_float_complex_static));
    printf("const_complex_static_float: (%f,%f)\n", crealf(const_complex_static_float), cimagf(const_complex_static_float));
    printf("const_complex_float_static: (%f,%f)\n", crealf(const_complex_float_static), cimagf(const_complex_float_static));
    printf("float_static_const_complex: (%f,%f)\n", crealf(float_static_const_complex), cimagf(float_static_const_complex));
    printf("float_static_complex_const: (%f,%f)\n", crealf(float_static_complex_const), cimagf(float_static_complex_const));
    printf("float_const_static_complex: (%f,%f)\n", crealf(float_const_static_complex), cimagf(float_const_static_complex));
    printf("float_const_complex_static: (%f,%f)\n", crealf(float_const_complex_static), cimagf(float_const_complex_static));
    printf("float_complex_static_const: (%f,%f)\n", crealf(float_complex_static_const), cimagf(float_complex_static_const));
    printf("float_complex_const_static: (%f,%f)\n", crealf(float_complex_const_static), cimagf(float_complex_const_static));
    printf("complex_static_const_float: (%f,%f)\n", crealf(complex_static_const_float), cimagf(complex_static_const_float));
    printf("complex_static_float_const: (%f,%f)\n", crealf(complex_static_float_const), cimagf(complex_static_float_const));
    printf("complex_const_static_float: (%f,%f)\n", crealf(complex_const_static_float), cimagf(complex_const_static_float));
    printf("complex_const_float_static: (%f,%f)\n", crealf(complex_const_float_static), cimagf(complex_const_float_static));
    printf("complex_float_static_const: (%f,%f)\n", crealf(complex_float_static_const), cimagf(complex_float_static_const));
    printf("complex_float_const_static: (%f,%f)\n", crealf(complex_float_const_static), cimagf(complex_float_const_static));
}

#!/bin/sh

# picocom.sh: Start picocom and remind the user how to exit.
# Copyright (C) 2021, Remington Furman

# Copying and distribution of this file, with or without modification,
# are permitted in any medium without royalty, provided the copyright
# notice and this notice are preserved. This file is offered as-is,
# without any warranty.

DEVICE=${1:-/dev/ttyUSB0}
BAUD=${2:-115200}

TITLE ()
{
    echo "\033]0;${1}\007"
}

# Set window title
echo -ne "$(TITLE "picocom $DEVICE -- C-a C-x to exit")"

/usr/bin/picocom -b "$BAUD" "$DEVICE"

/* lc -- Line encode a bitstream with output in WaveDrom format.
   Copyright (C) 2022 Remington Furman
   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#include <stdio.h>
#include <string.h>
#include <getopt.h>
#include <stdlib.h>

struct line_code
{
    int cs;   /* Current state. */
    int bit;  /* Current bit value. */
};

%%{
    machine line_code;
    access fsm->;

    action low     { fsm->bit  = 0;  putchar('l'); }
    action high    { fsm->bit  = 1;  putchar('h'); }
    action toggle  { fsm->bit ^= 1;  putchar(fsm->bit ? 'h' : 'l'); }
    action toggle2 { fsm->bit ^= 1;  putchar(fsm->bit ? 'h' : 'l');
                     fsm->bit ^= 1;  putchar(fsm->bit ? 'h' : 'l'); }
    action hold    {                 putchar('.'); }
    action nl      {                 putchar('\n'); }

    zero_low_h  = ('0' @low  ('0' @hold)*); # Emit one  low then hold for rest
    zero_high_h = ('0' @high ('0' @hold)*); # Emit one high then hold for rest
    one_low_h   = ('1' @low  ('1' @hold)*); # Emit one  low then hold for rest
    one_high_h  = ('1' @high ('1' @hold)*); # Emit one high then hold for rest

    # Line code machines
    nrz_l := ((zero_low_h  | one_high_h )** 0 @nl)*; # Non-return-to-zero level
    nrz_i := ((zero_high_h | one_low_h  )** 0 @nl)*; # Non-return-to-zero invert
    nrz_s := (('0' @toggle | '1' @hold  )*  0 @nl)*; # Non-return-to-zero space
    nrz_m := (('0' @hold   | '1' @toggle)*  0 @nl)*; # Non-return-to-zero mark

    bph_l := (('0' @low @high    | '1' @high @low   )* 0 @nl)*; # Bi-phase level
    bph_s := (('0' @toggle2      | '1' @toggle @hold)* 0 @nl)*; # Bi-phase space
    bph_m := (('0' @toggle @hold | '1' @toggle2     )* 0 @nl)*; # Bi-phase mark

    # Aliases
    pass   := any @{ fhold; fgoto nrz_l; };
    invert := any @{ fhold; fgoto nrz_i; };
    manch  := any @{ fhold; fgoto bph_l; };
    main   := any @{ fhold; fgoto nrz_l; };
}%%

%% write data;

void line_code_init(struct line_code *fsm, int first_bit, int start)
{
    fsm->bit = first_bit;

    %% write init;

    fsm->cs = start;
}

void line_code_execute(struct line_code *fsm, const char *data, int len)
{
    const char *p = data;
    const char *pe = data + len;

    %% write exec;
}

int line_code_finish(struct line_code *fsm)
{
    if (fsm->cs == line_code_error) {
        return -1;
    }

    if (fsm->cs >= line_code_first_final) {
        return 1;
    }
    return 0;
}

#define NUM_ELEMENTS(a) (sizeof(a)/sizeof(a[0]))
#define XSTRINGIFY(s) #s
#define STRINGIFY(s) XSTRINGIFY(s)
#define MACHINE(name, desc) { STRINGIFY(name), desc, &line_code_en_ ## name }

struct { const char *name; char* desc; const int *start; } machines[] = {
    MACHINE(nrz_l,  "Non-return-to-zero level"),
    MACHINE(nrz_i,  "Non-return-to-zero invert"),
    MACHINE(nrz_s,  "Non-return-to-zero space"),
    MACHINE(nrz_m,  "Non-return-to-zero mark"),
    MACHINE(bph_l,  "Bi-phase level"),
    MACHINE(bph_s,  "Bi-phase space"),
    MACHINE(bph_m,  "Bi-phase mark"),
    MACHINE(pass,   "Passthrough (alias of nrz_l)"),
    MACHINE(invert, "Invert (alias of nrz_i)"),
    MACHINE(manch,  "Manchester (alias of bph_l)"),
};

void usage(char *name) {
    printf("%s [flags] input" , name);
    printf("    input\n"
           "        One or more strings of 0's and 1's\n"
           "    -i n\n"
           "        Initial line state (default: 0)\n"
           "    -c name\n"
           "        Line code to use (default: pass)\n");
    printf("\nAvailable codes:\n");
    for (int i = 0; i < NUM_ELEMENTS(machines); i++) {
        printf("  %-7s- %s\n", machines[i].name, machines[i].desc);
    }
}

int main(int argc, char **argv)
{
    struct line_code lc;

    int first_bit = 0;
    int start = line_code_en_nrz_l;

    int opt;
    while ((opt = getopt(argc, argv, "f:m:h")) != -1) {
        switch (opt) {
            case 'f': {
                first_bit = !!atoi(optarg);
                break;
            }
            case 'm': {
                int found = 0;
                for (int i = 0; i < NUM_ELEMENTS(machines); i++) {
                    if (strcmp(optarg, machines[i].name) == 0) {
                        start = *machines[i].start;
                        found = 1;
                        break;
                    }
                }
                if (!found) {
                    printf("Invalid machine name: %s\n", optarg);
                    usage(argv[0]);
                    exit(EXIT_FAILURE);
                }
                break;
            }
            case 'h': {
                usage(argv[0]);
                exit(EXIT_SUCCESS);
                break;
            }
            default: {
                usage(argv[0]);
                exit(EXIT_FAILURE);
                break;
            }
        }
    }

    /* Initialize state machine */
    line_code_init(&lc, first_bit, start);

    for (int i = optind; i < argc; i++) {
        /* Encode each input argument. */
        line_code_execute(&lc, argv[i], strlen(argv[i])+1);
    }

    if (line_code_finish(&lc) != 1) {
        fprintf(stderr, "%s: bad input\n", argv[0]);
        usage(argv[0]);
        exit(EXIT_FAILURE);
    }

    return 0;
}

{signal: [
  {name: 'pass',   wave: 'lhl.h.l..h..l...h...'},
  {name: 'invert', wave: 'hlh.l.h..l..h...l...'},
  {name: 'nrz_l',  wave: 'lhl.h.l..h..l...h...'},
  {name: 'nrz_i',  wave: 'hlh.l.h..l..h...l...'},
  {name: 'nrz_s',  wave: 'h.lh..lhl...hlhl....'},
  {name: 'nrz_m',  wave: '.h..lh...lhl....hlhl'},
  {name: 'manch',  wave: 'lhhllhlhhlhllhlhlhhlhlhllhlhlhlhhlhlhlhl'},
  {name: 'bph_l',  wave: 'lhhllhlhhlhllhlhlhhlhlhllhlhlhlhhlhlhlhl'},
  {name: 'bph_s',  wave: 'hlh.lhlhl.h.lhlhlhl.h.l.hlhlhlhlh.l.h.l.'},
  {name: 'bph_m',  wave: 'h.lhl.h.lhlhl.h.l.hlhlhlh.l.h.l.hlhlhlhl'},
]}

~/scripts $ cat ./annoyances.sh
#!/bin/bash

if [[ $1 =~ ^([a-z])([0-9]+)([a-z])$ ]] ; then
  grep "^${BASH_REMATCH[1]}[^']\{${BASH_REMATCH[2]}\}${BASH_REMATCH[3]}$" /usr/share/dict/words
else
  echo Poor form.
fi

$ cat numeronym.awk
#!/usr/bin/awk -f

BEGIN { savings = 0 }

{
  nwords = split($0, a, /[^[:alpha:]]+/, seps)
  for (i=1; i<=nwords; i++) {
    if(match(a[i], /^([[:alpha:]])([[:alpha:]]{2,})([[:alpha:]])$/, b)) {
      printf "%s", b[1]length(b[2])b[3]
      savings += length(b[2]) - 1
    }
    else {
      printf "%s", a[i]
    }

    printf "%s", seps[i] 
  }
  printf "\n"
}

END {
  printf "You saved %d chars today!\n", savings
}

# image_sort.tcl -- merge sort images with user input
# by Remington Furman 2021-01-08
# Based on image_viewer.tcl by Keith Vetter 2013-08-31
#
# Merge sort a list of images based on user input.  Each comparison
# step presents the user with two images, and the image that should
# come first is selected with a key (`a` or `h` for the left image and
# `d` or `l` for the right image).
#
# Write the list of filenames to a file, then call this script like so:
# $ wish image_sort.tcl file_list.txt
#
# Or use Bash process substitution:
# $ wish image_sort.tcl <(ls photos/*.jpg)

package require Tk
package require Img

set S(title) "Image Sorter"
set S(fnamel) ""
set S(fnamer) ""

set SCALING_FACTORS [dict create 1 1 2 1/2 3 1/3 4 1/4 1/2 2 1/3 3 1/4 4]

proc init_display {} {
    global S

    wm title . $S(title)
    destroy {*}[winfo child .]

    set ::S(max,width)  [expr {([winfo screenwidth .] / 2) - 100}]
    set ::S(max,height) [expr {[winfo screenheight .] - 200}]

    foreach side {l r} {
        canvas ".c${side}" -bd 5 -highlightthickness 0 \
            -width 600 -height 700 -bg dimgray
        label ".fn${side}" -textvariable "S(fname${side})"
    }

    grid .fnl .fnr
    grid .cl .cr -sticky ns
    grid rowconfigure . 1 -weight 1
    grid columnconfigure . 0 -weight 1
    grid configure .cl -sticky news
    grid configure .cr -sticky news

    foreach canvas {.cl .cr} {
        $canvas create image 0 0 -tag img -anchor nw
        $canvas create rect -100 -100 -100 -100 \
            -tag cropBox -fill {} -outline red -width 3 -dash "-"
    }

    bind all <Control-w> exit
    bind . <Destroy> exit

    foreach event { <Left> <Prior> <leftarrow> a h } {
        bind all $event [list set compare_result -1]
    }

    foreach event { <Right> <Next> <rightarrow> d l } {
        bind all $event [list set compare_result 1]
    }

    bind all <Alt-c> {catch {console show}}
}

proc shrink_image_to_fit_screen {canvas} {
    set w [image width "::img::img$canvas"]
    set h [image height "::img::img$canvas"]
    foreach factor {1 2 3 4} {
        if {$w / $factor < $::S(max,width) && \
            $h / $factor < $::S(max,height)} break
    }
    set ::S("shrunk$canvas") [dict get $::SCALING_FACTORS $factor]
}

proc make_display_image {canvas} {
    global S

    if {"::img::display$canvas" in [image names]} {
        image delete "::img::display$canvas"
    }

    ::image create photo "::img::display$canvas"
    "::img::display$canvas" copy "::img::working$canvas"
    $canvas coords img 0 0
    set S(width,display)  $S(width)
    set S(height,display) $S(height)

    $canvas config -scrollregion [$canvas bbox img]
    $canvas itemconfig img -image "::img::display$canvas"
    $canvas xview moveto 0
    $canvas yview moveto 0
}

proc load_image {fname canvas} {
    global S

    foreach img {"::img::img$canvas" "::img::working$canvas"} {
        if {$img in [image names]} {image delete $img}
    }

    image create photo "::img::img$canvas" -file $fname
    image create photo "::img::working$canvas"
    shrink_image_to_fit_screen $canvas
    resize_image $canvas

    wm geom . {}
    $canvas config -width $S(width,display) -height $S(height,display)
}

proc resize_image {canvas} {
    global S
    set factor [dict get $::SCALING_FACTORS $S("shrunk$canvas")]
    if {"::img::working$canvas" in [image names]} {
        image delete "::img::working$canvas"
    }
    image create photo "::img::working$canvas"
    "::img::working$canvas" copy "::img::img$canvas" -subsample $factor
    set S(width) [image width "::img::working$canvas"]
    set S(height) [image height "::img::working$canvas"]
    set S(size) "${S(width)}x$S(height)"

    make_display_image $canvas
    $canvas config -scrollregion [$canvas bbox img]
    $canvas coords cropBox -100 -100 -100 -100
}

proc compare_images {a b} {
    global compare_result
    global S

    puts -nonewline "Comparing $a and $b: "

    # Display both images.
    load_image $a .cl
    load_image $b .cr
    set S(fnamel) [file tail $a]
    set S(fnamer) [file tail $b]

    # Wait for user input.
    vwait compare_result
    puts $compare_result

    # Return result.
    return $compare_result
}

proc read_file_list {file} {
    set f [open $file r]
    # Split the file by newlines, and remove the empty element from
    # the end of the list.
    set files [lreplace [split [read $f] "\n"] end end]
    close $f
    return $files
}

init_display
set files [read_file_list [lindex $argv 0]]
puts "Sorting:  $files"
set files [lsort -command compare_images $files]
puts "Finished sorting:"
puts $files

exit

# Make test images for image_sort.tcl
#
# The parallelized Make loop trick is inspired by:
# https://stackoverflow.com/a/12110773/182734
#
# The imagemagick command is from:
# https://stackoverflow.com/a/63043486/182734

IMGDIR=img
N := 16
IMAGES := $(addprefix $(IMGDIR)/test_image_, \
          $(addsuffix .png, \
          $(shell seq -w $(N))))

all: $(IMAGES)

$(IMGDIR):
        mkdir $@
$(IMAGES): $(IMGDIR)/test_image_%.png:  | $(IMGDIR)
        convert -gravity center -background black -fill white -size 200x150 \
        caption:"$*" $@

/*
  Copyright (C) 2025 Remington Furman

  Permission is hereby granted, free of charge, to any person
  obtaining a copy of this software and associated documentation files
  (the "Software"), to deal in the Software without restriction,
  including without limitation the rights to use, copy, modify, merge,
  publish, distribute, sublicense, and/or sell copies of the Software,
  and to permit persons to whom the Software is furnished to do so,
  subject to the following conditions:

  The above copyright notice and this permission notice shall be
  included in all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.

  Replace edge labels with rectangular nodes that contain the label
  text.

  Inspired by:
  https://forum.graphviz.org/t/how-to-tell-dot-to-put-the-edge-label-in-a-box/1578/8
  and:
  https://www.exchangetuts.com/how-can-i-reverse-the-direction-of-every-edge-in-a-graphviz-dot-language-graph-1640404624170374
*/

BEG_G {
  string nodeName, prefix="__LabelNode_";
  int I=0;
  node_t labelNode;
  edge_t begEdge;
  edge_t endEdge;
  $O = graph($.name + "_box", "D");
  copyA($G, $O);
}

N {
  clone($O, $);
}

E {
  if (hasAttr($,"label")){
    I++;
    printf("edge %d, %s\n", I, $.label);
    nodeName = prefix+(string)I;
    labelNode = node($O,nodeName);
    labelNode.label = $.label;
    labelNode.shape="rect";
    begEdge = edge_sg($O, clone($O, $.tail), labelNode, "");
    endEdge = edge_sg($O, labelNode, clone($O, $.head), "");
    switch ($.dir) {
      default:
      case "forward": {
        begEdge.dir = "none";
        endEdge.dir = "forward";
        break;
      }
      case "back": {
        begEdge.dir = "back";
        endEdge.dir = "none";
        break;
      }
      case "both": {
        begEdge.dir = "back";
        endEdge.dir = "forward";
        break;
      }
      case "none": {
        begEdge.dir = "none";
        endEdge.dir = "none";
        break;
      }
    }
  } else {
    copy($O, $);
  }
}

END {
  printf("done.\n")
}

DOTS=$(wildcard *.dot)

SVGS=$(patsubst %.dot,%.svg,$(DOTS))
LABELED_SVGS=$(patsubst %.dot,%_label.svg,$(DOTS))
PNGS=$(patsubst %.dot,%.png,$(DOTS))
LABELED_PNGS=$(patsubst %.dot,%_label.png,$(DOTS))

all: $(SVGS) $(LABELED_SVGS) $(PNGS) $(LABELED_PNGS)

%.svg: %.dot
        dot -Tsvg $< > $@

%.png: %.dot
        dot -Tpng $< > $@

%_label.dot: %.dot label_box.gvpr
        gvpr -o $@ -f label_box.gvpr $<

/* goertzel_fixed -- Detect a single tone in an audio signal.
   Copyright (C) 2022 Remington Furman
   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see https://www.gnu.org/licenses/.
*/

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#include <complex.h>

/* These macros simplify working with signed fixed point numbers.

   In this notation, only the fractional bits are tracked in the macro
   names, so a Qm.n number is referred to as a Qn number, where n is
   the number of fractional bits.  This also sidesteps the issue of
   whether m includes the sign bit or not (ARM vs TI notation).

   The usual caveats of C preprocessor macros hold here.  Beware of
   multiple evaluations, side effects, etc.
*/

/* Convert to and from doubles. */
#define Qn_FROM_DOUBLE(value, n) (lrint((value) * (1 << (n))))
#define DOUBLE_FROM_Qn(value, n) ((double)(value) / (1 << (n)))

/* The number closest to +1.0 that can be represented. */
#define ONE_Qn(n) ((1<<(n)) - 1)
/* One half (0.5). */
#define HALF_Qn(n) (1<<((n) - 1))

/* Drop n bits from x (shift right) while rounding (add one half). */
#define ROUND_OFF_Qn(x, n)                      \
    ((n > 0) ? (((x) + HALF_Qn(n)) >> n) : (x))

/* Multiply two Qn numbers, rounding to the precision of the first.
   Make sure to cast one of the arguments to the size needed to avoid
   overflow in the multiplication before shifting. */
#define MUL_Qn_Qn(x, y, xn, yn)                 \
    ROUND_OFF_Qn((x) * (y), (yn))

/* Add two Qn numbers, using the precision of the first. */
#define ADD_Qn_Qn(x, y, xn, yn)                 \
    ((xn) > (yn) ? (x) + ((y) << ((xn)-(yn))) : \
     (x) + ROUND_OFF_Qn((y), ((xn)-(yn))))

typedef struct {
    int16_t real;
    int16_t imag;
} cint16_t;

/* Return a larger type here, because a complex point outside of the
   unit circle will have a larger magnitude. */
int32_t cint16_abs(cint16_t z) {
    /* Cheat for now and use floating point sqrt(). */
    return lrint(sqrt((double)z.real*(double)z.real +
                      (double)z.imag*(double)z.imag));
}

int16_t read_sample(void) {
    /* This function should read and return an audio sample from some
       source. */
    return 0;
}

int32_t goertzel(double detect_hz, double sample_rate_hz, int N) {
    /* Notation from p. 710 of Lyons. */

    /* Index of DFT frequency bin to calculate. */
    const double m = (N * detect_hz) / sample_rate_hz;

    /* This complex feedforward coefficient allows a single zero to
       cancel one of the complex poles.  It can be calculated in
       advance. */
    const double complex dbl_coeff_ff = -cexp(-I*2*M_PI*m/N);

    const int coeff_ff_Qn = 15;  /* Q1.15 */
    cint16_t coeff_ff;
    coeff_ff.real = Qn_FROM_DOUBLE(creal(dbl_coeff_ff), coeff_ff_Qn);
    coeff_ff.imag = Qn_FROM_DOUBLE(cimag(dbl_coeff_ff), coeff_ff_Qn);

    /* Feedback coefficient. */
    double dbl_coeff_fb = 2*cos(2*M_PI*m/N);
    const int coeff_fb_Qn = 14;  /* Q2.14 */
    int16_t coeff_fb = Qn_FROM_DOUBLE(dbl_coeff_fb, coeff_fb_Qn);

    const int w_Qn = 15;
    int32_t w[3] = {0};         /* Delay line. Q17.15. */

    int sample_index = 0;

    /* Read and process N+1 samples. */
    while (1) {
        const int x_Qn = 15;  /* Q1.15. */
        int16_t x = read_sample();

        if (sample_index == N) {
            /* The final x input sample should be forced to zero. */
            x = 0;
        }

        /* Manually shift delay line and calculate next value. */
        w[2] = w[1];
        w[1] = w[0];

        /* w[0] = x + (coeff_fb * w[1]) - w[2] */
        w[0] = MUL_Qn_Qn((int64_t)w[1], (int64_t)coeff_fb, w_Qn, coeff_fb_Qn);
        w[0] = ADD_Qn_Qn(w[0], x, w_Qn, x_Qn);
        w[0] = ADD_Qn_Qn(w[0], -w[2], w_Qn, w_Qn);

        if (sample_index++ == N) {
            /* End of Goertzel alogorithm for this buffer. Apply the
             * feedforward coefficient to generate final output. */
            const int y_Qn = 5;
            cint16_t y; /* y = w[0] + coeff_ff * w[1];  complex multiply. */
            y.real = ROUND_OFF_Qn(w[0] +
                                  MUL_Qn_Qn((int64_t)coeff_ff.real, w[1],
                                            coeff_ff_Qn, w_Qn), w_Qn - y_Qn);
            y.imag = ROUND_OFF_Qn(
                MUL_Qn_Qn((int64_t)coeff_ff.imag, w[1],
                          coeff_ff_Qn, w_Qn), w_Qn - y_Qn);

            int32_t dft_mag = cint16_abs(y);

            return dft_mag;
        }
    }
}

int main(void) {
    /* Input sample rate. */
    const double sample_rate_hz = 48000.0;

    /* Frequency of DFT bin to calculate. */
    const double detect_hz = 440.0;

    /* Number of samples for detection.  Need not be a power of 2. */
    const int N = 1024;

    while(1) {
        int32_t dft_mag = goertzel(detect_hz, sample_rate_hz, N);

        /* Normalize the DFT bin value by N.  A maximum amplitude
           signal at the detection frequency should give a value
           of 1/2. */
        double dft_mag_norm = dft_mag/N;
        printf("dft_mag: %u, dft_mag_norm: %g\n", dft_mag, dft_mag_norm);
    }
}

; Meme It
; Copyright (C) 2023 Remington Furman
;
; This program is free software: you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by
; the Free Software Foundation; either version 3 of the License, or
; (at your option) any later version.
;
; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
; GNU General Public License for more details.
;
; You should have received a copy of the GNU General Public License
; along with this program.  If not, see <https://www.gnu.org/licenses/>.
;
;
; Adds a border beneath the current text layer, selection, or active
; path as a layer below the active layer.
;


(define (duplicate-layer-under image drawable)
  (let* ((pos (car (gimp-image-get-item-position image drawable)))
         (parent (car (gimp-item-get-parent drawable)))
         (layer-copy (car (gimp-layer-copy drawable TRUE))))
    (gimp-image-insert-layer image layer-copy parent (+ pos 1))
    layer-copy))


(define (gimp-true gimp-pred)
  (= (car gimp-pred) TRUE))


(define (script-fu-meme-it image drawable width merge)
  (gimp-image-undo-group-start image)
  (gimp-context-push)

  (gimp-context-swap-colors)
  (gimp-context-set-opacity 100.0)
  (gimp-context-set-stroke-method STROKE-LINE)
  (gimp-context-set-line-width width)
  (gimp-context-set-line-cap-style CAP-ROUND)
  (gimp-context-set-antialias TRUE)

  ;; Draw a new layer under the text layer.
  (if (gimp-true (gimp-item-is-text-layer drawable))
      (let* ((text-copy (duplicate-layer-under image drawable))
             (text-vectors (car (gimp-vectors-new-from-text-layer image drawable))))
        (gimp-image-insert-vectors image text-vectors 0 0)
        (gimp-text-layer-set-color text-copy (car (gimp-context-get-foreground)))
        (gimp-layer-resize-to-image-size text-copy)
        (gimp-edit-stroke-vectors text-copy text-vectors)
        (gimp-image-remove-vectors image text-vectors)
        (gimp-selection-none image)
        (plug-in-autocrop-layer RUN-NONINTERACTIVE image text-copy)
        (if (= merge TRUE)
            (gimp-image-merge-down image drawable EXPAND-AS-NECESSARY)))
      ;; else
      (if (gimp-true (gimp-selection-is-empty image))
          ;; Stroke the active path twice on the current layer.
          (let* ((vectors (car (gimp-image-get-active-vectors image))))
            (if (not (= vectors -1))
                (begin
                  (gimp-context-set-line-width (* width 2))
                  (gimp-edit-stroke-vectors drawable vectors)

                  (gimp-context-swap-colors)
                  (gimp-context-set-line-width width)
                  (gimp-edit-stroke-vectors drawable vectors))))
          ;; else
          (begin
            ;; Stroke the selection twice.  This doesn't look as good
            ;; as stroking a path, but there isn't a way to convert
            ;; the selection to a path first.
            (gimp-context-set-line-width (* width 2))
            (gimp-drawable-edit-stroke-selection drawable)

            (gimp-context-swap-colors)
            (gimp-context-set-line-width width)
            (gimp-drawable-edit-stroke-selection drawable))))

  (gimp-displays-flush)                 ; Show this masterpiece.
  (gimp-context-pop)
  (gimp-image-undo-group-end image))


(script-fu-register "script-fu-meme-it"
                    "M_eme It..."
                    "Add a background border to the selected text (or path)"
                    "Remington Furman <remington@remcycles.net>"
                    "Remington Furman"
                    "2023"
                    "RGB*,GRAY*"
                    SF-IMAGE       "Image"           0
                    SF-DRAWABLE    "Drawable"        0
                    SF-ADJUSTMENT  "Stroke Width"    '(5 1 100 1 5 1 0)
                    SF-TOGGLE      "Merge layers"    TRUE
                    )


(script-fu-menu-register "script-fu-meme-it" "<Image>/Filters/Light and Shadow/")

seq 10 20 | ./gp_wrap.sh

./gp_wrap.sh -f file.csv -p -p -p

./gp_wrap.sh -f file.csv -h -p -p -p

#!/bin/bash

# gp_wrap.sh simplifies the Gnuplot interface and makes plotting
# data from CSV files easier.
# Copyright (C) 2021  Remington Furman

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.


# The command line arguments form a mini language that modify the
# current state of the plot parameters which are used when the -p
# (plot) argument is given to add a line to the plot.  By default, the
# plot parameters will plot the first column of the CSV file with no
# labels or title, and subsequent plots will plot the next column (-y
# will increment with each -p).

# Examples:
# ./gp_wrap.sh -f file.csv -p -p -p      # Plot columns 1, 2, 3 vs row number.
# ./gp_wrap.sh -f file.csv -h -p -p -p   # Same, but use headers from first row.
# ./gp_wrap.sh -h -p -p -p < file.csv    # Same, but read from stdin.
# ./gp_wrap.sh -f file.csv -x 2 -y 3 -p  # Plot col3 vs col2.


usage () {
    cat <<EOF
Usage:

    -f file    Plot data from File (default: stdin)
    -w file    Write output to file
    -F string  Use 'string' as Field separator (default: ",")
    -x n       Use column 'n' for X coordinates (default: use row number)
    -y n       Use column 'n' for Y coordinates (default: 1)
    -r range   Use Range for x and y axes (default: none)
    -a string  Label x axis (Abscissa) with 'string' (default: none)
    -o string  Label y axis (Ordinate) with 'string' (default: none)
    -t string  Label next plots with 'string' (default: filename)
    -T string  Set Title to 'string' (default: none)
    -s string  Style next plots with 'string' (default: lines)
    -k string  Place plot key at 'string' (default: top left)
    -i         Increment current column after each plot (default)
    -I         Don't Increment current column after each plot
    -m         Format Math in plot titles with TeX (default: off)
    -p         Make a Plot with the current parameters
    -l         List current parameters
    -h         Use first row (Header) as plot labels
    -c string  Add Custom Gnuplot commands to preamble (default: none)
    -u         Display Usage
    -d         Debug (print Gnuplot input)
EOF
}

# Set default parameters
STDIN=true                      # Read from stdin.
FILE=$(mktemp -u)
OUTPUT="./plot.png"
FIELD_SEP=","
X_COL=
Y_COL=1
RANGE=
X_LABEL=
Y_LABEL=
TITLE=
TITLE_MATH="set key noenhanced"
STYLE="with lines"
KEY_LOC="set key left top"
HEADER=
INCREMENT=true
CUSTOM=
PLOTS=
DEBUG=

# Read command line arguments
optstring="f:w:F:x:y:r:a:o:t:T:s:k:c:iImplhud"
while getopts ${optstring} arg; do
    case ${arg} in
        f)
            FILE="${OPTARG}"
            STDIN=false
            ;;
        w)
            OUTPUT="${OPTARG}"
            ;;
        F)
            FIELD_SEP="${OPTARG}"
            ;;
        x)
            # Note the trailing : which is necessary for specifying
            # the x and y coordinates.
            X_COL="${OPTARG}:"
            ;;
        y)
            Y_COL="${OPTARG}"
            ;;
        r)
            RANGE="${OPTARG}"
            ;;
        a)
            X_LABEL="${OPTARG}"
            ;;
        o)
            Y_LABEL="${OPTARG}"
            ;;
        t)
            PLOT_TITLE="title '${OPTARG}'"
            ;;
        T)
            TITLE="${OPTARG}"
            ;;
        s)
            STYLE="${OPTARG}"
            ;;
        k)
            KEY_LOC="set key ${OPTARG}"
            ;;
        i)
            INCREMENT=true
            ;;
        I)
            INCREMENT=false
            ;;
        m)
            TITLE_MATH=""
            ;;
        p)
            # Add a new plot command with current parameters.
            if [ "${STDIN}" = true -a \
                 -z "${HEADER}" -a    \
                 -z "${PLOT_TITLE}" ] ; then
                PLOT_TITLE="title 'stdin'"
            fi

            PLOTS="${PLOTS:+${PLOTS}, }" # Append comma if plots exist.
            PLOTS+="'${FILE}' using ${X_COL}${Y_COL} ${STYLE} ${PLOT_TITLE}"

            if "$INCREMENT" = true ; then
                # Move to next column.
                Y_COL=$((Y_COL+1))
            fi
            ;;
        l)
            echo FILE="$FILE"
            echo X_COL="$X_COL"
            echo Y_COL="$Y_COL"
            echo X_LABEL="$X_LABEL"
            echo Y_LABEL="$Y_LABEL"
            echo TITLE="$TITLE"
            echo HEADER="$HEADER"
            echo INCREMENT="$INCREMENT"
            echo CUSTOM="$CUSTOM"
            echo PLOTS="$PLOTS"
            ;;
        h)
            HEADER="set key autotitle columnheader"
            ;;
        c)
            CUSTOM+=$'\n'
            CUSTOM+="${OPTARG}"
            ;;
        u)
            usage
            exit
            ;;
        d)
            DEBUG=true
            ;;
    esac
done

if [ "${STDIN}" = true ] ; then
    # Save stdin to a file so that Gnuplot can read it for multiple
    # plots.
    cat /dev/stdin > "${FILE}"
    trap "rm ${FILE}" EXIT      # Make sure the temp file is deleted
                                # when this script exits.
    PLOT_TITLE="${PLOT_TITLE:-title 'stdin'}"
fi

if [ -z "${PLOTS}" ] ; then
    # Make at least one plot if none are requested.
    PLOTS="'${FILE}' using ${X_COL}${Y_COL} ${STYLE} ${PLOT_TITLE}"
fi

if [ "${DEBUG}" = true ] ; then
    COMMAND=cat
else
    COMMAND=gnuplot
fi

# Generate Gnuplot command and call Gnuplot
"${COMMAND}" <<-EOF
set terminal pngcairo
${CUSTOM}
set datafile separator ','
set output '${OUTPUT}'
set title '${TITLE}'
${TITLE_MATH}
${KEY_LOC}
${HEADER}
set xlabel '${X_LABEL}'
set ylabel '${Y_LABEL}'

plot ${RANGE} ${PLOTS}
EOF

if [ "${DEBUG}" = true ] ; then
    cat "${FILE}"
fi

tail -f gdb.log | awk '/PC =/ { sub(",", "", $3); print $3; system("grep-C3 ^" tolower($3) ": ~/path/to/code.S") }'

#!/bin/bash

WORD="${1:-echo}"
WORD="${WORD,,}"
echo "${WORD^^}   ${WORD^}    ${WORD}     ${WORD: -3}      ${WORD: -1}"

SRCS=$(wildcard *.c)        # Find all the .c files in this directory.
BINS=$(SRCS:.c=)            # Make binaries for them all.
ASMS=$(SRCS:.c=.s)          # Output assembly code for them.
PRES=$(SRCS:.c=.i)          # Save the pre-processor output.


# Set these as environment variables before running make if you want
# to override these defaults:
CC?=gcc
OPT?=-O3

CFLAGS=-Wall -Wpedantic
CFLAGS+=$(OPT)

LIBS=-lm


all: $(BINS) $(ASMS) $(PRES)
bin: $(BINS)
asm: $(ASMS)
pre: $(PRES)


# Make the binary.
%: %.c
        $(CC) $(CFLAGS) -o $@ $< $(LIBS)

# Make the assembly output.
%.s: %.c
        $(CC) $(CFLAGS) -S -fverbose-asm -o $@ $< $(LIBS)

# Make the preprocessor output.
%.i: %.c
        $(CC) $(CFLAGS) -E -o $@ $< $(LIBS)


.PHONY: clean
clean:
        rm -f $(BINS) $(ASMS) $(PRES)

#include <stdio.h>

int main(int argc, char **argv) {
    for (int i = 0; i < argc; i++) {
        printf("%s\n", argv[i]);
    }
}

#include <stdio.h>
#include <stdint.h>

int main(int argc, char **argv) {
    int8_t max = INT8_MAX;
    printf("max:   % 4d\n", max);

    int8_t max_incr = max + 1;
    printf("max+1: % 4d\n", max_incr);

    int8_t min = INT8_MIN;
    printf("min:   % 4d\n", min);
}

#!/bin/bash

GLIBC_TUNABLES=glibc.rtld.execstack=2 $(dirname "$0")/bin/jconsole "$@"

#!/bin/bash

# Quick and dirty script to find all finite field orders less than a
# given number.
# See https://oeis.org/A000961 and https://oeis.org/A246655.

limit=${1:-1000}

echo "q = p^m"

gf_count=0

while read line ; do
    factors=$(echo $line | cut -d: -f2)
    num_uniq_factors=$(echo $factors | tr ' ' '\n' | uniq | wc -w)
    if [ $num_uniq_factors = 1 ] ; then
        ((gf_count++))
        i=$(echo $line | cut -d: -f1)
        base=$(echo $factors | cut -d ' ' -f1)
        power=$(echo $factors | wc -w)
        echo "${i} = ${base}^${power}"
    fi
done < <(seq "$limit" | factor)

gf_percent=$(echo "2k 100 ${gf_count} * ${limit} / p" | dc)
echo -n "${gf_count} Galois fields of order less than or equal to ${limit} "
echo "(${gf_percent}%)."

#!/usr/bin/awk -f

# Copyright (C) 2024 Remington Furman
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

# This prints running statistics for a single input variable.
#
# It implements the Welford algorithm as described by:
# https://www.johndcook.com/blog/standard_deviation/
#
# It also calculates the root-mean-square (RMS) of the input.

BEGIN {OFS=", ";        print  "n, x, sum, mean, var, stddev, rms"}
function print_stats() {print NR, $1, sum, currM, var, sqrt(var), sqrt(sum2/NR)}

NR==1 {
    sum = prevM = currM = $1
    sum2 = $1 * $1
    var = prevS = 0.0
    print_stats()
}

NR!=1 {
    sum  += $1
    sum2 += $1 * $1
    currM = prevM + ($1 - prevM)/NR
    currS = prevS + ($1 - prevM)*($1 - currM)
    prevM = currM
    prevS = currS
    var   = currS/(NR-1)
    print_stats()
}

for i in {1..100} ; do echo $RANDOM ; done > rand.txt
gawk -v OFMT="%.16g" -f ./stats.awk rand.txt > rand_stats.csv

BEGIN {
    letter_val["e"] = 2
    letter_val["s"] = 3
    letter_val["i"] = 5
    letter_val["a"] = 7
    letter_val["r"] = 11
    letter_val["n"] = 13
    letter_val["t"] = 17
    letter_val["o"] = 19
    letter_val["l"] = 23
    letter_val["c"] = 29
    letter_val["d"] = 31
    letter_val["u"] = 37
    letter_val["g"] = 41
    letter_val["p"] = 43
    letter_val["m"] = 47
    letter_val["h"] = 53
    letter_val["b"] = 59
    letter_val["y"] = 61
    letter_val["f"] = 67
    letter_val["v"] = 71
    letter_val["k"] = 73
    letter_val["w"] = 79
    letter_val["z"] = 83
    letter_val["x"] = 89
    letter_val["j"] = 97
    letter_val["q"] = 101
}

# Get the prime values for each letter.
@include "letter_values.awk"

# Multiply the prime values for each letter in a word.
function word_val(word) {
    len = split(word, letters, "")
    val = 1
    for (i=1; i <= len; i++) {
        val *= letter_val[letters[i]]
    }
    return val
}

# Store the word values for each input word in a hash table.
{
    val = word_val($0)
    words[val] = words[val] ? words[val] " " $0 : $0
    print val, words[val]
}

# Look up anagrams for words based on their prime factorization value.
# This requires a .pma file with words and word_val defined.
{ print $0 " -> " words[word_val($0)] }

#!/usr/bin/awk -f

function bm_normal_rect(z,    u1, u2, r) {
    do { u1 = rand() } while (u1 == 0.0)  # Avoid log(0).
    u2 = rand()
    r = sqrt(-2.0 * log(u1))
    z[0] = r * cos(tau * u2)
    z[1] = r * sin(tau * u2)
}

function bm_normal_polar(z,    u1, u2, s, r) {
    do {
        u1 = (rand() * 2.0) - 1.0
        u2 = (rand() * 2.0) - 1.0
        s  = u1*u1 + u2*u2
    } while (s > 1)

    if (s == 0.0) {
        z[0] = z[1] = 0.0  # Avoid division by zero.
    } else {
        r = sqrt(-2.0 * log(s) / s)
        z[0] = u1 * r
        z[1] = u2 * r
    }
}

BEGIN {
    pi = atan2(0, -1)
    tau = 2.0*pi

    delete z[0]  # Make an empty array for the return values.
    while (1) {
        bm_normal_rect(z)              # Faster.
        # bm_normal_polar(z)           # Slower.
        printf "%a\n%a\n", z[0], z[1]  # Hexadecimal float notation, faster
        # printf "%.17e\n%.17e\n", z[0], z[1]  # Round-trip decimal precision
    }
    exit
}

./box_muller.awk | head -n 10000 | ~/tools/gp_wrap/gp_wrap.sh -t " AGWN" -p -w agwn.png