Algorithmic Patterns Skill for Claude

Algorithmic Patterns for AEC Design

1. Nature-Inspired Computation in AEC

Why Biological Algorithms Matter for Design

For three and a half billion years, evolution has solved the optimization problems architects and engineers face daily: distributing material efficiently, creating structures that resist loads with minimal mass, organizing circulation for millions of agents, regulating temperature without mechanical systems, and generating complex forms from simple rules. Nature-inspired computation translates these solutions into programmable algorithms that transform AEC practice.

The fundamental insight is that complexity does not require complex instructions. A fern frond with thousands of precisely placed leaflets emerges from a recursive rule fitting in a single line of code. A termite mound maintaining two-degree temperature stability is built by agents following three local rules. An oak tree optimally distributing material to resist wind has no central controller -- it grows according to Wolff's law, depositing material where stress is highest.

Emergence and Self-Organization

Emergence produces macro-scale patterns from micro-scale interactions without centralized control. In AEC, this challenges conventional top-down design, replacing it with local rules and boundary conditions that self-organize into coherent spatial configurations.

Key properties of emergent systems:

• Nonlinearity -- small changes in rules produce disproportionate changes in output
• Feedback loops -- positive feedback amplifies patterns, negative feedback stabilizes them
• Decentralization -- no single agent has global knowledge of the system
• Adaptation -- the system responds to environmental changes in real time
• Robustness -- local failures do not cascade to system-level collapse

The computational thesis underlying all algorithmic patterns is that irreducible complexity can emerge from reducible rules. Stephen Wolfram demonstrated this with elementary cellular automata: Rule 110, defined by 8 binary transitions, is Turing-complete. A one-dimensional grid of cells with two states and nearest-neighbor rules can compute anything computable. For AEC: a branching structure with thousands of unique members can be specified by 3-4 L-system rules; a facade with apparent randomness generated by a 2-state CA; an optimal circulation network by 10,000 agents following 3 flocking rules.

| Aspect | Top-Down (Traditional) | Bottom-Up (Algorithmic) |

|--------|----------------------|------------------------|

| Control | Centralized | Distributed |

| Specification | Global geometry | Local rules |

| Adaptability | Low (manual redesign) | High (rules adapt) |

| Scalability | Difficult | Inherent |

| Novelty | Limited by imagination | Generates unexpected solutions |

Applications Across AEC

| Domain | Algorithm Class | Application |

|--------|----------------|-------------|

| Urban growth | Cellular automata, ABM | Land use simulation, sprawl prediction |

| Structural branching | L-systems, space colonization | Tree columns, dendritic roofs |

| Facade patterning | Reaction-diffusion, CA | Perforated screens, shading panels |

| Space planning | Agent-based, packing | Room layout, furniture arrangement |

| Material distribution | Topology optimization, DLA | Graded density structures |

| Circulation design | Ant colony, shortest path | Corridor networks, staircase placement |

| Acoustic design | Reaction-diffusion, fractal | Diffuser panel geometry |

| Thermal design | Swarm optimization | Ventilation opening placement |

2. L-Systems (Lindenmayer Systems)

Formal Grammar

An L-system is a parallel rewriting system G = (V, w, P) where V is the alphabet, w is the axiom (initial string), and P is the production rules. Unlike Chomsky grammars, all rules apply simultaneously, modeling biological growth where cells divide concurrently.

DOL-Systems (Deterministic, Context-Free)

Each variable has exactly one production rule; rules are context-independent.

