techgeek1

#!/bin/bash

# --- Packages ---

# NOTE: I've noticed some issues where installs may fail if rapidly queued, to prevent this
#       an artificial delay is inserted since this seems to make the behavior much more
#       predictable

# Some operations seem to fail if time is not given for the system to do some kind of 
# processing under the hood, so we insert artificial delays to help the process along 

techgeek1

Techgeek1's Links

General Topics

General computer science topics applicable to any subdomain.

Algorithms

• Radix Sort Revisited

Data Structures

• The Slot Map Data Structure

techgeek1

/// AVX implementation of the Harley-Seal algorithm for counting the number of bits in a bitset
/// 
/// # Safety
/// Assumes that the input is `BITSET_SIZE_IN_WORDS` in length 
pub unsafe fn cardinality(bitset: &[u64]) -> usize {
    debug_assert!(bitset.len() == BITSET_SIZE_IN_WORDS);
    
    let d = bitset.as_ptr() as *const Register;

techgeek1

use std::cell::Cell;

/// A thunk used for lazy generation and caching of values
struct Thunk<T: Copy> {
    /// Cached value stored in the thunk
    value: Cell<Option<T>>,
    
    /// Generator function to generate a missing value
    generator: fn() -> T
}

techgeek1

const COUNT: i32 = 500_000;
const BLOCK_SIZE: i32 = 1024;

fn main() {
    let mut count = COUNT;
    
    let mut block_count = 0;
    let mut layer_count = 1;
    while count > BLOCK_SIZE {
        let blocks = (count as f32 / (BLOCK_SIZE as f32)).ceil() as i32;

techgeek1

extern crate rand; // 0.5.5

use std::default::Default;
use rand;

macro_rules! declare_components {
    ($($name:ident),*) => {
        $(
            struct $name {
                pub value: i32

techgeek1

#![feature(const_fn, const_type_id)]

 #[macro_use]
mod macros {
    macro_rules! foreach_permutation {
        ($action:ident!(), $type:ident) => {
            $action!($type);
        };
        ($action:ident!(), $type_lead:ident, $($type:ident),*) => {
            $action!($type_lead, $($type),*);

techgeek1

use std::any::TypeId;

macro_rules! depends_on {
    ($($type:ty),*) => {
        fn dependencies(&self) -> &'static [TypeId] {
            $(<$type as System>::__assert_is_system();)*
        
            &[$(TypeId::of::<$type>()),*]
        }
    }

techgeek1

# =============== #
# Unity generated #
# =============== #
[Tt]emp/
[Oo]bj/
/[Bb]uild/
/[Ll]ibrary/

# ======================================== #
# Visual Studio / Android Studio generated #

techgeek1

# Audio
*.wav filter=lfs diff=lfs merge=lfs -text
*.mp3 filter=lfs diff=lfs merge=lfs -text

# Models
*.obj filter=lfs diff=lfs merge=lfs -text
*.dae filter=lfs diff=lfs merge=lfs -text
*.fbx filter=lfs diff=lfs merge=lfs -text
*.mat filter=lfs diff=lfs merge=lfs -text