theoknock

import SwiftUI
import Speech
import AVFoundation
import Combine
import Observation

@Observable
class SpeechRecognizer {
	var transcription: String = ""
	var isTranscribing: Bool = false

theoknock

import CoreFoundation
import Foundation

var a = 3
var b = 7
var c = 5
var d = 10

func measureTime(for expression: () -> Void, iterations: Int) -> Double {
	var totalTime: CFAbsoluteTime = 0

theoknock

sudo pico ~/scripts/connect_hotspot.applescript

sudo pico ~/scripts/connect_hotspot.zsh
chmod +x ~/scripts / connect_hotspot.zsh

sudo pico ~/Library/LaunchAgents/com.user.connecthotspot.plist

networksetup -listallnetworkservices

tail -f ~/connect_hotspot.log

theoknock

import Foundation

typealias PredicateFunction = (UInt) -> UInt
typealias PredicateFunctionPointer = UnsafeMutablePointer<PredicateFunction>

let swapPointers: () -> Void = {
	var funcA: PredicateFunction = { predicate in
		print("funcA returned", terminator: " ")
		return predicate
	}

theoknock

import Foundation
import SwiftUI
import Combine
import Observation

struct ContentView: View {
	@State private var randoms: LatticeCircularDistributor = LatticeCircularDistributor(boundLower: 0.3125, boundUpper: 0.3125, threshholdLeft: 0.25, threshholdRight: 0.25)
	var body: some View {
		Spacer()
		VStack {

theoknock

/*
A circular distribution or polar distribution is a probability distribution of a random variable whose values are angles, usually taken to be in the range [0, 2π). A circular distribution is often a continuous probability distribution, and hence has a probability density, but such distributions can also be discrete, in which case they are called circular lattice distributions. Circular distributions can be used even when the variables concerned are not explicitly angles: the main consideration is that there is not usually any real distinction between events occurring at the opposite ends of the range, and the division of the range could notionally be made at any point.
*/

// https://en.wikipedia.org/wiki/Circular_distribution

import SwiftUI

func scale(oldMin: Double, oldMax: Double, value: Double, newMin: Double, newMax: Double) -> Double {
	return ((value - oldMin) / (oldMax - oldMin)) * (newMax - newMin) + newMin

theoknock

let n = vDSP_Length(88200)
let stride = vDSP_Stride(1)

var a: Float32 = 0.0
var b: Float32 = 1.0

var c = [Float32](repeating: 0,
                  count: Int(vDSP_Length(88200)))
vDSP_vgen(&a,
          &b,

theoknock

import SwiftUI

struct ContentView: View {
    @State private var selectedFontName: String = "Times New Roman"
    @State private var isPresented: Bool = true
    
    
    var body: some View {
        VStack {
            FontSelectorView(selectedFontName: $selectedFontName)

theoknock

import SwiftUI

func scale(oldMin: Double, oldMax: Double, value: Double, newMin: Double, newMax: Double) -> Double {
	return ((value - oldMin) / (oldMax - oldMin)) * (newMax - newMin) + newMin
}

struct ContentView: View {
	@State private var firstAngles: [Double] = []
	@State private var secondAngles: [Double] = []
	@State private var minusThresholdAngles: [Double] = []

theoknock

import MetalKit

class MetalSineWaveGenerator {
    let device: MTLDevice
    let commandQueue: MTLCommandQueue
    let computePipelineState: MTLComputePipelineState
    let arraySize: Int
    let frequency: Float
    let sampleRate: Float
    let resultBuffer: MTLBuffer