Algae (Lindenmayer's original): Alphabet: {A,B} | Axiom: A | Rules: A->AB, B->A

String length follows the Fibonacci sequence: A, AB, ABA, ABAAB, ABAABABA.

Koch Curve: Axiom: F | Rule: F->F+F-F-F+F | Angle: 90deg

Fractal dimension log(5)/log(3) = 1.465.

Sierpinski Triangle: Axiom: F-G-G | Rules: F->F-G+F+G-F, G->GG | Angle: 120deg

Dragon Curve: Axiom: FX | Rules: X->X+YF+, Y->-FX-Y | Angle: 90deg

Hilbert Curve: Axiom: A | Rules: A->-BF+AFA+FB-, B->+AF-BFB-FA+ | Angle: 90deg

Stochastic L-Systems

Multiple rules per predecessor with probabilities summing to 1:

F -> F[+F]F[-F]F    (p=0.33)
F -> F[+F]F          (p=0.33)
F -> FF-[-F+F+F]+[+F-F-F]  (p=0.34)

No two generated trees are identical, yet all share the same structural grammar. Critical for facades with varied but coherent panel geometries.

Context-Sensitive L-Systems

Rules depend on adjacent symbols: A < B > C -> D (B becomes D only between A and C). AEC application: signal propagation along structural members -- stress information triggers material deposition only where neighbors indicate high stress.

Parametric L-Systems

Symbols carry numerical parameters with guard conditions:

A(l,w) : l > 0.1 -> F(l) [+(30) A(l*0.7, w*0.8)] [-(30) A(l*0.7, w*0.8)]
A(l,w) : l <= 0.1 -> (terminal leaf)

Parameters 0.7 and 0.8 control child-to-parent ratios, mapping directly to Murray's law for biological branching.

Turtle Interpretation

| Symbol | Action | Symbol | Action |

|--------|--------|--------|--------|

| F | Move forward, draw line | [ | Push state (branch start) |

| f | Move forward, no draw | ] | Pop state (branch end) |

| +/- | Turn left/right by delta | &/^ | Pitch down/up (3D) |

| \// | Roll left/right (3D) | ! | Decrement diameter |

Extended Grammars

Binary Tree (2D):

Axiom: 0
Rules: 1 -> 11, 0 -> 1[+0]-0
Angle: 45 degrees, Iterations: 7

Produces a symmetric binary tree with 128 terminal branches.

Stochastic Shrub:

Axiom: F
Rules: F -> FF+[+F-F-F]-[-F+F+F] (p=0.5), F -> FF-[-F+F]+[+F-F] (p=0.5)
Angle: 22.5 degrees, Iterations: 4

3D Tree (with pitch and roll):

A -> F(1)[&(30)B][/(120)&(30)B][/(240)&(30)B]
B -> F(0.8)[+(25)$C][--(25)$C]B
C -> F(0.5)[+(20)$C][--(20)$C]

City Block Generator:

X -> F[-X][+X]FX | F -> FF
Angle: 90 degrees

Generates recursive block subdivision resembling organic street networks.

Column Capital (parametric, 3D):

A(h,r) -> F(h,r) [+(60)&(40) B(h*0.3,r*0.6)] [+(180)&(40) B(h*0.3,r*0.6)] [+(300)&(40) B(h*0.3,r*0.6)]
B(h,r) : h > 0.05 -> F(h,r) [+(45)&(30) B(h*0.5,r*0.7)] [-(45)&(30) B(h*0.5,r*0.7)]

AEC Applications

Branching Structures: Tree-columns in airports and stations (Stuttgart Airport, Sendai Mediatheque). A 5-rule L-system defines a column branching into 200+ terminal supports for a roof canopy.

Root-Like Foundations: Inverted L-system trees distributing loads through soil following optimized branching angles per Murray's law.

Dendritic Circulation: Corridor systems following L-system branching produce naturally navigable spaces with clear hierarchy.

Fractal Facades: Koch-curve-based facades provide increased surface area for shading while maintaining structural regularity.

Implementation

Python:

def l_system(axiom, rules, iterations):
    current = axiom
    for _ in range(iterations):
        current = "".join(rules.get(c, c) for c in current)
    return current

Grasshopper: String rewriting via text components, Anemone loop for iterations, turtle geometry components for line/curve generation, pipe/mesh for 3D visualization.

3. Cellular Automata (CA)

1D Elementary CA (Wolfram's 256 Rules)

A row of binary cells; next state depends on 3-cell neighborhood (8 configurations, 2^8 = 256 rules).

Rule 30 (chaotic): Aperiodic, seemingly random from a single cell. Found on Conus textile shell.

Rule 90 (Sierpinski): XOR of neighbors. Perfect for facade patterning -- regularity with complexity.

Rule 110 (Turing-complete): Proved by Cook (2004). Generates gliders and spaceships. The simplest known universal computer.

2D Cellular Automata

Game of Life (B3/S23): Dead cell with 3 neighbors is born; alive cell with 2-3 survives; all others die. Produces gliders, oscillators, guns, and self-replicating patterns.

Urban Growth (B3678/S2345678): Compact blob growth mimicking suburban sprawl. Adjusting to B45/S2345 produces polycentric growth.

Floor Plan Generator (B3/S1234): From random initial conditions, produces room-like enclosed spaces connected by narrow passages.

Neighborhoods

Von Neumann (4): Orthogonal patterns for rectilinear layouts. Moore (8): Organic, rounded patterns; standard for most 2D CA. Extended Moore (24, radius 2): Smoother boundaries for urban simulation. Hexagonal (6): Isotropic, no directional bias.

State Transitions and Multi-State CA

Binary (0/1): Simplest case -- cell is active or inactive.

Multi-state (0-N): Enables gradient effects and functional zoning:

• State 0: empty / undeveloped
• State 1: residential low-density
• State 2: residential high-density
• State 3: commercial
• State 4: industrial
• State 5: park / green space

Transition rules encode zoning logic: residential adjacent to 3+ commercial cells transitions to mixed-use. Green space cells never transition (protected). Totalistic CA depends only on the sum of neighbor states; outer-totalistic (like Game of Life) depends on center state AND neighbor sum but not arrangement.

3D Cellular Automata

Cubic lattice with 6 (von Neumann), 18 (edge-sharing), or 26 (Moore) neighbors.

Structural topology application:

States: solid (1), void (0)
Initial: solid block
Rules: Death: solid cell with < 4 solid Moore-26 neighbors -> void
       Birth: void cell with 8-12 solid neighbors -> solid

Produces porous, trabecular bone-like structures exportable as mesh for 3D printing or CNC fabrication.

AEC Applications

Urban Growth Simulation: SLEUTH/DUEM models simulate decades of land-use change for infrastructure planning.

Structural Topology: Voxel rules remove low-stress material, approximating optimal distributions.

Facade Patterns: CA grid mapped to facade; cell states determine panel type. Rule 90 produces Sierpinski; Game of Life produces organic patterns.

Python:

import numpy as np
from scipy.signal import convolve2d
def gol_step(grid):
    n = convolve2d(grid, np.array([[1,1,1],[1,0,1],[1,1,1]]), mode='same', boundary='wrap')
    return ((grid==0) & (n==3) | (grid==1) & ((n==2)|(n==3))).astype(int)

4. Agent-Based Modeling (ABM)

Agent Architecture

An agent has: position (x,y,z), velocity, state variables (energy, type, memory), behavioral rules executed each timestep, perception radius, and communication mode (direct messaging or stigmergy).

Environments: Grid-based (simple collision, coarse simulations), continuous (realistic pedestrian/vehicle movement, requires KDTree spatial indexing), network-based (agents move along graph edges for transit simulation).

Stigmergy

Indirect communication through environment modification. Agents deposit pheromone; it diffuses (Gaussian blur) and evaporates: P(t+1) = P(t) * (1 - rho). Others sense gradients and bias movement toward high concentrations. This is how ant colonies find shortest paths -- and how pedestrians create desire lines.

Flocking (Reynolds Boids)

Three rules applied each timestep:

• Separation: force = sum((self.pos - neighbor.pos) / dist^2) within separation_radius
• Alignment: force = avg(neighbor.velocity) - self.velocity within alignment_radius
• Cohesion: force = centroid(neighbors) - self.pos within cohesion_radius

Combined: velocity += w1*sep + w2*ali + w3*coh; clamp(velocity, max_speed); pos += velocity*dt

High w1 = dispersed; high w2 = parallel streams; high w3 = tight swarms; balanced = natural flocking.

Ant Colony Optimization (ACO)

Path selection: P(i->j) = (tau_ij^alpha * eta_ij^beta) / sum(tau_ik^alpha * eta_ik^beta) where tau = pheromone, eta = 1/distance. Pheromone update: tau = (1-rho)*tau + Q/L_k for ants using edge.

AEC: Hospital corridor layout optimization. Nodes = rooms (ER, ICU, pharmacy). ACO minimizes total daily staff travel distance, producing a connectivity graph that informs spatial adjacency.

Termite Mound Algorithms

Stigmergic construction: deposit material where pheromone is high; deposits emit pheromone; positive feedback creates pillars, arches, chambers. Translates to robotic construction agents building without centralized control.

AEC Applications

Pedestrian Flow: Thousands of agents navigating stations/malls; identify bottlenecks, optimize door placement.

Evacuation: Social force model (Helbing) validates egress timeframes with body-compression physics.

Urban Morphogenesis: Developer/resident agents produce clustering, segregation, gentrification from individual decisions.

Structural Placement: Agents walking force-flow lines deposit material at convergences, reflecting principal stress trajectories.

Adaptive Facades: Each panel is an agent with sensors/actuators, coordinating shading with neighbors.

Tools: Quelea (Grasshopper real-time ABM), NetLogo (visual ABM platform), Mesa (Python framework integrating with compas/ladybug/honeybee).

5. Swarm Intelligence

Particle Swarm Optimization (PSO)

v_i = w*v_i + c1*r1*(p_i - x_i) + c2*r2*(g - x_i)
x_i = x_i + v_i

w (inertia): 0.9 -> 0.4 over iterations. c1, c2 (cognitive/social): typically 2.0. r1, r2: random [0,1].

AEC: Optimize building orientation, WWR, shading angles via EnergyPlus fitness function. Converges in 50-200 iterations.

ACO Pheromone Strategies

Ant System: All ants deposit; simple but slow. Ant Colony System: Best-ant-only with local decay; faster convergence. MAX-MIN: Bounded pheromone prevents premature convergence.

AEC: Pipe routing through ceiling cavities minimizing length while avoiding structural members.

Bee Algorithm

Scout bees (random global search), employed bees (local exploitation), onlooker bees (quality-weighted roulette selection). Abandoned food sources trigger scouting.

AEC: Multi-objective optimization balancing energy performance, structural efficiency, daylight, and cost.

Firefly Algorithm

Attractiveness: beta(r) = beta_0 * exp(-gamma*r^2). Brighter fireflies attract dimmer ones; distance-dependent attraction clusters solutions around promising regions.

AEC: Structural member sizing -- each firefly is a set of beam/column cross-sections; brightness = low weight satisfying constraints.

| Criterion | PSO | ACO | Bee | Firefly |

|-----------|-----|-----|-----|---------|

| Continuous variables | Excellent | Poor | Good | Good |

| Discrete/combinatorial | Poor | Excellent | Good | Fair |

| Multi-objective | Fair | Fair | Good | Fair |

| Convergence speed | Fast | Moderate | Moderate | Slow |

| Best AEC use | Parametric opt. | Routing/layout | Multi-objective | Sizing opt. |

6. Reaction-Diffusion

Turing Patterns

Two morphogens -- activator (slow diffusion, self-promoting) and inhibitor (fast diffusion, activator-suppressing) -- produce stable spatial patterns via short-range activation / long-range inhibition: spots, stripes, labyrinths, inverse spots. Found throughout biology: leopard spots, zebra stripes, seashell markings, fingerprints.

Gray-Scott Model

du/dt = Du*laplacian(u) - u*v^2 + f*(1-u)
dv/dt = Dv*laplacian(v) + u*v^2 - (f+k)*v

Typical: Du=0.16, Dv=0.08. The (f,k) parameter space maps to distinct regimes:

| f | k | Pattern Type |

|---|---|-------------|

| 0.010 | 0.045 | Spots (mitosis) |

| 0.022 | 0.051 | Spots and stripes |

| 0.030 | 0.057 | Stripes / labyrinthine |

| 0.040 | 0.063 | Worms / meandering |

| 0.050 | 0.065 | Holes (inverse spots) |

| 0.025 | 0.060 | Solitons (isolated spots) |

| 0.014 | 0.054 | Pulsating spots |

Belousov-Zhabotinsky Patterns

Chemical reaction producing concentric target waves and spiral waves. Modeled by Oregonator equations. AEC: spiral/concentric patterns for acoustic diffusers breaking up sound reflections.

AEC Applications

Facade Patterning: Concentration field drives perforation density -- dense shading where solar gain is highest, open where views are prioritized.

Structural Porosity: 3D reaction-diffusion determines solid/void in 3D-printed elements, lighter than solid while maintaining load paths.

Ventilation: Opening density correlates with local wind pressure via tuned diffusion parameters.

Acoustic Diffusers: Labyrinthine patterns achieve broadband diffusion without periodicity artifacts.

Implementation

Discretized Laplacian (5-point): L(u,i,j) = u[i+1,j] + u[i-1,j] + u[i,j+1] + u[i,j-1] - 4*u[i,j]

9-point stencil (more isotropic): weight corners 0.05, edges 0.2, center -1.0.

import numpy as np
def gray_scott_step(u, v, f, k, Du=0.16, Dv=0.08, dt=1.0):
    Lu = np.roll(u,1,0)+np.roll(u,-1,0)+np.roll(u,1,1)+np.roll(u,-1,1) - 4*u
    Lv = np.roll(v,1,0)+np.roll(v,-1,0)+np.roll(v,1,1)+np.roll(v,-1,1) - 4*v
    uvv = u*v*v
    return np.clip(u+dt*(Du*Lu-uvv+f*(1-u)),0,1), np.clip(v+dt*(Dv*Lv+uvv-(f+k)*v),0,1)

256x256 runs real-time on CPU; 512+ requires GPU (CUDA/WebGL compute shaders).

7. Growth and Packing Algorithms

Diffusion-Limited Aggregation (DLA)

Seed at origin; random walkers perform Brownian motion, sticking permanently on cluster contact. Fractal dimension ~1.71 (2D). Produces patterns resembling lightning, river deltas, mineral dendrites, frost.

AEC: Branching structural topologies refined by FEA, green infrastructure networks (branching bioswales).

Space Colonization Algorithm

Attraction points fill target volume (canopy envelope). Tree nodes grow toward nearest points; points consumed within kill distance. Parameters: influence distance, kill distance, step length D, point distribution.

AEC: Column-tree structures for large-span roofs with branch density proportional to local load. More natural branching than L-systems for canopy-filling geometries.

Circle/Sphere Packing

Apollonian gasket: Recursive tangent circle insertion (D~1.31). RSA: Random placement rejecting overlaps; jams at ~54.7% coverage. Force-directed: Repulsive forces between overlapping circles iterate to equilibrium, producing dense organic packings.

def force_pack(circles, iterations=1000):
    for _ in range(iterations):
        for i, ci in enumerate(circles):
            force = [0, 0]
            for j, cj in enumerate(circles):
                if i == j: continue
                d = dist(ci, cj); overlap = (ci.r + cj.r) - d
                if overlap > 0:
                    force[0] += overlap * (ci.x-cj.x)/d
                    force[1] += overlap * (ci.y-cj.y)/d
            ci.x += force[0]*0.1; ci.y += force[1]*0.1

AEC: Column placement (circles = tributary areas), window placement on curved facades, bubble diagrams for space planning.

Bin Packing and Graph Algorithms

2D Nesting: Irregular polygons on sheets; NP-hard; bottom-left + NFP heuristics. CNC steel cutting, facade panel nesting. 5-10% efficiency gain = significant cost savings.

Dijkstra: Shortest paths O((V+E)log V) for service routing. A*: Heuristic-guided single-target wayfinding. MST: Minimum-length corridor/utility networks (Kruskal/Prim).

8. Space-Filling and Fractal Geometry

Fractal Dimension

D = log(N)/log(S) for self-similar fractals. Box-counting method: cover pattern with epsilon-boxes, plot log(N) vs. log(1/epsilon); slope = D. Urban analysis: compact cities D~2.0; sprawling cities D~1.3-1.5. Track D over time to quantify sprawl. Skyline D~1.3-1.5 correlates with visual preference.

Iterated Function Systems (IFS)

Contractive affine transformations applied recursively. Barnsley fern: 4 transformations with probabilities (stem p=0.01, leaflets p=0.85, branches p=0.07 each). AEC: decorative screens, tile designs, mullion layouts with parameterized self-similarity.

Space-Filling Curves

Hilbert curve: Visits every point in 2^N x 2^N grid preserving locality. AEC: CNC toolpaths, sensor placement, robotic inspection routes.

Peano curve: 3x3 recursive, denser coverage. Z-Order (Morton): Bit-interleaved 2D-to-1D for spatial database indexing.

Self-Similar Structures and Fractal Architecture

Historical examples of fractal architecture:

• African vernacular settlements: Recursive compound layouts where village plans mirror individual compound plans (Ron Eglash's research)
• Hindu temples: Shikhara towers with recursive self-similar profile
• Gothic cathedrals: Pointed arch motif repeated at window, door, vault, and building scales
• Menger sponge structures: Theoretical 3D fractal (D=log(20)/log(3)=2.727) with infinite surface area and zero volume, informing ultra-lightweight structural concepts

Fractal analysis of cities:

• Street networks: organic medieval cities D~1.8-1.9 vs. grid cities D~2.0 vs. suburban dendritic D~1.3-1.5
• Building footprints: D of built/unbuilt boundary correlates with walkability and urban vitality
• Skyline silhouettes: D~1.3-1.5 correlates with visual preference in perception studies

9. Implementation Guide

Grasshopper Ecosystem

• Anemone: Looping and recursion for iterative algorithms
• Quelea: Real-time agent-based simulation with custom force fields
• Heteroptera: CA and ABM utilities
• 4D Noise: Perlin/simplex noise field generation
• Kangaroo 2: Physics simulation (particle-spring, packing)
• Dendro: Volume/SDF operations for 3D CA output
• Cocoon: Isosurface extraction from scalar fields
• C# scripting: 10-100x faster than GhPython for tight numerical loops

Python Libraries

numpy (array ops, convolution), scipy (KDTree, signal processing), matplotlib (visualization), networkx (graph algorithms), compas (AEC geometry framework), shapely (2D polygon ops), trimesh (3D mesh export).

Performance: Vectorize with numpy (100x over Python loops). scipy.spatial.KDTree for O(log n) agent neighbor queries. Preallocate arrays. GPU via cupy/CUDA for grids > 512x512.

Processing/p5.js for Visualization

Processing (Java): Excellent for real-time interactive visualization. Built-in 2D/3D rendering with straightforward pixel manipulation for CA and RD simulations.

p5.js (JavaScript): Browser-based Processing ideal for client presentations and web demos. WebGL mode enables GPU-accelerated rendering of large simulations. Particularly effective for interactive reaction-diffusion and flocking demonstrations.

Performance Considerations

Grid resolution vs. computation:

• 256x256 RD: real-time on CPU. 1024x1024: requires GPU (CUDA, OpenCL, WebGL compute).
• Doubling grid resolution quadruples memory and computation per step.

Agent scaling:

• ABM: O(N^2) naive -> O(N log N) with spatial hashing/KDTree. Essential for >10,000 agents.

Memory management:

• 3D CA at 256^3: 16M cells, 16 MB/step. 100 timesteps = 1.6 GB. Use sparse representations for low fill ratios.

Convergence:

• L-systems: deterministic, terminate after specified generation count.
• CA/RD: may need thousands of steps to reach steady state. Define convergence threshold (change between steps < epsilon).
• ABM: may never reach equilibrium. Use maximum iteration limits or target metric values.

Algorithm Selection Guide

| Design Goal | Algorithm | Rationale |

|-------------|-----------|-----------|

| Branching structure | L-system / Space Colonization | Controlled recursion with biological analogy |

| Organic facade pattern | Gray-Scott reaction-diffusion | Tunable Turing patterns with density control |

| Regular-complex pattern | CA (Rule 90, Game of Life) | Deterministic complexity from simple rules |

| Pedestrian flow analysis | ABM (boids + social force) | Captures individual decision-making |

| Structural optimization | PSO / topology-optimized CA | Continuous variable optimization |

| Routing optimization | Ant Colony Optimization | Graph-based combinatorial problems |

| Column/support placement | Circle packing, force-directed | Distributes supports with minimum spacing |

| Panel nesting (fabrication) | 2D bin packing, NFP nesting | Minimizes material waste |

| Urban growth prediction | CA (SLEUTH) or ABM | Captures spatial dynamics of development |

| Ventilation openings | Reaction-diffusion | Organic density variation across surface |

| Multi-objective optimization | Bee Algorithm, NSGA-II | Balanced Pareto front exploration |

| Fractal complexity analysis | Box-counting dimension | Quantifies pattern complexity across scales |

References

• Prusinkiewicz, P. & Lindenmayer, A. (1990). *The Algorithmic Beauty of Plants*. Springer.
• Wolfram, S. (2002). *A New Kind of Science*. Wolfram Media.
• Reynolds, C. (1987). "Flocks, Herds, and Schools." SIGGRAPH.
• Turing, A. (1952). "The Chemical Basis of Morphogenesis." Phil. Trans. Royal Society.
• Pearson, J.E. (1993). "Complex Patterns in a Simple System." Science, 261(5118).
• Runions, A. et al. (2007). "Modeling Trees with a Space Colonization Algorithm." Eurographics.
• Shiffman, D. (2012). *The Nature of Code*. Self-published.
• Terzidis, K. (2006). *Algorithmic Architecture*. Architectural Press.
• Hensel, M., Menges, A. & Weinstock, M. (2010). *Emergent Technologies and Design*. Routledge.
• Frazer, J. (1995). *An Evolutionary Architecture*. Architectural Association.
• Coates, P. (2010). *Programming.Architecture*. Routledge.
• Dorigo, M. & Stutzle, T. (2004). *Ant Colony Optimization*. MIT Press.
• Kennedy, J. & Eberhart, R. (1995). "Particle Swarm Optimization." IEEE ICNN.
• Witten, T.A. & Sander, L.M. (1981). "Diffusion-Limited Aggregation." PRL.
• Eglash, R. (1999). *African Fractals*. Rutgers University Press.