chemacortes

import scala.concurrent.{ExecutionContext, Future}
import scala.collection.mutable.ArrayBuffer

/** Valor exacto a·φ + b con a, b enteros arbitrarios. */
final case class PhiValue(a: BigInt, b: BigInt):
  def +(o: PhiValue): PhiValue = PhiValue(a + o.a, b + o.b)
  def -(o: PhiValue): PhiValue = PhiValue(a - o.a, b - o.b)
  def isZero: Boolean = a == 0 && b == 0

object PhiMath:

chemacortes

import java.util.concurrent.ConcurrentHashMap
import scala.math.BigInt

object Phinary:
  private val Zero = BigInt(0)
  private val One  = BigInt(1)
  private val Two  = BigInt(2)
  private val Five = BigInt(5)

  // Caché thread-safe optimizada. Usamos inserciones puras para

chemacortes

import scala.concurrent.{Future, Await}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration.*
import scala.math.BigInt
import scala.collection.concurrent.TrieMap

object Phinary:

  // ---------- Caché concurrente de Fibonacci ----------
  private val fibCache = TrieMap[Int, BigInt](

chemacortes

Sistema phinario (base $\phi$), un fascinante sistema de numeración con base irracional concebido originalmente por el matemático George Bergman en 1957. [^1][^2] En este sistema, la base es el número áureo ($\phi \approx 1.61803...$), y sorprendentemente, cualquier número natural se puede escribir de forma exacta utilizando únicamente los dígitos 0 y 1. [^2][^3]

---

La propiedad fundamental de la Base $\phi$

Este sistema se basa en la propiedad algebraica de la proporción divina: $$\phi^2 = \phi + 1$$ Si trasladamos esto a un sistema de valor posicional (como el binario o decimal), significa que tener las potencias $\phi^1$ y $\phi^0$ consecutivas es exactamente lo mismo que tener una potencia $\phi^2$.

chemacortes

def fib(n: Long): BigInt = {
  def loop(n: Long): (BigInt, BigInt) =
    if (n == 0) (0, 1)
    else {
      val (a, b) = loop(n / 2)
      val c = a * (2 * b - a)
      val d = a * a + b * b

      if ((n & 1) == 0) (c, d)
      else (d, c + d)

chemacortes

import java.security.MessageDigest

def sha1(text: String): String =
  val bytes = text.getBytes("UTF-8")
  MessageDigest
    .getInstance("SHA-1")
    .digest(bytes)
    .map("%02x".format(_))
    .mkString

chemacortes

#!/bin/env python 

import requests
import sys

if len(sys.argv) != 2:
    print("Falta 1 argumento de entrada")
    sys.exit(1)

arg = sys.argv[1]

chemacortes

Awesome Stars

A curated list of my GitHub stars! Generated by starred.

Contents

• Batchfile
• C
• C++

chemacortes

¡Excelente iniciativa! Usar Scala 3, con su potente sistema de tipos (incluyendo traits, intersection types, extension methods, context functions y given/using), es una forma muy elegante y rigurosa de formalizar conceptos algebraicos. El enfoque de "type classes" encaja perfectamente aquí.

El repositorio que mencionas parece un buen punto de partida, probablemente definiendo estructuras básicas como Semigrupos, Monoides y Grupos. Para continuar y definir estructuras más complejas como los anillos, seguirías construyendo sobre esas bases.

Cómo Continuar - Pasos Generales:

1. Jerarquía de Traits: Define cada estructura algebraica como un trait. Las estructuras más complejas heredarán (extends) de las más simples. Por ejemplo, un Ring extenderá (de alguna forma) las propiedades de un AbelianGroup (para la suma) y un Monoid (para la multiplicación).
2. Métodos y Operadores: Usa extension methods dentro de los traits para definir las operaciones binarias (+, *) y unarias (-) de

chemacortes

def benchmarks[A](f: => A) =
  inline def memory() = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()

  val t0 = System.nanoTime()
  val m0 = memory()

  val ret = f
  val t1 = System.nanoTime()
  val m1 = memory()