RandyMcMillan

use std::env;
use std::process;
use std::io::{self, Write};

enum LogLevel {
    Error,
    Warn,
    Info,
    Debug,
}

RandyMcMillan

use std::collections::HashMap;

fn is_prime(n: i32) -> bool {
    if n <= 1 {
        return false;
    }
    let mut i = 2;
    while i * i <= n {
        if n % i == 0 {
            return false;

RandyMcMillan

use std::collections::HashMap;

fn main() {
    let mut hashmap: HashMap<i32, (i32, i32)> = HashMap::new();

    for count in 0..1000 {
        hashmap.insert(count, (count, count % 13));
    }

    let mut sorted_vec: Vec<(&i32, &(i32, i32))> = hashmap.iter().collect();

RandyMcMillan

fn print_moon_phases() {
    let moon_phases = [
        "🌕🌕🌕🌕🌕🌕🌕🌕🌕🌕🌕🌕",
        "🌕🌕🌕🌒🌕🌖🌒🌕🌕🌕🌕🌕",
        "🌕🌕🌖🌑🌓🌑🌑🌕🌕🌕🌕🌕",
        "🌕🌕🌗🌑🌑🌑🌑🌔🌕🌕🌕🌕",
        "🌕🌕🌘🌙🌑🌙🌑🌔🌖🌑🌕🌕",
        "🌕🌕🌖🌑🌑🌑🌑🌕🌕🌑🌔🌕",
        "🌕🌕🌕🌖🌑🌑🌔🌕🌕🌑🌔🌕",
        "🌕🌕🌕🌘🌑🌑🌒🌕🌕🌑🌔🌕",

RandyMcMillan

fn gamma(n: f64) -> f64 {
    // For simplicity, we'll use a basic approximation method.
    // For higher accuracy, consider using a more sophisticated algorithm or a crate 
    // like `special_function` (if it provides Gamma).

    // We can use integration techniques like the trapezoidal rule or Simpson's rule for approximation.
    // Here's a basic trapezoidal rule example:

    let mut result = 0.0;
    let a = 0.0;

RandyMcMillan

prime_clock
simple_logger
prime_clock.dSYM

RandyMcMillan

use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};

#[derive(Debug, Clone)]
struct HashMap<K, V>
where
    K: Eq + Hash + Clone,
    V: Clone,
{
    // Buckets for storing key-value pairs

RandyMcMillan

use std::fs;
use std::path::Path;

fn main() {
    let input = "/usr/share/doc";

    fn action(path: &str) { println!("\t{}" , path); }

    fn walk(path: &str) {
        println!("Listing {} ..." , path);

RandyMcMillan

use std::any::Any;
use std::fmt::Debug;

fn print_type_name<T: Any + Debug>(value: &T) {
    println!("Type of {:?} is: {}", value, std::any::type_name::<T>());
}

fn main() {
    let i: i32 = 42;
    print_type_name(&i);

RandyMcMillan

use sha2::{Digest, Sha256};

/// Calculates the Hamming distance between two SHA-256 hashes.
///
/// This function takes two byte slices representing SHA-256 hashes and returns 
/// the number of bits that differ between them.
fn hamming_distance_sha256(hash1: &[u8], hash2: &[u8]) -> u32 {
    assert_eq!(hash1.len(), 32, "Invalid hash1 length");
    assert_eq!(hash2.len(), 32, "Invalid hash2 length");