├── .gitignore
├── force-field
    ├── c++
    │   ├── Makefile
    │   ├── main.cpp
    │   ├── particle.hpp
    │   └── vector.hpp
    ├── swift
    │   ├── a.out
    │   └── force-field
    │   │   ├── force-field.xcodeproj
    │   │       ├── project.xcworkspace
    │   │       │   ├── contents.xcworkspacedata
    │   │       │   ├── xcuserdata
    │   │       │   │   └── alex.xcuserdatad
    │   │       │   │   │   └── UserInterfaceState.xcuserstate
    │   │       │   └── xcshareddata
    │   │       │   │   └── force-field.xccheckout
    │   │       ├── xcuserdata
    │   │       │   └── alex.xcuserdatad
    │   │       │   │   └── xcschemes
    │   │       │   │       ├── xcschememanagement.plist
    │   │       │   │       └── force-field.xcscheme
    │   │       └── project.pbxproj
    │   │   └── force-field
    │   │       ├── main.swift
    │   │       ├── Particle.swift
    │   │       └── Vector.swift
    ├── python
    │   ├── vector.pyc
    │   ├── particle.pyc
    │   ├── __pycache__
    │   │   ├── vector.cpython-33.pyc
    │   │   └── particle.cpython-33.pyc
    │   ├── main.py
    │   ├── particle.py
    │   └── vector.py
    ├── java
    │   ├── Makefile
    │   ├── Main.java
    │   ├── Particle.java
    │   └── Vector.java
    ├── ruby
    │   ├── main.rb
    │   ├── Vector.rb
    │   └── Particle.rb
    ├── php
    │   ├── main.php
    │   ├── Particle.php
    │   └── Vector.php
    ├── js
    │   ├── main.js
    │   ├── particle.js
    │   └── vector.js
    ├── dart
    │   ├── main.dart
    │   ├── particle.dart
    │   └── vector.dart
    ├── rust
    │   ├── main.rs
    │   ├── particle.rs
    │   └── vector.rs
    ├── cs
    │   ├── Program.cs
    │   ├── Particle.cs
    │   └── Vector.cs
    ├── go
    │   └── main.go
    └── README.md
├── roll-avg
    ├── swift
    │   ├── a.out
    │   ├── note.md
    │   └── rolling-avg
    │   │   ├── rolling-avg.xcodeproj
    │   │       ├── project.xcworkspace
    │   │       │   ├── contents.xcworkspacedata
    │   │       │   ├── xcuserdata
    │   │       │   │   └── alex.xcuserdatad
    │   │       │   │   │   └── UserInterfaceState.xcuserstate
    │   │       │   └── xcshareddata
    │   │       │   │   └── rolling-avg.xccheckout
    │   │       ├── xcuserdata
    │   │       │   └── alex.xcuserdatad
    │   │       │   │   └── xcschemes
    │   │       │   │       ├── xcschememanagement.plist
    │   │       │   │       └── rolling-avg.xcscheme
    │   │       └── project.pbxproj
    │   │   └── rolling-avg
    │   │       └── main.swift
    ├── java
    │   ├── Main.class
    │   └── Main.java
    ├── c
    │   ├── excursion
    │   │   ├── func1.c
    │   │   ├── instructions.md
    │   │   └── long command.txt
    │   ├── note.md
    │   └── main.c
    ├── ruby
    │   └── main.rb
    ├── python
    │   └── main.py
    ├── dart
    │   └── main.dart
    ├── php
    │   └── main.php
    ├── go
    │   └── main.go
    ├── rust
    │   └── main.rs
    ├── js
    │   └── main.js
    ├── cs
    │   └── Program.cs
    └── README.md
├── array-reverse
    ├── swift
    │   ├── a.out
    │   └── array-reverse
    │   │   ├── array-reverse.xcodeproj
    │   │       ├── xcuserdata
    │   │       │   └── alex.xcuserdatad
    │   │       │   │   ├── xcdebugger
    │   │       │   │       └── Breakpoints_v2.xcbkptlist
    │   │       │   │   └── xcschemes
    │   │       │   │       ├── xcschememanagement.plist
    │   │       │   │       └── array-reverse.xcscheme
    │   │       ├── project.xcworkspace
    │   │       │   ├── contents.xcworkspacedata
    │   │       │   ├── xcuserdata
    │   │       │   │   └── alex.xcuserdatad
    │   │       │   │   │   └── UserInterfaceState.xcuserstate
    │   │       │   └── xcshareddata
    │   │       │   │   └── array-reverse.xccheckout
    │   │       └── project.pbxproj
    │   │   └── array-reverse
    │   │       └── main.swift
    ├── java
    │   ├── Main.class
    │   └── Main.java
    ├── ruby
    │   ├── main_builtin.rb
    │   └── main.rb
    ├── php
    │   ├── main-builtin.php
    │   ├── main-user.php
    │   └── note.md
    ├── python
    │   ├── main2_builtin.py
    │   ├── main3_builtin.py
    │   ├── main2.py
    │   └── main3.py
    ├── js
    │   ├── main_builtin.js
    │   └── main.js
    ├── rust
    │   ├── main_builtin.rs
    │   └── main.rs
    ├── go
    │   └── main.go
    ├── dart
    │   └── main.dart
    ├── c
    │   └── main.c
    ├── cs
    │   └── Program.cs
    └── README.md
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | 
3 | 


--------------------------------------------------------------------------------
/force-field/c++/Makefile:
--------------------------------------------------------------------------------
1 | a.out:
2 | 	g++ -O2 -std=c++11 main.cpp
3 | 
4 | clean:
5 | 	rm -rf a.out


--------------------------------------------------------------------------------
/roll-avg/swift/a.out:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/unixpickle/Benchmarks/HEAD/roll-avg/swift/a.out


--------------------------------------------------------------------------------
/roll-avg/swift/note.md:
--------------------------------------------------------------------------------
1 | See the note in the C test ([click here](../c/note.md), if you're on GitHub)


--------------------------------------------------------------------------------
/force-field/swift/a.out:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/unixpickle/Benchmarks/HEAD/force-field/swift/a.out


--------------------------------------------------------------------------------
/array-reverse/swift/a.out:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/unixpickle/Benchmarks/HEAD/array-reverse/swift/a.out


--------------------------------------------------------------------------------
/roll-avg/java/Main.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/unixpickle/Benchmarks/HEAD/roll-avg/java/Main.class


--------------------------------------------------------------------------------
/array-reverse/java/Main.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/unixpickle/Benchmarks/HEAD/array-reverse/java/Main.class


--------------------------------------------------------------------------------
/force-field/python/vector.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/unixpickle/Benchmarks/HEAD/force-field/python/vector.pyc


--------------------------------------------------------------------------------
/force-field/python/particle.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/unixpickle/Benchmarks/HEAD/force-field/python/particle.pyc


--------------------------------------------------------------------------------
/force-field/python/__pycache__/vector.cpython-33.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/unixpickle/Benchmarks/HEAD/force-field/python/__pycache__/vector.cpython-33.pyc


--------------------------------------------------------------------------------
/force-field/python/__pycache__/particle.cpython-33.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/unixpickle/Benchmarks/HEAD/force-field/python/__pycache__/particle.cpython-33.pyc


--------------------------------------------------------------------------------
/roll-avg/c/excursion/func1.c:
--------------------------------------------------------------------------------
1 | unsigned int addUpTo(unsigned int dest) {
2 |   unsigned int sum = 0;
3 |   for (int i = 1; i <= dest; i++) {
4 |     sum += i;
5 |   }
6 |   return sum;
7 | }
8 | 


--------------------------------------------------------------------------------
/array-reverse/swift/array-reverse/array-reverse.xcodeproj/xcuserdata/alex.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <Bucket
3 |    type = "1"
4 |    version = "2.0">
5 | </Bucket>
6 | 


--------------------------------------------------------------------------------
/force-field/java/Makefile:
--------------------------------------------------------------------------------
 1 | Main.class: Particle.class Vector.class
 2 | 	javac Main.java
 3 | 
 4 | Particle.class: Vector.class
 5 | 	javac Particle.java
 6 | 
 7 | Vector.class:
 8 | 	javac Vector.java
 9 | 
10 | clean:
11 | 	rm -rf Vector.class Particle.class Main.class


--------------------------------------------------------------------------------
/roll-avg/swift/rolling-avg/rolling-avg.xcodeproj/project.xcworkspace/contents.xcworkspacedata:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <Workspace
3 |    version = "1.0">
4 |    <FileRef
5 |       location = "self:rolling-avg.xcodeproj">
6 |    </FileRef>
7 | </Workspace>
8 | 


--------------------------------------------------------------------------------
/force-field/swift/force-field/force-field.xcodeproj/project.xcworkspace/contents.xcworkspacedata:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <Workspace
3 |    version = "1.0">
4 |    <FileRef
5 |       location = "self:force-field.xcodeproj">
6 |    </FileRef>
7 | </Workspace>
8 | 


--------------------------------------------------------------------------------
/array-reverse/ruby/main_builtin.rb:
--------------------------------------------------------------------------------
 1 | if ARGV.length != 2
 2 |   puts 'Usage: ruby main.rb <size> <iterations>'
 3 |   exit 1
 4 | end
 5 | 
 6 | size = ARGV[0].to_i
 7 | iterations = ARGV[1].to_i
 8 | 
 9 | list = (0...size).to_a
10 | 
11 | iterations.times do
12 |   list.reverse!
13 | end


--------------------------------------------------------------------------------
/array-reverse/swift/array-reverse/array-reverse.xcodeproj/project.xcworkspace/contents.xcworkspacedata:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <Workspace
3 |    version = "1.0">
4 |    <FileRef
5 |       location = "self:array-reverse.xcodeproj">
6 |    </FileRef>
7 | </Workspace>
8 | 


--------------------------------------------------------------------------------
/array-reverse/php/main-builtin.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | if ($argc != 3)
 4 | {
 5 | 	printf("Usage: %s <size> <iterations>", $argv[0]);
 6 | 	exit(1);
 7 | }
 8 | 
 9 | 
10 | $myList = range(0, $argv[1] - 1);
11 | 
12 | for ($i = 0; $i < $argv[2]; $i++)
13 | {
14 | 	$myList = array_reverse($myList);
15 | }
16 | 


--------------------------------------------------------------------------------
/roll-avg/swift/rolling-avg/rolling-avg.xcodeproj/project.xcworkspace/xcuserdata/alex.xcuserdatad/UserInterfaceState.xcuserstate:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/unixpickle/Benchmarks/HEAD/roll-avg/swift/rolling-avg/rolling-avg.xcodeproj/project.xcworkspace/xcuserdata/alex.xcuserdatad/UserInterfaceState.xcuserstate


--------------------------------------------------------------------------------
/force-field/swift/force-field/force-field.xcodeproj/project.xcworkspace/xcuserdata/alex.xcuserdatad/UserInterfaceState.xcuserstate:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/unixpickle/Benchmarks/HEAD/force-field/swift/force-field/force-field.xcodeproj/project.xcworkspace/xcuserdata/alex.xcuserdatad/UserInterfaceState.xcuserstate


--------------------------------------------------------------------------------
/roll-avg/c/excursion/instructions.md:
--------------------------------------------------------------------------------
 1 | **Create unoptimized func1_unopt.s LLVM IR**
 2 | 
 3 | clang -c -S func1.c -O0 -emit-llvm -o func1_unopt.s
 4 | 
 5 | **Create optimized func1.bc**
 6 | 
 7 | opt func1_unopt.s *some arguments here* -o func1.bc
 8 | 
 9 | **Create optimized func1.s assembly**
10 | 
11 | llc func1.bc
12 | 


--------------------------------------------------------------------------------
/array-reverse/swift/array-reverse/array-reverse.xcodeproj/project.xcworkspace/xcuserdata/alex.xcuserdatad/UserInterfaceState.xcuserstate:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/unixpickle/Benchmarks/HEAD/array-reverse/swift/array-reverse/array-reverse.xcodeproj/project.xcworkspace/xcuserdata/alex.xcuserdatad/UserInterfaceState.xcuserstate


--------------------------------------------------------------------------------
/array-reverse/python/main2_builtin.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | 
 3 | if len(sys.argv) != 3:
 4 |   print('Usage: python main2.py <size> <iterations>')
 5 |   exit(1)
 6 | 
 7 | size = int(sys.argv[1])
 8 | iterations = int(sys.argv[2])
 9 | 
10 | myList = range(0, size)
11 | 
12 | for i in xrange(0, iterations):
13 |   myList.reverse()
14 | 


--------------------------------------------------------------------------------
/array-reverse/python/main3_builtin.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | 
 3 | if len(sys.argv) != 3:
 4 |   print('Usage: python3 main3_builtin.py <size> <iterations>')
 5 |   exit(1)
 6 | 
 7 | size = int(sys.argv[1])
 8 | iterations = int(sys.argv[2])
 9 | 
10 | myList = list(range(0, size))
11 | 
12 | for i in range(0, iterations):
13 |   myList.reverse()
14 | 


--------------------------------------------------------------------------------
/array-reverse/js/main_builtin.js:
--------------------------------------------------------------------------------
 1 | if (process.argv.length !== 4) {
 2 |   console.error('Usage: node main.js <size> <iterations>');
 3 |   process.exit(1);
 4 | }
 5 | 
 6 | var size = parseInt(process.argv[2]);
 7 | var iterations = parseInt(process.argv[3]);
 8 | 
 9 | // generate the array
10 | list = []
11 | for (var i = 0; i < size; i++) {
12 |   list.push(i);
13 | }
14 | 
15 | for (var i = 0; i < iterations; i++) {
16 |   list.reverse();
17 | }
18 | 


--------------------------------------------------------------------------------
/array-reverse/ruby/main.rb:
--------------------------------------------------------------------------------
 1 | def reverseArray(theList)
 2 |   (theList.length >> 1).times do |i|
 3 |     lastIdx = theList.length - i - 1
 4 |     theList[i], theList[lastIdx] = theList[lastIdx], theList[i]
 5 |   end
 6 | end
 7 | 
 8 | if ARGV.length != 2
 9 |   puts 'Usage: ruby main.rb <size> <iterations>'
10 |   exit 1
11 | end
12 | 
13 | size = ARGV[0].to_i
14 | iterations = ARGV[1].to_i
15 | 
16 | list = (0...size).to_a
17 | 
18 | iterations.times do
19 |   reverseArray list
20 | end


--------------------------------------------------------------------------------
/array-reverse/python/main2.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | 
 3 | def reverseArray(theArray):
 4 |   for i in xrange(0, len(theArray) >> 1):
 5 |     lastIdx = len(theArray) - i - 1
 6 |     theArray[lastIdx], theArray[i] = theArray[i], theArray[lastIdx]
 7 | 
 8 | if len(sys.argv) != 3:
 9 |   print('Usage: python main2.py <size> <iterations>')
10 |   exit(1)
11 | 
12 | size = int(sys.argv[1])
13 | iterations = int(sys.argv[2])
14 | 
15 | myList = range(0, size)
16 | 
17 | for i in xrange(0, iterations):
18 |   reverseArray(myList)
19 | 


--------------------------------------------------------------------------------
/array-reverse/python/main3.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | 
 3 | def reverseArray(theArray):
 4 |   for i in range(0, len(theArray) >> 1):
 5 |     lastIdx = len(theArray) - i - 1
 6 |     theArray[lastIdx], theArray[i] = theArray[i], theArray[lastIdx]
 7 | 
 8 | if len(sys.argv) != 3:
 9 |   print('Usage: python3 main3.py <size> <iterations>')
10 |   exit(1)
11 | 
12 | size = int(sys.argv[1])
13 | iterations = int(sys.argv[2])
14 | 
15 | myList = list(range(0, size))
16 | 
17 | for i in range(0, iterations):
18 |   reverseArray(myList)
19 | 


--------------------------------------------------------------------------------
/array-reverse/rust/main_builtin.rs:
--------------------------------------------------------------------------------
 1 | use std::env::args;
 2 | 
 3 | fn main() {
 4 |   if args().count() != 3 {
 5 |     panic!("Usage: {} <size> <iterations>", args().next().unwrap());
 6 |   }
 7 | 
 8 |   let mut args_iter = args().skip(1);
 9 | 
10 |   let count: usize = args_iter.next().unwrap().parse().unwrap();
11 |   let iterations: usize = args_iter.next().unwrap().parse().unwrap();
12 | 
13 |   let mut array: Vec<usize> = (0..count).collect();
14 | 
15 |   for _ in 0..iterations {
16 |     array.reverse();
17 |   }
18 | }
19 | 


--------------------------------------------------------------------------------
/force-field/ruby/main.rb:
--------------------------------------------------------------------------------
 1 | require './Particle.rb'
 2 | require './Vector.rb'
 3 | 
 4 | if ARGV.length != 2
 5 |   puts 'Usage: ruby main.rb <time delta> <count>'
 6 |   exit 1
 7 | end
 8 | 
 9 | timeDelta = ARGV[0].to_f
10 | count = ARGV[1].to_i
11 | 
12 | p1 = Particle.new Vector.new(0.3, 0), -1
13 | p2 = Particle.new Vector.new(-0.3, 1), 1
14 | 
15 | count.times do
16 |   force1 = p1.forceFrom p2
17 |   force2 = p2.forceFrom p1
18 |   p1.applyForce force1, timeDelta
19 |   p2.applyForce force2, timeDelta
20 | end
21 | 
22 | puts "p1 = #{p1}"
23 | puts "p2 = #{p2}"
24 | 


--------------------------------------------------------------------------------
/roll-avg/ruby/main.rb:
--------------------------------------------------------------------------------
 1 | def addUpTo(dest)
 2 |   sum = 0
 3 |   i = 1
 4 |   while i <= dest
 5 |     sum += i
 6 |     i += 1
 7 |   end
 8 |   return sum
 9 | end
10 | 
11 | def rollAverage(dest)
12 |   average = 0.0
13 |   dest.times do |x|
14 |     average = (average + addUpTo(x)) / 2.0
15 |   end
16 |   return average
17 | end
18 | 
19 | if ARGV.length != 2
20 |   puts 'Usage: ruby main.rb <start> <end>'
21 |   exit 1
22 | end
23 | 
24 | start = ARGV[0].to_i
25 | endNum = ARGV[1].to_i
26 | 
27 | while start <= endNum
28 |   puts "rollAverage(#{start}) = #{rollAverage(start)}"
29 |   start += 1
30 | end
31 | 


--------------------------------------------------------------------------------
/force-field/python/main.py:
--------------------------------------------------------------------------------
 1 | from particle import Particle
 2 | from vector import Vector
 3 | import sys
 4 | 
 5 | if len(sys.argv) != 3:
 6 |   print('Usage: python main.py <time delta> <count>')
 7 |   exit(1)
 8 | 
 9 | timeDelta = float(sys.argv[1])
10 | count = int(sys.argv[2])
11 | 
12 | p1 = Particle(Vector(0.3, 0), -1)
13 | p2 = Particle(Vector(-0.3, 1), 1)
14 | 
15 | while count > 0:
16 |   force1 = p1.forceFrom(p2)
17 |   force2 = p2.forceFrom(p1)
18 |   p1.applyForce(force1, timeDelta)
19 |   p2.applyForce(force2, timeDelta)
20 |   count -= 1
21 | 
22 | print("p1 = " + str(p1))
23 | print("p2 = " + str(p2))
24 | 


--------------------------------------------------------------------------------
/roll-avg/python/main.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | 
 3 | def addUpTo(dest):
 4 |   summation = 0
 5 |   i = 1
 6 |   d = dest+1
 7 |   for i in range(1,d):
 8 |     summation += i
 9 |     
10 |   return summation
11 | 
12 | def rollAverage(dest):
13 |   average = 0.0
14 |   i = 0
15 |   for i in range(dest):
16 |     average = (average + addUpTo(i)) / 2
17 |   return average
18 | 
19 | if len(sys.argv) != 3:
20 |   print('Usage: python main.py <start> <end>')
21 |   exit(1)
22 | 
23 | start = int(sys.argv[1])
24 | end = int(sys.argv[2])
25 | while start <= end:
26 |   print('rollAverage(' + str(start) + ') = ' + str(rollAverage(start)))
27 |   start += 1
28 | 


--------------------------------------------------------------------------------
/array-reverse/php/main-user.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | if ($argc != 3)
 4 | {
 5 | 	printf("Usage: %s <size> <iterations>\n", $argv[0]);
 6 | 	exit(1);
 7 | }
 8 | 
 9 | 
10 | $myList = range(0, $argv[1] - 1);
11 | 
12 | for ($i = 0; $i < $argv[2]; $i++)
13 | {
14 | 	reverseArray($myList);
15 | }
16 | 
17 | /**
18 |  * Reverses an array inplace
19 |  * @param array &$array An array to be reversed
20 |  */
21 | function reverseArray(&$array)
22 | {
23 | 	for ($i = 0; $i < count($array) >> 1; $i++)
24 | 	{
25 | 		$lastIdx = count($array) - $i - 1;
26 | 		$lastValue = $array[$lastIdx];
27 | 		$array[$lastIdx] = $array[$i];
28 | 		$array[$i] = $lastValue;
29 | 	}
30 | }
31 | 
32 | 


--------------------------------------------------------------------------------
/roll-avg/c/note.md:
--------------------------------------------------------------------------------
 1 | This is significantly faster than the other tests (except for the Swift one, which uses Clang as well and is thus equivalently optimized). This is because Clang provides Induction Variable Simplification. This means that this:
 2 | 
 3 |     unsigned int addUpTo(unsigned int dest) {
 4 |       unsigned int sum = 0;
 5 |       for (int i = 1; i <= dest; i++) {
 6 |         sum += i;
 7 |       }
 8 |       return sum;
 9 |     }
10 | 
11 | Gets turned into this:
12 | 
13 |     unsigned int addUpTo(unsigned int dest) {
14 |       return (unsigned int)(((long)dest * (long)(dest + 1)) >> 1);
15 |     }
16 | 
17 | This changes the program from O(n^2) to O(n).


--------------------------------------------------------------------------------
/force-field/swift/force-field/force-field.xcodeproj/xcuserdata/alex.xcuserdatad/xcschemes/xcschememanagement.plist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 3 | <plist version="1.0">
 4 | <dict>
 5 | 	<key>SchemeUserState</key>
 6 | 	<dict>
 7 | 		<key>force-field.xcscheme</key>
 8 | 		<dict>
 9 | 			<key>orderHint</key>
10 | 			<integer>0</integer>
11 | 		</dict>
12 | 	</dict>
13 | 	<key>SuppressBuildableAutocreation</key>
14 | 	<dict>
15 | 		<key>FABFCB98197211810093E1E1</key>
16 | 		<dict>
17 | 			<key>primary</key>
18 | 			<true/>
19 | 		</dict>
20 | 	</dict>
21 | </dict>
22 | </plist>
23 | 


--------------------------------------------------------------------------------
/roll-avg/swift/rolling-avg/rolling-avg.xcodeproj/xcuserdata/alex.xcuserdatad/xcschemes/xcschememanagement.plist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 3 | <plist version="1.0">
 4 | <dict>
 5 | 	<key>SchemeUserState</key>
 6 | 	<dict>
 7 | 		<key>rolling-avg.xcscheme</key>
 8 | 		<dict>
 9 | 			<key>orderHint</key>
10 | 			<integer>0</integer>
11 | 		</dict>
12 | 	</dict>
13 | 	<key>SuppressBuildableAutocreation</key>
14 | 	<dict>
15 | 		<key>FA0E8553196F609500955123</key>
16 | 		<dict>
17 | 			<key>primary</key>
18 | 			<true/>
19 | 		</dict>
20 | 	</dict>
21 | </dict>
22 | </plist>
23 | 


--------------------------------------------------------------------------------
/array-reverse/swift/array-reverse/array-reverse.xcodeproj/xcuserdata/alex.xcuserdatad/xcschemes/xcschememanagement.plist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 3 | <plist version="1.0">
 4 | <dict>
 5 | 	<key>SchemeUserState</key>
 6 | 	<dict>
 7 | 		<key>array-reverse.xcscheme</key>
 8 | 		<dict>
 9 | 			<key>orderHint</key>
10 | 			<integer>0</integer>
11 | 		</dict>
12 | 	</dict>
13 | 	<key>SuppressBuildableAutocreation</key>
14 | 	<dict>
15 | 		<key>FAC83AC51970A1F100E03EAC</key>
16 | 		<dict>
17 | 			<key>primary</key>
18 | 			<true/>
19 | 		</dict>
20 | 	</dict>
21 | </dict>
22 | </plist>
23 | 


--------------------------------------------------------------------------------
/force-field/php/main.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require_once __DIR__ . '/Vector.php';
 4 | require_once __DIR__ . '/Particle.php';
 5 | 
 6 | if ($argc != 3)
 7 | {
 8 | 	printf("Usage: %s <time delta> <count>\n", $argv[0]);
 9 | 	exit(1);
10 | }
11 | 
12 | 
13 | $timeDelta = $argv[1];
14 | $count = $argv[2];
15 | 
16 | $p1 = new Particle(new Vector(0.3, 0), -1);
17 | $p2 = new Particle(new Vector(-0.3, 1), 1);
18 | 
19 | for ($i = 0; $i < $count; $i++)
20 | {
21 | 	$force1 = $p1->forceFrom($p2);
22 | 	$force2 = $p2->forceFrom($p1);
23 | 
24 | 	$p1->applyForce($force1, $timeDelta);
25 | 	$p2->applyForce($force2, $timeDelta);
26 | }
27 | 
28 | echo "p1 = " . $p1 . "\n";
29 | echo "p2 = " . $p2 . "\n";
30 | 
31 | 


--------------------------------------------------------------------------------
/array-reverse/go/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"os"
 6 | 	"strconv"
 7 | )
 8 | 
 9 | func reverseArray(l []int) {
10 | 	for i := 0; i < (len(l) >> 1); i++ {
11 | 		lastIdx := len(l) - i - 1
12 | 		l[lastIdx], l[i] = l[i], l[lastIdx]
13 | 	}
14 | }
15 | 
16 | func main() {
17 | 	if len(os.Args) != 3 {
18 | 		fmt.Fprintln(os.Stderr, "Usage: array-reverse <size> <iterations>")
19 | 		os.Exit(1)
20 | 	}
21 | 	
22 | 	count, _ := strconv.Atoi(os.Args[1])
23 | 	iterations, _ := strconv.Atoi(os.Args[2])
24 | 	
25 | 	array := make([]int, count)
26 | 	for i := 0; i < count; i++ {
27 | 		array[i] = i
28 | 	}
29 | 	
30 | 	for i := 0; i < iterations; i++ {
31 | 		reverseArray(array)
32 | 	}
33 | }
34 | 


--------------------------------------------------------------------------------
/force-field/js/main.js:
--------------------------------------------------------------------------------
 1 | var Particle = require('./particle');
 2 | var Vector = require('./vector');
 3 | 
 4 | if (process.argv.length !== 4) {
 5 |   console.error('Usage: node main.js <time delta> <count>');
 6 |   process.exit(1);
 7 | }
 8 | 
 9 | var timeDelta = parseFloat(process.argv[2]);
10 | var count = parseInt(process.argv[3]);
11 | 
12 | var p1 = new Particle(new Vector(0.3, 0), -1);
13 | var p2 = new Particle(new Vector(-0.3, 1), 1);
14 | 
15 | for (var i = 0; i < count; i++) {
16 |   var force1 = p1.forceFrom(p2);
17 |   var force2 = p2.forceFrom(p1);
18 |   p1.applyForce(force1, timeDelta);
19 |   p2.applyForce(force2, timeDelta);
20 | }
21 | 
22 | console.log('p1 = ' + p1);
23 | console.log('p2 = ' + p2);
24 | 


--------------------------------------------------------------------------------
/array-reverse/js/main.js:
--------------------------------------------------------------------------------
 1 | function reverseArray(theArray) {
 2 |   for (var i = 0; i < theArray.length >>> 1; i++) {
 3 |     var lastIdx = theArray.length - i - 1;
 4 |     var lastValue = theArray[lastIdx];
 5 |     theArray[lastIdx] = theArray[i];
 6 |     theArray[i] = lastValue;
 7 |   }
 8 | }
 9 | 
10 | if (process.argv.length !== 4) {
11 |   console.error('Usage: node main.js <size> <iterations>');
12 |   process.exit(1);
13 | }
14 | 
15 | var size = parseInt(process.argv[2]);
16 | var iterations = parseInt(process.argv[3]);
17 | 
18 | // generate the array
19 | list = []
20 | for (var i = 0; i < size; i++) {
21 |   list.push(i);
22 | }
23 | 
24 | for (var i = 0; i < iterations; i++) {
25 |   reverseArray(list);
26 | }
27 | 


--------------------------------------------------------------------------------
/roll-avg/dart/main.dart:
--------------------------------------------------------------------------------
 1 | import 'dart:io';
 2 | 
 3 | int addUpTo(int dest) {
 4 |   int sum = 0;
 5 |   for (int i = 1; i <= dest; i++) {
 6 |     sum += i;
 7 |   }
 8 |   return sum;
 9 | }
10 | 
11 | double rollAverage(int dest) {
12 |   double average = 0;
13 |   for (int i = 0; i < dest; i++) {
14 |     average = (average + addUpTo(i)) / 2.0;
15 |   }
16 |   return average;
17 | }
18 | 
19 | main(List<String> arguments) {
20 |   if (arguments.length != 2) {
21 |     print("Usage: dart main.dart <start> <end>");
22 |     exit(1);
23 |   }
24 |   int start = int.parse(arguments[0]);
25 |   int end = int.parse(arguments[1]);
26 |   for (int i = start; i <= end; i++) {
27 |     print("rollAverage(" + i.toString() + ") = " + rollAverage(i).toString());
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/force-field/dart/main.dart:
--------------------------------------------------------------------------------
 1 | import 'dart:io';
 2 | 
 3 | import 'particle.dart';
 4 | import 'vector.dart';
 5 | 
 6 | void main(List<String> args) {
 7 |   if (args.length != 2) {
 8 |     print("Usage: dart main.dart <time delta> <count>");
 9 |     exit(1);
10 |   }
11 |   
12 |   double timeDelta = double.parse(args[0]);
13 |   int count = int.parse(args[1]);
14 |   
15 |   Particle p1 = new Particle(new Vector(0.3, 0), -1);
16 |   Particle p2 = new Particle(new Vector(-0.3, 1), 1);
17 |   for (int i = 0; i < count; i++) {
18 |     Vector force1 = p1.forceFrom(p2);
19 |     Vector force2 = p2.forceFrom(p1);
20 |     p1.applyForce(force1, timeDelta);
21 |     p2.applyForce(force2, timeDelta);
22 |   }
23 |   
24 |   print("p1 = ${p1}");
25 |   print("p2 = ${p2}");
26 | }
27 | 


--------------------------------------------------------------------------------
/array-reverse/dart/main.dart:
--------------------------------------------------------------------------------
 1 | import 'dart:io';
 2 | 
 3 | reverseArray(List<int> list) {
 4 |   for (int i = 0; i < list.length >> 1; i++) {
 5 |     int lastIdx = list.length - i - 1;
 6 |     int lastValue = list[lastIdx];
 7 |     list[lastIdx] = list[i];
 8 |     list[i] = lastValue;
 9 |   }
10 | }
11 | 
12 | main(List<String> arguments) {
13 |   if (arguments.length != 2) {
14 |     print("Usage: dart main.dart <size> <iterations>");
15 |     exit(1);
16 |   }
17 |   
18 |   int size = int.parse(arguments[0]);
19 |   int iterations = int.parse(arguments[1]);
20 |   
21 |   List<int> theList = new List(size);
22 |   for (int i = 0; i < size; i++) {
23 |     theList[i] = i;
24 |   }
25 |   
26 |   for (int i = 0; i < iterations; i++) {
27 |     reverseArray(theList);
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/force-field/python/particle.py:
--------------------------------------------------------------------------------
 1 | from vector import Vector
 2 | 
 3 | class Particle:
 4 |   def __init__(self, pos, mass):
 5 |     self.position = pos
 6 |     self.mass = mass
 7 |     self.velocity = Vector(0, 0)
 8 |   
 9 |   def forceFrom(self, p):
10 |     distance = p.position.subtract(self.position)
11 |     magnitude = self.mass * p.mass / distance.dot(distance)
12 |     return distance.normalize().scale(magnitude)
13 |   
14 |   def applyForce(self, force, timeDelta):
15 |     self.velocity.addInPlace(force.scale(timeDelta / abs(self.mass)))
16 |     self.position.addInPlace(self.velocity.scale(timeDelta))
17 |   
18 |   def __str__(self):
19 |     return ("{Particle mass: " + str(self.mass) + " velocity: " +
20 |       str(self.velocity) + " position: " + str(self.position) + "}")
21 | 


--------------------------------------------------------------------------------
/roll-avg/php/main.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | if ($argc != 3)
 4 | {
 5 | 	printf("Usage: %s <start> <end>", $argv[0]);
 6 | 	exit(1);
 7 | }
 8 | 
 9 | $start = $argv[1];
10 | $end = $argv[2];
11 | 
12 | for ($i = $start; $i <= $end; $i++)
13 | {
14 | 	printf("rollAverage(%d) = %d\n", $i, rollAverage($i));
15 | }
16 | 
17 | 
18 | /**
19 |  * @param int $dest
20 |  * @return int
21 |  */
22 | function addUpTo($dest)
23 | {
24 | 	$sum = 0;
25 | 	for ($i = 1; $i <= $dest; $i++)
26 | 	{
27 | 		$sum += $i;
28 | 	}
29 | 	return $sum;
30 | }
31 | 
32 | /**
33 |  * @param int $dest
34 |  * @return float
35 |  */
36 | function rollAverage($dest)
37 | {
38 | 	$average = 0;
39 | 	for ($i = 0; $i < $dest; $i++)
40 | 	{
41 | 		$average = ($average + addUpTo($i)) / 2.0;
42 | 	}
43 | 	return $average;
44 | }
45 | 


--------------------------------------------------------------------------------
/force-field/ruby/Vector.rb:
--------------------------------------------------------------------------------
 1 | class Vector
 2 |   attr_accessor :x
 3 |   attr_accessor :y
 4 |   
 5 |   def initialize(x, y)
 6 |     @x = x
 7 |     @y = y
 8 |   end
 9 |   
10 |   def subtract(v)
11 |     Vector.new @x - v.x, @y - v.y
12 |   end
13 |   
14 |   def add(v)
15 |     Vector.new @x + v.x, @y + v.y
16 |   end
17 |   
18 |   def scale(s)
19 |     Vector.new x * s, y * s
20 |   end
21 |   
22 |   def addInPlace(v)
23 |     @x += v.x
24 |     @y += v.y
25 |   end
26 |   
27 |   def dot(v)
28 |     @x * v.x + @y * v.y
29 |   end
30 |   
31 |   def normalize()
32 |     magnitude = Math.sqrt self.dot self
33 |     if magnitude == 0
34 |       return Vector.new 0, 0
35 |     end
36 |     self.scale 1.0 / magnitude
37 |   end
38 |   
39 |   def to_s
40 |     "(#{@x}, #{@y})"
41 |   end
42 | end
43 | 


--------------------------------------------------------------------------------
/force-field/ruby/Particle.rb:
--------------------------------------------------------------------------------
 1 | require './Vector.rb'
 2 | 
 3 | class Particle
 4 |   attr_accessor :position
 5 |   attr_accessor :mass
 6 |   attr_accessor :velocity
 7 |   
 8 |   def initialize(pos, mass)
 9 |     @position = pos
10 |     @mass = mass
11 |     @velocity = Vector.new 0, 0
12 |   end
13 |   
14 |   def forceFrom(p)
15 |     distance = p.position.subtract @position
16 |     magnitude = @mass * p.mass / distance.dot(distance)
17 |     return distance.normalize().scale magnitude
18 |   end
19 |   
20 |   def applyForce(force, timeDelta)
21 |     velocity.addInPlace force.scale (timeDelta / @mass.abs)
22 |     position.addInPlace velocity.scale timeDelta
23 |   end
24 |   
25 |   def to_s
26 |     "{Particle mass: #{@mass} velocity: #{@velocity} position: #{@position}}"
27 |   end
28 | end
29 | 


--------------------------------------------------------------------------------
/array-reverse/rust/main.rs:
--------------------------------------------------------------------------------
 1 | use std::env::args;
 2 | 
 3 | fn reverse_array(the_list: &mut Vec<usize>) {
 4 |   for i in 0..the_list.len() >> 1 {
 5 |     let last_idx = the_list.len() - i - 1;
 6 |     let last_value = the_list[last_idx];
 7 |     the_list[last_idx] = the_list[i];
 8 |     the_list[i] = last_value;
 9 |   }
10 | }
11 | 
12 | fn main() {
13 |   if args().count() != 3 {
14 |     panic!("Usage: {} <size> <iterations>", args().next().unwrap());
15 |   }
16 | 
17 |   let mut args_iter = args().skip(1);
18 | 
19 |   let count: usize = args_iter.next().unwrap().parse().unwrap();
20 |   let iterations: usize = args_iter.next().unwrap().parse().unwrap();
21 | 
22 |   let mut array: Vec<usize> = (0..count).collect();
23 | 
24 |   for _ in 0..iterations {
25 |    reverse_array(&mut array);
26 |   }
27 | }
28 | 


--------------------------------------------------------------------------------
/force-field/dart/particle.dart:
--------------------------------------------------------------------------------
 1 | import 'vector.dart';
 2 | 
 3 | class Particle {
 4 |   Vector position;
 5 |   double mass;
 6 |   Vector velocity;
 7 |   
 8 |   Particle(this.position, this.mass) {
 9 |     velocity = new Vector(0, 0);
10 |   }
11 |   
12 |   Vector forceFrom(Particle p) {
13 |     Vector distance = p.position - position;
14 |     double magnitude = mass * p.mass / distance.dot(distance);
15 |     return distance.normalize() * magnitude;
16 |   }
17 |   
18 |   void applyForce(Vector force, double timeDelta) {
19 |     velocity.addInPlace(force * (timeDelta / mass.abs()));
20 |     position.addInPlace(velocity * timeDelta);
21 |   }
22 |   
23 |   String toString() {
24 |     return "{Particle mass:${mass} velocity: ${velocity}" +
25 |       " position: ${position}}";
26 |   }
27 | 
28 | }
29 | 


--------------------------------------------------------------------------------
/force-field/python/vector.py:
--------------------------------------------------------------------------------
 1 | import math
 2 | 
 3 | class Vector:
 4 |   def __init__(self, x, y):
 5 |     self.x = x
 6 |     self.y = y
 7 |   
 8 |   def subtract(self, v):
 9 |     return Vector(self.x - v.x, self.y - v.y);
10 |   
11 |   def add(self, v):
12 |     return Vector(self.x + v.x, self.y + v.y);
13 |   
14 |   def addInPlace(self, v):
15 |     self.x += v.x
16 |     self.y += v.y
17 |   
18 |   def scale(self, s):
19 |     return Vector(self.x * s, self.y * s);
20 |   
21 |   def dot(self, v):
22 |     return self.x * v.x + self.y * v.y
23 |   
24 |   def normalize(self):
25 |     magnitude = math.sqrt(self.dot(self))
26 |     if magnitude == 0: return Vector(0, 0)
27 |     return self.scale(1.0 / magnitude)
28 |   
29 |   def __str__(self):
30 |     return "(" + str(self.x) + ", " + str(self.y) + ")"
31 | 


--------------------------------------------------------------------------------
/roll-avg/c/main.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | 
 4 | unsigned int addUpTo(unsigned int dest) {
 5 |   unsigned int sum = 0;
 6 |   for (int i = 1; i <= dest; i++) {
 7 |     sum += i;
 8 |   }
 9 |   return sum;
10 | }
11 | 
12 | double rollAverage(unsigned int dest) {
13 |   double average = 0;
14 |   for (unsigned int i = 0; i < dest; i++) {
15 |     average = (average + (double)addUpTo(i)) / 2.0;
16 |   }
17 |   return average;
18 | }
19 | 
20 | int main(int argc, const char ** argv) {
21 |   if (argc != 3) {
22 |     fprintf(stderr, "Usage: roll-avg <start> <end>\n");
23 |     return 1;
24 |   }
25 |   int start = atoi(argv[1]);
26 |   int end = atoi(argv[2]);
27 |   for (int i = start; i <= end; i++) {
28 |     printf("rollAverage(%d) = %lf\n", i, rollAverage(i));
29 |   }
30 |   return 0;
31 | }
32 | 


--------------------------------------------------------------------------------
/roll-avg/go/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"os"
 6 | 	"strconv"
 7 | )
 8 | 
 9 | func addUpTo(dest uint32) uint32 {
10 | 	sum := uint32(0)
11 | 	for i := uint32(1); i <= dest; i++ {
12 | 		sum += i
13 | 	}
14 | 	return sum
15 | }
16 | 
17 | func rollAverage(dest int) float64 {
18 | 	average := 0.0
19 | 	for i := uint32(0); i < uint32(dest); i++ {
20 | 		average = (average+float64(addUpTo(i))) / 2.0
21 | 	}
22 | 	return average
23 | }
24 | 
25 | func main() {
26 | 	if len(os.Args) != 3 {
27 | 		fmt.Fprintln(os.Stderr, "Usage: roll-avg <start> <end>")
28 | 		os.Exit(1)
29 | 	}
30 | 	
31 | 	start, _ := strconv.Atoi(os.Args[1])
32 | 	end, _ := strconv.Atoi(os.Args[2])
33 | 	
34 | 	for i := start; i <= end; i++ {
35 | 		fmt.Printf("rollAverage(%d) = %f\n", i, rollAverage(i))
36 | 	}
37 | }
38 | 
39 | 


--------------------------------------------------------------------------------
/force-field/java/Main.java:
--------------------------------------------------------------------------------
 1 | class Main {
 2 |   
 3 |   public static void main(String[] args) {
 4 |     if (args.length != 2) {
 5 |       System.err.println("Usage: java Main <time delta> <count>");
 6 |       System.exit(1);
 7 |     }
 8 |     
 9 |     double timeDelta = Double.parseDouble(args[0]);
10 |     int count = Integer.parseInt(args[1]);
11 |     
12 |     Particle p1 = new Particle(new Vector(0.3, 0), -1);
13 |     Particle p2 = new Particle(new Vector(-0.3, 1), 1);
14 |     for (int i = 0; i < count; i++) {
15 |       Vector force1 = p1.forceFrom(p2);
16 |       Vector force2 = p2.forceFrom(p1);
17 |       p1.applyForce(force1, timeDelta);
18 |       p2.applyForce(force2, timeDelta);
19 |     }
20 |     
21 |     System.out.println("p1 = " + p1);
22 |     System.out.println("p2 = " + p2);
23 |   }
24 |   
25 | }


--------------------------------------------------------------------------------
/force-field/c++/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstdlib>
 3 | #include "particle.hpp"
 4 | #include "vector.hpp"
 5 | 
 6 | using namespace std;
 7 | 
 8 | int main(int argc, const char * argv[]) {
 9 |   if (argc != 3) {
10 |     cerr << "Usage: " << argv[0] << " <time delta> <count>" << endl;
11 |     return 1;
12 |   }
13 |   
14 |   double timeDelta = atof(argv[1]);
15 |   int count = atoi(argv[2]);
16 |   
17 |   Particle p1(Vector(0.3, 0), -1);
18 |   Particle p2(Vector(-0.3, 1), 1);
19 |   for (int i = 0; i < count; i++) {
20 |     Vector force1 = p1.ForceFrom(p2);
21 |     Vector force2 = p2.ForceFrom(p1);
22 |     p1.ApplyForce(force1, timeDelta);
23 |     p2.ApplyForce(force2, timeDelta);
24 |   }
25 |   
26 |   cout << "p1 = " << p1 << endl;
27 |   cout << "p2 = " << p2 << endl;
28 |   
29 |   return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/array-reverse/java/Main.java:
--------------------------------------------------------------------------------
 1 | class Main {
 2 |   
 3 |   public static void reverseArray(int[] array) {
 4 |     for (int i = 0; i < array.length >> 1; i++) {
 5 |       int lastIdx = array.length - i - 1;
 6 |       int lastValue = array[lastIdx];
 7 |       array[lastIdx] = array[i];
 8 |       array[i] = lastValue;
 9 |     }
10 |   }
11 |   
12 |   public static void main(String[] args) {
13 |     if (args.length != 2) {
14 |       System.err.println("Usage: java Main <size> <iterations>");
15 |       System.exit(1);
16 |     }
17 |     
18 |     int[] myList = new int[Integer.parseInt(args[0])];
19 |     for (int i = 0; i < myList.length; i++) {
20 |       myList[i] = i;
21 |     }
22 |     int count = Integer.parseInt(args[1]);
23 |     for (int i = 0; i < count; i++) {
24 |       reverseArray(myList);
25 |     }
26 |   }
27 |   
28 | }


--------------------------------------------------------------------------------
/roll-avg/rust/main.rs:
--------------------------------------------------------------------------------
 1 | use std::env::args;
 2 | 
 3 | fn add_up_to(dest: usize) -> usize {
 4 |   let mut sum: usize = 0;
 5 | 
 6 |   for i in 1..dest + 1 {
 7 |     sum += i;
 8 |   }
 9 | 
10 |   sum
11 | }
12 | 
13 | fn roll_average(dest: usize) -> f64 {
14 |   let mut average = 0f64;
15 | 
16 |   for i in 0..dest {
17 |     average = (average + add_up_to(i) as f64) / 2f64;
18 |   }
19 | 
20 |   average
21 | }
22 | 
23 | fn main() {
24 |   if args().count() != 3 {
25 |     panic!("Usage: {} <start> <end>", args().next().unwrap());
26 |   }
27 | 
28 |   let mut args_iter = args().skip(1);
29 | 
30 |   let start: usize = args_iter.next().unwrap().parse().unwrap();
31 |   let end: usize = args_iter.next().unwrap().parse().unwrap();
32 | 
33 |   for i in start..end + 1 {
34 |     println!("rollAverage({}) = {}", i, roll_average(i));
35 |   }
36 | }
37 | 


--------------------------------------------------------------------------------
/array-reverse/c/main.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | 
 4 | void reverseArray(int * theList, int count) {
 5 |   for (int i = 0; i < count >> 1; i++) {
 6 |     int lastIdx = count - i - 1;
 7 |     int lastValue = theList[lastIdx];
 8 |     theList[lastIdx] = theList[i];
 9 |     theList[i] = lastValue;
10 |   }
11 | }
12 | 
13 | int main(int argc, const char * argv[]) {
14 |   if (argc != 3) {
15 |     fprintf(stderr, "Usage: array-reverse <size> <iterations>\n");
16 |     return 1;
17 |   }
18 |   
19 |   int count = atoi(argv[1]);
20 |   int iterations = atoi(argv[2]);
21 |   
22 |   int * array = malloc(sizeof(int) * count);
23 |   for (int i = 0; i < count; i++) {
24 |     array[i] = i;
25 |   }
26 |   
27 |   for (int i = 0; i < iterations; i++) {
28 |     reverseArray(array, count);
29 |   }
30 |   
31 |   free(array);
32 |   return 0;
33 | }


--------------------------------------------------------------------------------
/roll-avg/js/main.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Adds integers up to and including `dest` and returns the sum.
 3 |  */
 4 | function addUpTo(dest) {
 5 |   var sum = 0;
 6 |   for (var i = 1; i <= dest; i++) {
 7 |     sum += i;
 8 |   }
 9 |   return sum;
10 | }
11 | 
12 | /**
13 |  * Run a "rolling average" on a set of sums of consecutive integers.
14 |  */
15 | function rollAverage(dest) {
16 |   var average = 0.0;
17 |   for (var i = 0; i < dest; i++) {
18 |     average = (average + addUpTo(i)) / 2.0;
19 |   }
20 |   return average;
21 | }
22 | 
23 | if (process.argv.length !== 4) {
24 |   console.error('Usage: node main.js <start> <end>');
25 |   process.exit(1);
26 | }
27 | 
28 | var start = parseInt(process.argv[2]);
29 | var end = parseInt(process.argv[3]);
30 | for (var i = start; i <= end; i++) {
31 |   console.log('rollAverage(' + i + ') = ' + rollAverage(i));
32 | }
33 | 


--------------------------------------------------------------------------------
/roll-avg/java/Main.java:
--------------------------------------------------------------------------------
 1 | class Main {
 2 | 
 3 |   public static int addUpTo(int dest) {
 4 |     int sum = 0;
 5 |     for (int i = 1; i <= dest; i++) {
 6 |       sum += i;
 7 |     }
 8 |     return sum;
 9 |   }
10 | 
11 |   public static double rollAverage(int dest) {
12 |     double average = 0;
13 |     for (int i = 0; i < dest; i++) {
14 |       average = (average + (double)addUpTo(i)) / 2.0;
15 |     }
16 |     return average;
17 |   }
18 | 
19 |   public static void main(String[] args) {
20 |     if (args.length != 2) {
21 |       System.err.println("Usage: java Main <start> <end>");
22 |       System.exit(1);
23 |     }
24 |     int start = Integer.parseInt(args[0]);
25 |     int end = Integer.parseInt(args[1]);
26 |     for (int i = start; i <= end; i++) {
27 |       System.out.println("rollAverage(" + i + ") = " + rollAverage(i));
28 |     }
29 |   }
30 | 
31 | }


--------------------------------------------------------------------------------
/force-field/dart/vector.dart:
--------------------------------------------------------------------------------
 1 | import 'dart:math';
 2 | 
 3 | class Vector {
 4 |   double x;
 5 |   double y;
 6 |   
 7 |   Vector(this.x, this.y) {
 8 |   }
 9 |   
10 |   Vector operator -(Vector v) {
11 |     return new Vector(x - v.x, y - v.y);
12 |   }
13 |   
14 |   Vector operator +(Vector v) {
15 |     return new Vector(x + v.x, y + v.y);
16 |   }
17 |   
18 |   Vector operator *(double d) {
19 |     return new Vector(x * d, y * d);
20 |   }
21 |   
22 |   void addInPlace(Vector v) {
23 |     x += v.x;
24 |     y += v.y;
25 |   }
26 |   
27 |   double dot(Vector v) {
28 |     return x * v.x + y * v.y;
29 |   }
30 |   
31 |   Vector normalize() {
32 |     double magnitude = sqrt(dot(this));
33 |     if (magnitude == 0) return new Vector(0, 0);
34 |     return this * (1.0 / magnitude);
35 |   }
36 |   
37 |   String toString() {
38 |     return "(${x}, ${y})";
39 |   }
40 |   
41 | }
42 | 


--------------------------------------------------------------------------------
/force-field/js/particle.js:
--------------------------------------------------------------------------------
 1 | var Vector = require('./vector');
 2 | 
 3 | function Particle(position, mass) {
 4 |   this.position = position;
 5 |   this.mass = mass;
 6 |   this.velocity = new Vector();
 7 | }
 8 | 
 9 | Particle.prototype.forceFrom = function(p) {
10 |   var distance = p.position.subtract(this.position);
11 |   var magnitude = this.mass * p.mass / distance.dot(distance);
12 |   return distance.normalize().scale(magnitude);
13 | };
14 | 
15 | Particle.prototype.applyForce = function(force, timeDelta) {
16 |   this.velocity.addInPlace(force.scale(timeDelta / Math.abs(this.mass)));
17 |   this.position.addInPlace(this.velocity.scale(timeDelta));
18 | };
19 | 
20 | Particle.prototype.toString = function() {
21 |   return '{Particle mass: ' + this.mass + ' velocity: ' + this.velocity
22 |     + ' position: ' + this.position + '}';
23 | };
24 | 
25 | module.exports = Particle;
26 | 


--------------------------------------------------------------------------------
/force-field/java/Particle.java:
--------------------------------------------------------------------------------
 1 | class Particle {
 2 |   
 3 |   public Vector position;
 4 |   public double mass;
 5 |   public Vector velocity;
 6 |   
 7 |   public Particle(Vector pos, double _mass) {
 8 |     position = pos;
 9 |     mass = _mass;
10 |     velocity = new Vector();
11 |   }
12 |   
13 |   public Vector forceFrom(Particle p) {
14 |     Vector distance = p.position.subtract(position);
15 |     double magnitude = mass * p.mass / (distance.dot(distance));
16 |     return distance.normalize().scale(magnitude);
17 |   }
18 |   
19 |   public void applyForce(Vector force, double timeDelta) {
20 |     velocity.addInPlace(force.scale(timeDelta / Math.abs(mass)));
21 |     position.addInPlace(velocity.scale(timeDelta));
22 |   }
23 |   
24 |   public String toString() {
25 |     return "{Particle mass: " + mass + " velocity: " + velocity +
26 |       " position: " + position + "}";
27 |   }
28 |   
29 | }


--------------------------------------------------------------------------------
/force-field/rust/main.rs:
--------------------------------------------------------------------------------
 1 | mod particle;
 2 | mod vector;
 3 | 
 4 | use std::env::args;
 5 | 
 6 | use particle::Particle;
 7 | use vector::Vector;
 8 | 
 9 | fn main() {
10 |   if args().count() != 3 {
11 |     panic!("Usage: {} <time delta> <count>", args().next().unwrap());
12 |   }
13 | 
14 |   let mut args_iter = args().skip(1);
15 | 
16 |   let time_delta: f64 = args_iter.next().unwrap().parse().unwrap();
17 |   let count: usize = args_iter.next().unwrap().parse().unwrap();
18 | 
19 |   let mut p1 = Particle::new(Vector::from(0.3f64, 0f64), -1f64);
20 |   let mut p2 = Particle::new(Vector::from(-0.3f64, 1f64), 1f64);
21 | 
22 |   for _ in 0..count {
23 |     let force1 = p1.force_from(&p2);
24 |     let force2 = p2.force_from(&p1);
25 |     p1.apply_force(force1, time_delta);
26 |     p2.apply_force(force2, time_delta);
27 |   }
28 | 
29 |   println!("p1 = {}", p1);
30 |   println!("p2 = {}", p2);
31 | }
32 | 


--------------------------------------------------------------------------------
/force-field/swift/force-field/force-field/main.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  main.swift
 3 | //  force-field
 4 | //
 5 | //  Created by Alex Nichol on 7/12/14.
 6 | //  Copyright (c) 2014 Alex Nichol. All rights reserved.
 7 | //
 8 | 
 9 | import Foundation
10 | 
11 | if C_ARGC != 3 {
12 |   println("Usage: ./force-field <time delay> <count>")
13 |   exit(1);
14 | }
15 | 
16 | let arg1 = String.fromCString(C_ARGV[1])!;
17 | let timeDelta = NSString(string: arg1).doubleValue;
18 | let count = String.fromCString(C_ARGV[2])!.toInt()!;
19 | 
20 | var p1 = Particle(position: Vector(x: 0.3, y: 0), mass: -1);
21 | var p2 = Particle(position: Vector(x: -0.3, y: 1), mass: 1);
22 | 
23 | for i in 1...count {
24 |   var force1 = p1.forceFrom(p2);
25 |   var force2 = p2.forceFrom(p1);
26 |   p1.applyForce(force1, timeDelta: timeDelta);
27 |   p2.applyForce(force2, timeDelta: timeDelta);
28 | }
29 | 
30 | println("p1 = \(p1)");
31 | println("p2 = \(p2)");
32 | 


--------------------------------------------------------------------------------
/array-reverse/swift/array-reverse/array-reverse/main.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  main.swift
 3 | //  array-reverse
 4 | //
 5 | //  Created by Alex Nichol on 7/11/14.
 6 | //  Copyright (c) 2014 Alex Nichol. All rights reserved.
 7 | //
 8 | 
 9 | import Foundation
10 | 
11 | func reverseArray(inout theList: Array<Int>) {
12 |   for i in 0...(theList.count >> 1) - 1 {
13 |     let lastIdx = theList.count - i - 1
14 |     let lastValue = theList[lastIdx]
15 |     theList[lastIdx] = theList[i]
16 |     theList[i] = lastValue
17 |   }
18 | }
19 | 
20 | if C_ARGC != 3 {
21 |   println("Usage: ./array-reverse <size> <iterations>")
22 |   exit(1)
23 | }
24 | 
25 | let size = String.fromCString(C_ARGV[1])!.toInt()!
26 | let iterations = String.fromCString(C_ARGV[2])!.toInt()!
27 | 
28 | 
29 | var list = Array<Int>(count: size, repeatedValue: 0)
30 | for i in 0...size - 1 {
31 |   list[i] = i
32 | }
33 | 
34 | for i in 0...iterations - 1 {
35 |   reverseArray(&list)
36 | }
37 | 


--------------------------------------------------------------------------------
/force-field/php/Particle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Particle {
 4 | 	public $position;
 5 | 	public $mass;
 6 | 	public $velocity;
 7 | 
 8 | 	public function __construct($pos, $mass)
 9 | 	{
10 | 		$this->position = $pos;
11 | 		$this->mass = $mass;
12 | 		$this->velocity = new Vector(0, 0);
13 | 	}
14 | 
15 | 	public function forceFrom(Particle $p)
16 | 	{
17 | 		$distance = $p->position->subtract($this->position);
18 | 		$magnitude = $this->mass * $p->mass / $distance->dot($distance);
19 | 		return $distance->normalize()->scale($magnitude);
20 | 	}
21 | 
22 | 	public function applyForce($force, $timeDelta)
23 | 	{
24 | 		$this->velocity->addInPlace($force->scale($timeDelta / abs($this->mass)));
25 | 		$this->position->addInPlace($this->velocity->scale($timeDelta));
26 | 	}
27 | 
28 | 	public function __toString()
29 | 	{
30 | 		return sprintf('{Particle mass: %d velocity: %s position: %s', $this->mass, $this->velocity, $this->position);
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/force-field/cs/Program.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace ForceField {
 4 | 
 5 |   public class Program {
 6 |     
 7 |     public static void Main(String[] args) {
 8 |       if (args.Length != 2) {
 9 |         Console.Error.WriteLine("Usage: mono Program.exe <time delta> <count>");
10 |         Environment.Exit(1);
11 |       }
12 |       
13 |       double timeDelta = Convert.ToDouble(args[0]);
14 |       int count = Convert.ToInt32(args[1]);
15 |       
16 |       Particle p1 = new Particle(new Vector(0.3, 0), -1);
17 |       Particle p2 = new Particle(new Vector(-0.3, 1), 1);
18 |       for (int i = 0; i < count; i++) {
19 |         Vector force1 = p1.forceFrom(p2);
20 |         Vector force2 = p2.forceFrom(p1);
21 |         p1.applyForce(force1, timeDelta);
22 |         p2.applyForce(force2, timeDelta);
23 |       }
24 |       
25 |       Console.WriteLine("p1 = " + p1);
26 |       Console.WriteLine("p2 = " + p2);
27 |     }
28 |     
29 |   }
30 | }
31 | 


--------------------------------------------------------------------------------
/array-reverse/cs/Program.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace ArrayReverse {
 4 |   
 5 |   public class Program {
 6 |     
 7 |     public static void reverseArray(int[] array) {
 8 |       for (int i = 0; i < array.Length >> 1; i++) {
 9 |         int lastIdx = array.Length - i - 1;
10 |         int lastValue = array[lastIdx];
11 |         array[lastIdx] = array[i];
12 |         array[i] = lastValue;
13 |       }
14 |     }
15 |     
16 |     public static void Main(string[] args) {
17 |       if (args.Length != 2) {
18 |         Console.Error.WriteLine("Usage: mono Program <size> <iterations>");
19 |         Environment.Exit(1);
20 |       }
21 |       
22 |       int[] myList = new int[Convert.ToInt32(args[0])];
23 |       for (int i = 0; i < myList.Length; i++) {
24 |         myList[i] = i;
25 |       }
26 |       int count = Convert.ToInt32(args[1]);
27 |       for (int i = 0; i < count; i++) {
28 |         reverseArray(myList);
29 |       }
30 |     }
31 |   }  
32 | }


--------------------------------------------------------------------------------
/force-field/js/vector.js:
--------------------------------------------------------------------------------
 1 | function Vector(x, y) {
 2 |   this.x = x || 0;
 3 |   this.y = y || 0;
 4 | }
 5 | 
 6 | Vector.prototype.subtract = function(v) {
 7 |   return new Vector(this.x - v.x, this.y - v.y);
 8 | };
 9 | 
10 | Vector.prototype.add = function(v) {
11 |   return new Vector(this.x + v.x, this.y + v.y);
12 | };
13 | 
14 | Vector.prototype.scale = function(constant) {
15 |   return new Vector(this.x * constant, this.y * constant);
16 | };
17 | 
18 | Vector.prototype.addInPlace = function(v) {
19 |   this.x += v.x;
20 |   this.y += v.y;
21 | };
22 | 
23 | Vector.prototype.dot = function(v) {
24 |   return this.x * v.x + this.y * v.y;
25 | };
26 | 
27 | Vector.prototype.normalize = function() {
28 |   var magnitude = Math.sqrt(this.dot(this));
29 |   if (magnitude == 0) return new Vector(0, 0);
30 |   return this.scale(1 / magnitude);
31 | };
32 | 
33 | Vector.prototype.toString = function() {
34 |   return '(' + this.x + ', ' + this.y + ')';
35 | };
36 | 
37 | module.exports = Vector;
38 | 


--------------------------------------------------------------------------------
/roll-avg/cs/Program.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace RollAvg {
 4 | 
 5 |   class Program {
 6 |   
 7 |     public static int addUpTo(int dest) {
 8 |       int sum = 0;
 9 |       for (int i = 1; i <= dest; i++) {
10 |         sum += i;
11 |       }
12 |       return sum;
13 |     }
14 |   
15 |     public static double rollAverage(int dest) {
16 |       double average = 0;
17 |       for (int i = 0; i < dest; i++) {
18 |         average = (average + (double)addUpTo(i)) / 2.0;
19 |       }
20 |       return average;
21 |     }
22 |   
23 |     public static void Main(String[] args) {
24 |       if (args.Length != 2) {
25 |         Console.Error.WriteLine("Usage: mono Program.exe <start> <end>");
26 |         Environment.Exit(1);
27 |       }
28 |       int start = Convert.ToInt32(args[0]);
29 |       int end = Convert.ToInt32(args[1]);
30 |       for (int i = start; i <= end; i++) {
31 |         Console.WriteLine("rollAverage(" + i + ") = " + rollAverage(i));
32 |       }
33 |     }
34 |   
35 |   }
36 |   
37 | }
38 | 


--------------------------------------------------------------------------------
/array-reverse/php/note.md:
--------------------------------------------------------------------------------
 1 | # PHP Array Complexity
 2 | 
 3 | I found the following results when running the PHP implementation of array-reverse:
 4 | 
 5 | |Array Size |100 reversals (s) |
 6 | |-----------|------------------|
 7 | |100        |0.108             |
 8 | |1000       |3.220             |
 9 | |2000       |12.415            |
10 | |3000       |28.19             |
11 | |4000       |57.72             |
12 | |5000       |99.67             |
13 | |6000       |151.6             |
14 | |7000       |214.4             |
15 | |8000       |286.9             |
16 | |9000       |365.7             |
17 | |10000      |482               |
18 | 
19 | Usually, reversing an array takes O(n) time, but this is clearly converging to either O(n^2) time or something even worse. Because PHP arrays are internally hash maps, I suspect that it's approaching O(n) for each array access and thus O(n^2) for the reverse call.
20 | 
21 | Thus, it is possible to claim that PHP is **infinitely worse** at this benchmark than every other langauge.
22 | 


--------------------------------------------------------------------------------
/force-field/cs/Particle.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace ForceField {
 4 | 
 5 |   public class Particle {
 6 |     
 7 |     public Vector position;
 8 |     public double mass;
 9 |     public Vector velocity;
10 |     
11 |     public Particle(Vector pos, double _mass) {
12 |       position = pos;
13 |       mass = _mass;
14 |       velocity = new Vector();
15 |     }
16 |     
17 |     public Vector forceFrom(Particle p) {
18 |       Vector distance = p.position.subtract(position);
19 |       double magnitude = mass * p.mass / (distance.dot(distance));
20 |       return distance.normalize().scale(magnitude);
21 |     }
22 |     
23 |     public void applyForce(Vector force, double timeDelta) {
24 |       velocity.addInPlace(force.scale(timeDelta / Math.Abs(mass)));
25 |       position.addInPlace(velocity.scale(timeDelta));
26 |     }
27 |     
28 |     public override string ToString() {
29 |       return "{Particle mass: " + mass + " velocity: " + velocity +
30 |         " position: " + position + "}";
31 |     }
32 |     
33 |   }
34 |   
35 | }
36 | 


--------------------------------------------------------------------------------
/force-field/java/Vector.java:
--------------------------------------------------------------------------------
 1 | class Vector {
 2 |   
 3 |   public double x;
 4 |   public double y;
 5 |   
 6 |   public Vector(double _x, double _y) {
 7 |     this.x = _x;
 8 |     this.y = _y;
 9 |   }
10 |   
11 |   public Vector() {
12 |     this.x = 0;
13 |     this.y = 0;
14 |   }
15 |   
16 |   public Vector subtract(Vector v) {
17 |     return new Vector(x - v.x, y - v.y);
18 |   }
19 |   
20 |   public Vector add(Vector v) {
21 |     return new Vector(x + v.x, y + v.y);
22 |   }
23 |   
24 |   public Vector scale(double d) {
25 |     return new Vector(x * d, y * d);
26 |   }
27 |   
28 |   public void addInPlace(Vector v) {
29 |     x += v.x;
30 |     y += v.y;
31 |   }
32 |   
33 |   public double dot(Vector v) {
34 |     return x * v.x + y * v.y;
35 |   }
36 |   
37 |   public Vector normalize() {
38 |     double magnitude = Math.sqrt(dot(this));
39 |     if (magnitude == 0.0) return new Vector(0, 0);
40 |     return scale(1.0 / magnitude);
41 |   }
42 |   
43 |   public String toString() {
44 |     return "(" + x + ", " + y + ")";
45 |   }
46 |   
47 | }


--------------------------------------------------------------------------------
/force-field/php/Vector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Vector {
 4 | 	public $x;
 5 | 	public $y;
 6 | 
 7 | 	public function __construct($x, $y)
 8 | 	{
 9 | 		$this->x = $x;
10 | 		$this->y = $y;
11 | 	}
12 | 
13 | 	public function subtract($v)
14 | 	{
15 | 		return new static($this->x - $v->x, $this->y - $v->y);
16 | 	}
17 | 
18 | 	public function add($v)
19 | 	{
20 | 		return new static($this->x + $v->x, $this->y + $v->y);
21 | 	}
22 | 
23 | 	public function scale($d)
24 | 	{
25 | 		return new Vector($this->x * $d, $this->y * $d);
26 | 	}
27 | 
28 | 	public function addInPlace($v)
29 | 	{
30 | 		$this->x += $v->x;
31 | 		$this->y += $v->y;
32 | 	}
33 | 
34 | 	public function dot($v)
35 | 	{
36 | 		return ($this->x * $v->x) + ($this->y * $v->y);
37 | 	}
38 | 
39 | 	public function normalize()
40 | 	{
41 | 		$magnitude = sqrt($this->dot($this));
42 | 		if ($magnitude == 0) return new static(0, 0);
43 | 		return $this->scale(1.0 / $magnitude);
44 | 	}
45 | 
46 | 	public function __toString()
47 | 	{
48 | 		return sprintf('(%f, %f)', $this->x, $this->y);
49 | 	}
50 | }
51 | 


--------------------------------------------------------------------------------
/roll-avg/swift/rolling-avg/rolling-avg/main.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  main.swift
 3 | //  rolling-avg
 4 | //
 5 | //  Created by Alex Nichol on 7/10/14.
 6 | //  Copyright (c) 2014 Alex Nichol. All rights reserved.
 7 | //
 8 | 
 9 | import Foundation
10 | 
11 | func addUpTo(dest: Int) -> Int {
12 |   var sum : Int = 0
13 |   var i : Int = 1
14 |   // note here that range based for loops are a LOT slower!
15 |   while i <= dest {
16 |     sum += i
17 |     i++
18 |   }
19 |   return sum
20 | }
21 | 
22 | func rollAverage(dest: Int) -> Double {
23 |   var average : Double = 0
24 |   // see note in addUpTo()
25 |   var i : Int = 0
26 |   while i < dest {
27 |     average = (average + Double(addUpTo(i))) / 2.0
28 |     i++
29 |   }
30 |   return average
31 | }
32 | 
33 | if C_ARGC != 3 {
34 |   println("Usage: ./rolling-avg <start> <end>")
35 |   exit(1)
36 | }
37 | 
38 | let start = String.fromCString(C_ARGV[1])!.toInt()!
39 | let end = String.fromCString(C_ARGV[2])!.toInt()!
40 | 
41 | for i in start...end {
42 |   println("rollAverage(\(i)) = \(rollAverage(Int(i)))")
43 | }
44 | 


--------------------------------------------------------------------------------
/force-field/swift/force-field/force-field/Particle.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Particle.swift
 3 | //  force-field
 4 | //
 5 | //  Created by Alex Nichol on 7/12/14.
 6 | //  Copyright (c) 2014 Alex Nichol. All rights reserved.
 7 | //
 8 | 
 9 | import Foundation
10 | 
11 | class Particle: Printable {
12 |   var position: Vector;
13 |   var mass: Double;
14 |   var velocity: Vector;
15 |   
16 |   var description: String {
17 |   get {
18 |     return "{Particle mass: \(mass) velocity: \(velocity) position: \(position)}";
19 |   }
20 |   }
21 |   
22 |   init(position _pos: Vector, mass _mass: Double) {
23 |     position = _pos;
24 |     mass = _mass;
25 |     velocity = Vector(x: 0, y: 0);
26 |   }
27 |   
28 |   func forceFrom(p: Particle) -> Vector {
29 |     var distance = p.position - position;
30 |     var magnitude = mass * p.mass / distance.dot(distance);
31 |     return distance.normalize() * magnitude;
32 |   }
33 |   
34 |   func applyForce(force: Vector, timeDelta: Double) {
35 |     velocity += force * (timeDelta / fabs(mass));
36 |     position += velocity * timeDelta;
37 |   }
38 |   
39 | }
40 | 


--------------------------------------------------------------------------------
/force-field/c++/particle.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __FORCE_FIELD_PARTICLE_HPP__
 2 | #define __FORCE_FIELD_PARTICLE_HPP__
 3 | 
 4 | #include "vector.hpp"
 5 | 
 6 | struct Particle {
 7 |   Vector position;
 8 |   double mass;
 9 |   Vector velocity;
10 |   
11 |   Particle(const Vector & pos, double _mass) : position(pos), mass(_mass) {}
12 |   
13 |   Particle() = delete;
14 |   Particle(const Particle & p) = delete;
15 |   Particle & operator=(const Particle & p) = delete;
16 |   
17 |   Vector ForceFrom(const Particle & p) {
18 |     Vector distance = p.position - position;
19 |     
20 |     // G*m1*m1/d^2, assuming G=1
21 |     double magnitude = mass * p.mass / distance.Dot(distance);
22 |     
23 |     return distance.Normalize() * magnitude;
24 |   }
25 |   
26 |   void ApplyForce(Vector force, double timeDelta) {
27 |     velocity += force * (timeDelta / fabs(mass));
28 |     position += velocity * timeDelta;
29 |   }
30 | };
31 | 
32 | std::ostream & operator<<(std::ostream & stream, const Particle & v) {
33 |   return stream << "{Particle mass: " << v.mass << " velocity: "
34 |     << v.velocity << " position: " << v.position << "}";
35 | }
36 | 
37 | #endif
38 | 


--------------------------------------------------------------------------------
/force-field/rust/particle.rs:
--------------------------------------------------------------------------------
 1 | use std::fmt::{Display, Formatter, Result};
 2 | 
 3 | use super::vector::Vector;
 4 | 
 5 | pub struct Particle {
 6 |   pub position: Vector,
 7 |   pub mass: f64,
 8 |   velocity: Vector,
 9 | }
10 | 
11 | impl Particle {
12 |   pub fn new(position: Vector, mass: f64) -> Particle {
13 |     Particle {
14 |       position: position,
15 |       mass: mass,
16 |       velocity: Vector::new(),
17 |     }
18 |   }
19 | 
20 |   pub fn force_from(&self, other: &Particle) -> Vector {
21 |     let distance = other.position - self.position;
22 | 
23 |     // G*m1*m1/d^2, assuming G=1
24 |     let magnitude = self.mass * other.mass / distance.dot(&distance);
25 | 
26 |     magnitude * distance.normalize()
27 |   }
28 | 
29 |   pub fn apply_force(&mut self, force: Vector, time_delta: f64) {
30 |     self.velocity += (time_delta / self.mass.abs()) * force;
31 |     self.position += time_delta * self.velocity;
32 |   }
33 | }
34 | 
35 | impl Display for Particle {
36 |   fn fmt(&self, f: &mut Formatter) -> Result {
37 |     write!(
38 |       f,
39 |       "{{Particle mass: {} velocity: {} position: {}}}",
40 |       self.mass,
41 |       self.velocity,
42 |       self.position
43 |     )
44 |   }
45 | }
46 | 


--------------------------------------------------------------------------------
/force-field/cs/Vector.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace ForceField {
 4 | 
 5 |   public class Vector {
 6 |     
 7 |     public double x;
 8 |     public double y;
 9 |     
10 |     public Vector(double _x, double _y) {
11 |       this.x = _x;
12 |       this.y = _y;
13 |     }
14 |     
15 |     public Vector() {
16 |       this.x = 0;
17 |       this.y = 0;
18 |     }
19 |     
20 |     public Vector subtract(Vector v) {
21 |       return new Vector(x - v.x, y - v.y);
22 |     }
23 |     
24 |     public Vector add(Vector v) {
25 |       return new Vector(x + v.x, y + v.y);
26 |     }
27 |     
28 |     public Vector scale(double d) {
29 |       return new Vector(x * d, y * d);
30 |     }
31 |     
32 |     public void addInPlace(Vector v) {
33 |       x += v.x;
34 |       y += v.y;
35 |     }
36 |     
37 |     public double dot(Vector v) {
38 |       return x * v.x + y * v.y;
39 |     }
40 |     
41 |     public Vector normalize() {
42 |       double magnitude = Math.Sqrt(dot(this));
43 |       if (magnitude == 0.0) return new Vector(0, 0);
44 |       return scale(1.0 / magnitude);
45 |     }
46 |     
47 |     public override string ToString() {
48 |       return "(" + x + ", " + y + ")";
49 |     }
50 |     
51 |   }
52 |   
53 | }
54 | 


--------------------------------------------------------------------------------
/force-field/swift/force-field/force-field/Vector.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  Vector.swift
 3 | //  force-field
 4 | //
 5 | //  Created by Alex Nichol on 7/12/14.
 6 | //  Copyright (c) 2014 Alex Nichol. All rights reserved.
 7 | //
 8 | 
 9 | import Foundation
10 | 
11 | struct Vector: Printable {
12 |   var x: Double
13 |   var y: Double
14 |   
15 |   var description: String {
16 |   get {
17 |     return "(\(x), \(y))";
18 |   }
19 |   }
20 |   
21 |   init(x _x: Double, y _y: Double) {
22 |     x = _x;
23 |     y = _y;
24 |   }
25 |   
26 |   func dot(v: Vector) -> Double {
27 |     return x * v.x + y * v.y;
28 |   }
29 |   
30 |   func normalize() -> Vector {
31 |     var magnitude = sqrt(dot(self));
32 |     if (magnitude == 0) {
33 |       return Vector(x: 0, y: 0);
34 |     }
35 |     return self * (1/magnitude);
36 |   }
37 |   
38 | }
39 | 
40 | func *(lhs: Vector, rhs: Double) -> Vector {
41 |   return Vector(x: lhs.x * rhs, y: lhs.y * rhs);
42 | }
43 | 
44 | func +(lhs: Vector, rhs: Vector) -> Vector {
45 |   return Vector(x: lhs.x + rhs.x, y: lhs.y + rhs.y);
46 | }
47 | 
48 | func -(lhs: Vector, rhs: Vector) -> Vector {
49 |   return Vector(x: lhs.x - rhs.x, y: lhs.y - rhs.y);
50 | }
51 | 
52 | func += (inout left: Vector, right: Vector) {
53 |   left = left + right;
54 | }
55 | 


--------------------------------------------------------------------------------
/force-field/c++/vector.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __FORCE_FIELD_VECTOR_HPP__
 2 | #define __FORCE_FIELD_VECTOR_HPP__
 3 | 
 4 | #include <cmath>
 5 | #include <iostream>
 6 | 
 7 | /**
 8 |  * A simple 2D vector.
 9 |  */
10 | struct Vector {
11 |   double x;
12 |   double y;
13 |   
14 |   Vector() : x(0), y(0) {}
15 |   Vector(double _x, double _y) : x(_x), y(_y) {}
16 |   Vector(const Vector & v) : x(v.x), y(v.y) {}
17 |   
18 |   Vector & operator=(const Vector & v) {
19 |     x = v.x;
20 |     y = v.y;
21 |     return *this;
22 |   }
23 |   
24 |   Vector operator-(const Vector & v) const {
25 |     return Vector(x - v.x, y - v.y);
26 |   }
27 |   
28 |   Vector operator+(const Vector & v) const {
29 |     return Vector(x + v.x, y + v.y);
30 |   }
31 |   
32 |   Vector operator*(double d) const {
33 |     return Vector(x * d, y * d);
34 |   }
35 |   
36 |   Vector operator+=(Vector v) {
37 |     x += v.x;
38 |     y += v.y;
39 |     return *this;
40 |   }
41 |   
42 |   double Dot(const Vector & v) const {
43 |     return x * v.x + y * v.y;
44 |   }
45 |   
46 |   Vector Normalize() const {
47 |     double magnitude = sqrt(Dot(*this));
48 |     if (magnitude == 0) return Vector(0, 0);
49 |     return (*this) * (1.0 / magnitude);
50 |   }
51 | };
52 | 
53 | std::ostream & operator<<(std::ostream & stream, const Vector & v) {
54 |   return stream << "(" << v.x << ", " << v.y << ")";
55 | }
56 | 
57 | #endif
58 | 


--------------------------------------------------------------------------------
/roll-avg/c/excursion/long command.txt:
--------------------------------------------------------------------------------
1 | # these flags will not provide the same optimization as -O2 because of the lack of -indvars
2 | 
3 | opt  -targetlibinfo -no-aa -tbaa -basicaa -notti -preverify -domtree -verify -globalopt -ipsccp -deadargelim -instcombine -simplifycfg -basiccg -prune-eh -inline-cost -inline -functionattrs -argpromotion -sroa -domtree -early-cse -lazy-value-info -jump-threading -correlated-propagation -simplifycfg -instcombine -tailcallelim -simplifycfg -reassociate -domtree -loops -loop-simplify -lcssa -loop-rotate -licm -lcssa -loop-unswitch -instcombine -scalar-evolution -loop-simplify -lcssa -loop-idiom -loop-deletion -loop-unroll -memdep -gvn -memdep -memcpyopt -sccp -instcombine -lazy-value-info -jump-threading -correlated-propagation -domtree -memdep -dse -adce -simplifycfg -instcombine -strip-dead-prototypes -globaldce -constmerge -globalopt -ipsccp -deadargelim -instcombine -simplifycfg -basiccg -prune-eh -inline-cost -inline -functionattrs -sroa -domtree -early-cse -lazy-value-info -jump-threading -correlated-propagation -simplifycfg -instcombine -tailcallelim -simplifycfg -reassociate -domtree -loops -loop-simplify -lcssa -loop-rotate -licm -lcssa -loop-unswitch -instcombine -scalar-evolution -loop-simplify -lcssa -loop-idiom -loop-deletion -loop-unroll -memdep -gvn -memdep -memcpyopt -sccp -instcombine -lazy-value-info -jump-threading -correlated-propagation -domtree -memdep -dse -loops -scalar-evolution -slp-vectorizer -adce -simplifycfg -instcombine -domtree -loops -loop-simplify -lcssa -scalar-evolution -loop-simplify -lcssa -loop-vectorize -instcombine -simplifycfg -strip-dead-prototypes -globaldce -constmerge -preverify -domtree -verify func1_unopt.s -o func1.bc && llc func1.bc


--------------------------------------------------------------------------------
/force-field/rust/vector.rs:
--------------------------------------------------------------------------------
 1 | use std::fmt::{Display, Formatter, Result};
 2 | use std::ops::{Add, AddAssign, Mul, Sub};
 3 | 
 4 | #[derive(Copy, Clone)]
 5 | pub struct Vector {
 6 |   pub x: f64,
 7 |   pub y: f64,
 8 | }
 9 | 
10 | impl Vector {
11 |   pub fn new() -> Vector {
12 |     Vector {
13 |       x: 0f64,
14 |       y: 0f64,
15 |     }
16 |   }
17 | 
18 |   pub fn from(x: f64, y: f64) -> Vector {
19 |     Vector {
20 |       x: x,
21 |       y: y,
22 |     }
23 |   }
24 | 
25 |   pub fn dot(&self, v: &Vector) -> f64 {
26 |     self.x * v.x + self.y * v.y
27 |   }
28 | 
29 |   pub fn normalize(&self) -> Vector {
30 |     let magnitude = self.dot(&self).sqrt();
31 | 
32 |     if magnitude == 0f64 {
33 |       return Vector::new();
34 |     }
35 | 
36 |     (1f64 / magnitude) * *self
37 |   }
38 | }
39 | 
40 | impl Add for Vector {
41 |   type Output = Vector;
42 | 
43 |   fn add(self, other: Vector) -> Vector {
44 |     Vector::from(self.x + other.x, self.y + other.y)
45 |   }
46 | }
47 | 
48 | impl AddAssign for Vector {
49 |   fn add_assign(&mut self, other: Vector) {
50 |     *self = Vector {
51 |       x: self.x + other.x,
52 |       y: self.y + other.y,
53 |     }
54 |   }
55 | }
56 | 
57 | impl Sub for Vector {
58 |   type Output = Vector;
59 | 
60 |   fn sub(self, other: Vector) -> Vector {
61 |     Vector::from(self.x - other.x, self.y - other.y)
62 |   }
63 | }
64 | 
65 | impl Mul<Vector> for f64 {
66 |   type Output = Vector;
67 | 
68 |   fn mul(self, vector: Vector) -> Vector {
69 |     Vector::from(vector.x * self, vector.y * self)
70 |   }
71 | }
72 | 
73 | impl Display for Vector {
74 |   fn fmt(&self, f: &mut Formatter) -> Result {
75 |     write!(f, "({}, {})", self.x, self.y)
76 |   }
77 | }
78 | 


--------------------------------------------------------------------------------
/roll-avg/swift/rolling-avg/rolling-avg.xcodeproj/project.xcworkspace/xcshareddata/rolling-avg.xccheckout:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 3 | <plist version="1.0">
 4 | <dict>
 5 | 	<key>IDESourceControlProjectFavoriteDictionaryKey</key>
 6 | 	<false/>
 7 | 	<key>IDESourceControlProjectIdentifier</key>
 8 | 	<string>860D33D9-ACD0-4743-9874-A9D67369F89F</string>
 9 | 	<key>IDESourceControlProjectName</key>
10 | 	<string>rolling-avg</string>
11 | 	<key>IDESourceControlProjectOriginsDictionary</key>
12 | 	<dict>
13 | 		<key>7D114AA2ECC3D6ABCBBC30A7900195C73C3E79FA</key>
14 | 		<string>github.com:unixpickle/Benchmarks.git</string>
15 | 	</dict>
16 | 	<key>IDESourceControlProjectPath</key>
17 | 	<string>roll-avg/swift/rolling-avg/rolling-avg.xcodeproj</string>
18 | 	<key>IDESourceControlProjectRelativeInstallPathDictionary</key>
19 | 	<dict>
20 | 		<key>7D114AA2ECC3D6ABCBBC30A7900195C73C3E79FA</key>
21 | 		<string>../../../../..</string>
22 | 	</dict>
23 | 	<key>IDESourceControlProjectURL</key>
24 | 	<string>github.com:unixpickle/Benchmarks.git</string>
25 | 	<key>IDESourceControlProjectVersion</key>
26 | 	<integer>111</integer>
27 | 	<key>IDESourceControlProjectWCCIdentifier</key>
28 | 	<string>7D114AA2ECC3D6ABCBBC30A7900195C73C3E79FA</string>
29 | 	<key>IDESourceControlProjectWCConfigurations</key>
30 | 	<array>
31 | 		<dict>
32 | 			<key>IDESourceControlRepositoryExtensionIdentifierKey</key>
33 | 			<string>public.vcs.git</string>
34 | 			<key>IDESourceControlWCCIdentifierKey</key>
35 | 			<string>7D114AA2ECC3D6ABCBBC30A7900195C73C3E79FA</string>
36 | 			<key>IDESourceControlWCCName</key>
37 | 			<string>Benchmarks</string>
38 | 		</dict>
39 | 	</array>
40 | </dict>
41 | </plist>
42 | 


--------------------------------------------------------------------------------
/force-field/swift/force-field/force-field.xcodeproj/project.xcworkspace/xcshareddata/force-field.xccheckout:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 3 | <plist version="1.0">
 4 | <dict>
 5 | 	<key>IDESourceControlProjectFavoriteDictionaryKey</key>
 6 | 	<false/>
 7 | 	<key>IDESourceControlProjectIdentifier</key>
 8 | 	<string>3F539233-A3A2-4FEC-AB31-C121559B243E</string>
 9 | 	<key>IDESourceControlProjectName</key>
10 | 	<string>force-field</string>
11 | 	<key>IDESourceControlProjectOriginsDictionary</key>
12 | 	<dict>
13 | 		<key>7D114AA2ECC3D6ABCBBC30A7900195C73C3E79FA</key>
14 | 		<string>github.com:unixpickle/Benchmarks.git</string>
15 | 	</dict>
16 | 	<key>IDESourceControlProjectPath</key>
17 | 	<string>force-field/swift/force-field/force-field.xcodeproj</string>
18 | 	<key>IDESourceControlProjectRelativeInstallPathDictionary</key>
19 | 	<dict>
20 | 		<key>7D114AA2ECC3D6ABCBBC30A7900195C73C3E79FA</key>
21 | 		<string>../../../../..</string>
22 | 	</dict>
23 | 	<key>IDESourceControlProjectURL</key>
24 | 	<string>github.com:unixpickle/Benchmarks.git</string>
25 | 	<key>IDESourceControlProjectVersion</key>
26 | 	<integer>111</integer>
27 | 	<key>IDESourceControlProjectWCCIdentifier</key>
28 | 	<string>7D114AA2ECC3D6ABCBBC30A7900195C73C3E79FA</string>
29 | 	<key>IDESourceControlProjectWCConfigurations</key>
30 | 	<array>
31 | 		<dict>
32 | 			<key>IDESourceControlRepositoryExtensionIdentifierKey</key>
33 | 			<string>public.vcs.git</string>
34 | 			<key>IDESourceControlWCCIdentifierKey</key>
35 | 			<string>7D114AA2ECC3D6ABCBBC30A7900195C73C3E79FA</string>
36 | 			<key>IDESourceControlWCCName</key>
37 | 			<string>Benchmarks</string>
38 | 		</dict>
39 | 	</array>
40 | </dict>
41 | </plist>
42 | 


--------------------------------------------------------------------------------
/array-reverse/swift/array-reverse/array-reverse.xcodeproj/project.xcworkspace/xcshareddata/array-reverse.xccheckout:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 3 | <plist version="1.0">
 4 | <dict>
 5 | 	<key>IDESourceControlProjectFavoriteDictionaryKey</key>
 6 | 	<false/>
 7 | 	<key>IDESourceControlProjectIdentifier</key>
 8 | 	<string>83A03796-6117-482C-B96E-642CE6FA7350</string>
 9 | 	<key>IDESourceControlProjectName</key>
10 | 	<string>array-reverse</string>
11 | 	<key>IDESourceControlProjectOriginsDictionary</key>
12 | 	<dict>
13 | 		<key>7D114AA2ECC3D6ABCBBC30A7900195C73C3E79FA</key>
14 | 		<string>github.com:unixpickle/Benchmarks.git</string>
15 | 	</dict>
16 | 	<key>IDESourceControlProjectPath</key>
17 | 	<string>array-reverse/swift/array-reverse/array-reverse.xcodeproj</string>
18 | 	<key>IDESourceControlProjectRelativeInstallPathDictionary</key>
19 | 	<dict>
20 | 		<key>7D114AA2ECC3D6ABCBBC30A7900195C73C3E79FA</key>
21 | 		<string>../../../../..</string>
22 | 	</dict>
23 | 	<key>IDESourceControlProjectURL</key>
24 | 	<string>github.com:unixpickle/Benchmarks.git</string>
25 | 	<key>IDESourceControlProjectVersion</key>
26 | 	<integer>111</integer>
27 | 	<key>IDESourceControlProjectWCCIdentifier</key>
28 | 	<string>7D114AA2ECC3D6ABCBBC30A7900195C73C3E79FA</string>
29 | 	<key>IDESourceControlProjectWCConfigurations</key>
30 | 	<array>
31 | 		<dict>
32 | 			<key>IDESourceControlRepositoryExtensionIdentifierKey</key>
33 | 			<string>public.vcs.git</string>
34 | 			<key>IDESourceControlWCCIdentifierKey</key>
35 | 			<string>7D114AA2ECC3D6ABCBBC30A7900195C73C3E79FA</string>
36 | 			<key>IDESourceControlWCCName</key>
37 | 			<string>Benchmarks</string>
38 | 		</dict>
39 | 	</array>
40 | </dict>
41 | </plist>
42 | 


--------------------------------------------------------------------------------
/roll-avg/README.md:
--------------------------------------------------------------------------------
 1 | # The test
 2 | 
 3 | This program has a very inefficient subroutine to compute the sum of every integer up to a certain value (i.e. 1 + 2 + 3 + 4 + ... + n). Also included is a function which performs a makeshift average on the sums. Essentially, it averages 1 and 2, then averages that with (1 + 2 + 3), and then averages that with (1 + 2 + 3 + 4), etc. It does this up to a specified maximum. Thus, the (unoptimized) average method runs in O(n^2) time.
 4 | 
 5 | The program takes two arguments which are the start and end indexes. The program will call the rolling average function with each argument between and including these boundaries, printing the result each time.
 6 | 
 7 | If you choose to write your own version of this benchmark, refrain from simplifying methods by using builtins or algorithms to compute sums or averages. The point of this benchmark is to test the language's optimizer to see if *it*&ndash;and not you&ndash;is capable of doing such things.
 8 | 
 9 | # Results
10 | 
11 | You may notice that Swift, Rust, and C are both extremely fast compared to their competition. I wrote a note specifically explaining this [here](c/note.md). Tl;dr, it's because Clang/LLVM was able to realize it could use the summation formula; this makes the program compiled with Clang run in O(n) time rather than O(n^2) time.
12 | 
13 | Every result here is from running the programs with a range of 10,000 to 10,020 (inclusive).
14 | 
15 | | Language   | Time (s) |
16 | |------------|----------|
17 | |C (-O1)     |0.005     |
18 | |C (-O2)     |0.005     |
19 | |C (-O3)     |0.005     |
20 | |Rust        |0.007     |
21 | |Swift       |0.008     |
22 | |Java        |0.463     |
23 | |Go          |0.603     |
24 | |C# (normal) |0.621     |
25 | |C# (-O=all) |0.681     |
26 | |Dart        |1.057     |
27 | |JavaScript  |1.312     |
28 | |C (-O0)     |2.763     |
29 | |Ruby        |31.582    |
30 | |PHP         |40.925    |
31 | |Python 2    |71.550    |
32 | |Python 3    |81.143    |
33 | 


--------------------------------------------------------------------------------
/force-field/go/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"math"
 6 | 	"os"
 7 | 	"strconv"
 8 | )
 9 | 
10 | func main() {
11 | 	if len(os.Args) != 3 {
12 | 		fmt.Fprintln(os.Stderr, "Usage: force-field <time delta> <count>")
13 | 		os.Exit(1)
14 | 	}
15 | 
16 | 	timeDelta, _ := strconv.ParseFloat(os.Args[1], 64)
17 | 	count, _ := strconv.Atoi(os.Args[2])
18 | 
19 | 	p1 := Particle{Vector{0.3, 0}, -1, Vector{0, 0}}
20 | 	p2 := Particle{Vector{-0.3, 1}, 1, Vector{0, 0}}
21 | 	for i := 0; i < count; i++ {
22 | 		force1 := p1.ForceFrom(&p2)
23 | 		force2 := p2.ForceFrom(&p1)
24 | 		p1.ApplyForce(force1, timeDelta)
25 | 		p2.ApplyForce(force2, timeDelta)
26 | 	}
27 | 
28 | 	fmt.Println("p1 =", p1)
29 | 	fmt.Println("p2 =", p2)
30 | }
31 | 
32 | type Particle struct {
33 | 	Position Vector
34 | 	Mass     float64
35 | 	Velocity Vector
36 | }
37 | 
38 | func (p *Particle) ApplyForce(force Vector, timeDelta float64) {
39 | 	AddInPlace(&p.Velocity, force.Scale(timeDelta/math.Abs(p.Mass)))
40 | 	AddInPlace(&p.Position, p.Velocity.Scale(timeDelta))
41 | }
42 | 
43 | func (p *Particle) ForceFrom(p1 *Particle) Vector {
44 | 	distance := p1.Position.Subtract(p.Position)
45 | 	magnitude := p.Mass * p1.Mass / distance.Dot(distance)
46 | 	return distance.Normalize().Scale(magnitude)
47 | }
48 | 
49 | func (p *Particle) String() string {
50 | 	return fmt.Sprintf("{Particle mass: %f velocity: %s position: %s}",
51 | 		p.Mass, p.Velocity.String(), p.Position.String())
52 | }
53 | 
54 | type Vector struct {
55 | 	X float64
56 | 	Y float64
57 | }
58 | 
59 | func (v Vector) Add(v2 Vector) Vector {
60 | 	return Vector{v.X + v2.X, v.Y + v2.Y}
61 | }
62 | 
63 | func (v Vector) Dot(v2 Vector) float64 {
64 | 	return v.X*v2.X + v.Y*v2.Y
65 | }
66 | 
67 | func (v Vector) Normalize() Vector {
68 | 	magnitude := math.Sqrt(v.Dot(v))
69 | 	if magnitude == 0 {
70 | 		return Vector{0, 0}
71 | 	}
72 | 	return v.Scale(1.0 / magnitude)
73 | }
74 | 
75 | func (v Vector) Scale(scaler float64) Vector {
76 | 	return Vector{v.X * scaler, v.Y * scaler}
77 | }
78 | 
79 | func (v Vector) String() string {
80 | 	return fmt.Sprintf("(%f, %f)", v.X, v.Y)
81 | }
82 | 
83 | func (v Vector) Subtract(v2 Vector) Vector {
84 | 	return Vector{v.X - v2.X, v.Y - v2.Y}
85 | }
86 | 
87 | func AddInPlace(v *Vector, v2 Vector) {
88 | 	v.X += v2.X
89 | 	v.Y += v2.Y
90 | }
91 | 


--------------------------------------------------------------------------------
/array-reverse/README.md:
--------------------------------------------------------------------------------
 1 | # The test
 2 | 
 3 | This program takes two arguments: the size of an array, and the number of times to reverse it. It creates the array as a sequential list of integers, and then calls a `reverseArray` method in a loop.
 4 | 
 5 | This test shows how close a language's array performance comes to raw memory performance. Additionally, it requires a tight loop and many function calls.
 6 | 
 7 | **The true purpose of this test isn't to see how fast a language can reverse an array.** The test is to see how efficient a langauge's array access/write times are. However, I understand that many languages include a builtin method for reversing an array. You should feel free to write two tests, one with this method and one without it. This way, you can also test your language's direct ability to reverse an array.
 8 | 
 9 | The creation of the array is *not* particularly on display, so you may use a builtin to create it (i.e. Python's `range()`). This is because the time to create the array is insignificant compared to the numerous iterations of the `reverseArray()` call.
10 | 
11 | # Results
12 | 
13 | These results all use a list of 100,000 elements. Some results will be scaled (since the Python and Ruby tests take too long otherwise). The end measurement is how long it took (or *would* take) to reverse the array 100,000 times.
14 | 
15 | | Language   | Time (s) |
16 | |------------|----------|
17 | |Java        |3.776     |
18 | |C (-O3)     |4.273     |
19 | |C (-O2)     |4.367     |
20 | |C (-O1)     |4.395     |
21 | |Rust        |5.698     |
22 | |Go          |7.825     |
23 | |C# (-O=all) |8.378     |
24 | |Dart        |8.988     |
25 | |JavaScript  |13.162    |
26 | |C# (normal) |14.071    |
27 | |C (-O0)     |17.034    |
28 | |Swift       |25.658    |
29 | |Ruby        |1439      |
30 | |Python 3    |1466      |
31 | |Python 2    |1485      |
32 | 
33 | For the tests up to and including *Swift* I used the full 100,000 iterations. For Ruby and both Pythons, I used 500 iterations and scaled up by 200.
34 | 
35 | I do not include PHP here because I discovered that PHP's array does not appear to operate in O(1) time like in other languages. See my [note](php/note.md)
36 | 
37 | # Results with builtins
38 | 
39 | These results use each language's "builtin" reverse method. Interestingly, JavaScript's Array.reverse() is actually slower than reversing the array manually in this case. The rest of the reverse builtins are inline with the optimized C performance.
40 | 
41 | | Language  | Time (s) |
42 | |-----------|----------|
43 | |Python 2   |4.520     |
44 | |Python 3   |4.558     |
45 | |Ruby       |4.591     |
46 | |Rust       |5.565     |
47 | |JavaScript |27.748    |
48 | |PHP        |765.8     |
49 | 
50 | The PHP benchmark was run using 1000 iterations and scaling by 100.
51 | 


--------------------------------------------------------------------------------
/force-field/README.md:
--------------------------------------------------------------------------------
 1 | # The test
 2 | 
 3 | This test uses object orientation to compute a discrete approximation of electrostatic (inverse square) repulsion. It creates two "particles" and continually computes the force vectors each one has on the other. It then applies these forces to the particles' velocities, and then it applies the velocities to the particles' positions.
 4 | 
 5 | The program takes two arguments: the discrete amount of time between each "frame" and the number of frames to approximate with.
 6 | 
 7 | This is the most involved of the benchmarks I've created so far. It primarily serves to test a language's object creation/destruction efficiency. It also serves to test floating point and vectorization optimizations of a language.
 8 | 
 9 | Because this is the most involved test, there are many slight differences between each implementation. For example, in some languages I was able to use operator overloading, while in others I needed to create regular methods to perform the equivalent operations. If you have any suggestions on how to make this test more fair, go ahead and leave a pull request demonstrating how your change affects the results.
10 | 
11 | **This benchmark serves two purposes which may conflict if you choose to rewrite it in a different language.** While this benchmark tests object creation/destruction performance, it also guages a language's ability to perform vector arithmetic. Thus, if you write your own implementation of this in a language that has native vector support, you may want to write a version with the native vector type, and a version with your own custom vector implementation. This way, one test will guage the performance of custom object management, while the other will show the language's vectorization optimizations.
12 | 
13 | # Results
14 | 
15 | For this test I found it appropriate to use C++ instead of C. In C++, I use stack allocation exclusively to avoid expensive allocations. I believe that this is fair because few languages explicitly support such a feature.
16 | 
17 | The times record how long it would take to run the program with a time delta of 0.0001 and a count of 50,000,000. Some results are scaled.
18 | 
19 | | Language   | Time (s) |
20 | |------------|----------|
21 | |C++ (-O2)   |1.892     |
22 | |C++ (-O3)   |1.895     |
23 | |Rust        |2.105     |
24 | |Java        |2.469     |
25 | |Go          |3.581     |
26 | |C++ (-O1)   |5.290     |
27 | |Dart        |5.844     |
28 | |Swift       |7.675     |
29 | |C++ (-O0)   |7.773     |
30 | |C# (-O=all) |10.639    |
31 | |C# (normal) |10.712    |
32 | |JavaScript  |16.159    |
33 | |Ruby        |300.4     |
34 | |PHP         |557.2     |
35 | |Python 2    |717.2     |
36 | |Python 3    |880.7     |
37 | 
38 | Both Pythons were recorded with 500000 iterations and scaled up by a factor of 100. Ruby and PHP were recorded with 1000000 iterations and scaled up by a factor of 50.
39 | 


--------------------------------------------------------------------------------
/force-field/swift/force-field/force-field.xcodeproj/xcuserdata/alex.xcuserdatad/xcschemes/force-field.xcscheme:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <Scheme
 3 |    LastUpgradeVersion = "0600"
 4 |    version = "1.3">
 5 |    <BuildAction
 6 |       parallelizeBuildables = "YES"
 7 |       buildImplicitDependencies = "YES">
 8 |       <BuildActionEntries>
 9 |          <BuildActionEntry
10 |             buildForTesting = "YES"
11 |             buildForRunning = "YES"
12 |             buildForProfiling = "YES"
13 |             buildForArchiving = "YES"
14 |             buildForAnalyzing = "YES">
15 |             <BuildableReference
16 |                BuildableIdentifier = "primary"
17 |                BlueprintIdentifier = "FABFCB98197211810093E1E1"
18 |                BuildableName = "force-field"
19 |                BlueprintName = "force-field"
20 |                ReferencedContainer = "container:force-field.xcodeproj">
21 |             </BuildableReference>
22 |          </BuildActionEntry>
23 |       </BuildActionEntries>
24 |    </BuildAction>
25 |    <TestAction
26 |       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
27 |       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
28 |       shouldUseLaunchSchemeArgsEnv = "YES"
29 |       buildConfiguration = "Debug">
30 |       <Testables>
31 |       </Testables>
32 |       <MacroExpansion>
33 |          <BuildableReference
34 |             BuildableIdentifier = "primary"
35 |             BlueprintIdentifier = "FABFCB98197211810093E1E1"
36 |             BuildableName = "force-field"
37 |             BlueprintName = "force-field"
38 |             ReferencedContainer = "container:force-field.xcodeproj">
39 |          </BuildableReference>
40 |       </MacroExpansion>
41 |    </TestAction>
42 |    <LaunchAction
43 |       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
44 |       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
45 |       launchStyle = "0"
46 |       useCustomWorkingDirectory = "NO"
47 |       buildConfiguration = "Debug"
48 |       ignoresPersistentStateOnLaunch = "NO"
49 |       debugDocumentVersioning = "YES"
50 |       allowLocationSimulation = "YES">
51 |       <BuildableProductRunnable>
52 |          <BuildableReference
53 |             BuildableIdentifier = "primary"
54 |             BlueprintIdentifier = "FABFCB98197211810093E1E1"
55 |             BuildableName = "force-field"
56 |             BlueprintName = "force-field"
57 |             ReferencedContainer = "container:force-field.xcodeproj">
58 |          </BuildableReference>
59 |       </BuildableProductRunnable>
60 |       <AdditionalOptions>
61 |       </AdditionalOptions>
62 |    </LaunchAction>
63 |    <ProfileAction
64 |       shouldUseLaunchSchemeArgsEnv = "YES"
65 |       savedToolIdentifier = ""
66 |       useCustomWorkingDirectory = "NO"
67 |       buildConfiguration = "Release"
68 |       debugDocumentVersioning = "YES">
69 |       <BuildableProductRunnable>
70 |          <BuildableReference
71 |             BuildableIdentifier = "primary"
72 |             BlueprintIdentifier = "FABFCB98197211810093E1E1"
73 |             BuildableName = "force-field"
74 |             BlueprintName = "force-field"
75 |             ReferencedContainer = "container:force-field.xcodeproj">
76 |          </BuildableReference>
77 |       </BuildableProductRunnable>
78 |    </ProfileAction>
79 |    <AnalyzeAction
80 |       buildConfiguration = "Debug">
81 |    </AnalyzeAction>
82 |    <ArchiveAction
83 |       buildConfiguration = "Release"
84 |       revealArchiveInOrganizer = "YES">
85 |    </ArchiveAction>
86 | </Scheme>
87 | 


--------------------------------------------------------------------------------
/roll-avg/swift/rolling-avg/rolling-avg.xcodeproj/xcuserdata/alex.xcuserdatad/xcschemes/rolling-avg.xcscheme:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <Scheme
 3 |    LastUpgradeVersion = "0600"
 4 |    version = "1.3">
 5 |    <BuildAction
 6 |       parallelizeBuildables = "YES"
 7 |       buildImplicitDependencies = "YES">
 8 |       <BuildActionEntries>
 9 |          <BuildActionEntry
10 |             buildForTesting = "YES"
11 |             buildForRunning = "YES"
12 |             buildForProfiling = "YES"
13 |             buildForArchiving = "YES"
14 |             buildForAnalyzing = "YES">
15 |             <BuildableReference
16 |                BuildableIdentifier = "primary"
17 |                BlueprintIdentifier = "FA0E8553196F609500955123"
18 |                BuildableName = "rolling-avg"
19 |                BlueprintName = "rolling-avg"
20 |                ReferencedContainer = "container:rolling-avg.xcodeproj">
21 |             </BuildableReference>
22 |          </BuildActionEntry>
23 |       </BuildActionEntries>
24 |    </BuildAction>
25 |    <TestAction
26 |       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
27 |       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
28 |       shouldUseLaunchSchemeArgsEnv = "YES"
29 |       buildConfiguration = "Debug">
30 |       <Testables>
31 |       </Testables>
32 |       <MacroExpansion>
33 |          <BuildableReference
34 |             BuildableIdentifier = "primary"
35 |             BlueprintIdentifier = "FA0E8553196F609500955123"
36 |             BuildableName = "rolling-avg"
37 |             BlueprintName = "rolling-avg"
38 |             ReferencedContainer = "container:rolling-avg.xcodeproj">
39 |          </BuildableReference>
40 |       </MacroExpansion>
41 |    </TestAction>
42 |    <LaunchAction
43 |       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
44 |       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
45 |       launchStyle = "0"
46 |       useCustomWorkingDirectory = "NO"
47 |       buildConfiguration = "Debug"
48 |       ignoresPersistentStateOnLaunch = "NO"
49 |       debugDocumentVersioning = "YES"
50 |       allowLocationSimulation = "YES">
51 |       <BuildableProductRunnable>
52 |          <BuildableReference
53 |             BuildableIdentifier = "primary"
54 |             BlueprintIdentifier = "FA0E8553196F609500955123"
55 |             BuildableName = "rolling-avg"
56 |             BlueprintName = "rolling-avg"
57 |             ReferencedContainer = "container:rolling-avg.xcodeproj">
58 |          </BuildableReference>
59 |       </BuildableProductRunnable>
60 |       <AdditionalOptions>
61 |       </AdditionalOptions>
62 |    </LaunchAction>
63 |    <ProfileAction
64 |       shouldUseLaunchSchemeArgsEnv = "YES"
65 |       savedToolIdentifier = ""
66 |       useCustomWorkingDirectory = "NO"
67 |       buildConfiguration = "Release"
68 |       debugDocumentVersioning = "YES">
69 |       <BuildableProductRunnable>
70 |          <BuildableReference
71 |             BuildableIdentifier = "primary"
72 |             BlueprintIdentifier = "FA0E8553196F609500955123"
73 |             BuildableName = "rolling-avg"
74 |             BlueprintName = "rolling-avg"
75 |             ReferencedContainer = "container:rolling-avg.xcodeproj">
76 |          </BuildableReference>
77 |       </BuildableProductRunnable>
78 |    </ProfileAction>
79 |    <AnalyzeAction
80 |       buildConfiguration = "Debug">
81 |    </AnalyzeAction>
82 |    <ArchiveAction
83 |       buildConfiguration = "Release"
84 |       revealArchiveInOrganizer = "YES">
85 |    </ArchiveAction>
86 | </Scheme>
87 | 


--------------------------------------------------------------------------------
/array-reverse/swift/array-reverse/array-reverse.xcodeproj/xcuserdata/alex.xcuserdatad/xcschemes/array-reverse.xcscheme:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <Scheme
 3 |    LastUpgradeVersion = "0600"
 4 |    version = "1.3">
 5 |    <BuildAction
 6 |       parallelizeBuildables = "YES"
 7 |       buildImplicitDependencies = "YES">
 8 |       <BuildActionEntries>
 9 |          <BuildActionEntry
10 |             buildForTesting = "YES"
11 |             buildForRunning = "YES"
12 |             buildForProfiling = "YES"
13 |             buildForArchiving = "YES"
14 |             buildForAnalyzing = "YES">
15 |             <BuildableReference
16 |                BuildableIdentifier = "primary"
17 |                BlueprintIdentifier = "FAC83AC51970A1F100E03EAC"
18 |                BuildableName = "array-reverse"
19 |                BlueprintName = "array-reverse"
20 |                ReferencedContainer = "container:array-reverse.xcodeproj">
21 |             </BuildableReference>
22 |          </BuildActionEntry>
23 |       </BuildActionEntries>
24 |    </BuildAction>
25 |    <TestAction
26 |       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
27 |       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
28 |       shouldUseLaunchSchemeArgsEnv = "YES"
29 |       buildConfiguration = "Debug">
30 |       <Testables>
31 |       </Testables>
32 |       <MacroExpansion>
33 |          <BuildableReference
34 |             BuildableIdentifier = "primary"
35 |             BlueprintIdentifier = "FAC83AC51970A1F100E03EAC"
36 |             BuildableName = "array-reverse"
37 |             BlueprintName = "array-reverse"
38 |             ReferencedContainer = "container:array-reverse.xcodeproj">
39 |          </BuildableReference>
40 |       </MacroExpansion>
41 |    </TestAction>
42 |    <LaunchAction
43 |       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
44 |       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
45 |       launchStyle = "0"
46 |       useCustomWorkingDirectory = "NO"
47 |       buildConfiguration = "Debug"
48 |       ignoresPersistentStateOnLaunch = "NO"
49 |       debugDocumentVersioning = "YES"
50 |       allowLocationSimulation = "YES">
51 |       <BuildableProductRunnable>
52 |          <BuildableReference
53 |             BuildableIdentifier = "primary"
54 |             BlueprintIdentifier = "FAC83AC51970A1F100E03EAC"
55 |             BuildableName = "array-reverse"
56 |             BlueprintName = "array-reverse"
57 |             ReferencedContainer = "container:array-reverse.xcodeproj">
58 |          </BuildableReference>
59 |       </BuildableProductRunnable>
60 |       <AdditionalOptions>
61 |       </AdditionalOptions>
62 |    </LaunchAction>
63 |    <ProfileAction
64 |       shouldUseLaunchSchemeArgsEnv = "YES"
65 |       savedToolIdentifier = ""
66 |       useCustomWorkingDirectory = "NO"
67 |       buildConfiguration = "Release"
68 |       debugDocumentVersioning = "YES">
69 |       <BuildableProductRunnable>
70 |          <BuildableReference
71 |             BuildableIdentifier = "primary"
72 |             BlueprintIdentifier = "FAC83AC51970A1F100E03EAC"
73 |             BuildableName = "array-reverse"
74 |             BlueprintName = "array-reverse"
75 |             ReferencedContainer = "container:array-reverse.xcodeproj">
76 |          </BuildableReference>
77 |       </BuildableProductRunnable>
78 |    </ProfileAction>
79 |    <AnalyzeAction
80 |       buildConfiguration = "Debug">
81 |    </AnalyzeAction>
82 |    <ArchiveAction
83 |       buildConfiguration = "Release"
84 |       revealArchiveInOrganizer = "YES">
85 |    </ArchiveAction>
86 | </Scheme>
87 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Benchmarks
  2 | 
  3 | These are some simple language benchmarks I am running on the following programming languages:
  4 | 
  5 |  * C/C++ - Apple LLVM version 5.0 (clang-500.2.79)
  6 |  * Dart VM version: 1.8.5 (Tue Jan 13 13:04:11 2015) on "macos_ia32"
  7 |  * Java - java version "1.7.0_71"
  8 |  * JavaScript - v8 (under node v0.10.29)
  9 |  * Python - both 3.3.0 and 2.7.5
 10 |  * Ruby - ruby 2.0.0p451 (2014-02-24 revision 45167)
 11 |  * Swift - Xcode Version 6.1.1 (6A2008a)
 12 |  * PHP - PHP 5.6.5 (cli)
 13 |  * Go - go version go1.4 darwin/amd64
 14 |  * C# - Mono JIT compiler version 3.12.0 + Mono C# compiler version 3.12.0.0
 15 |  * Rust - rustc 1.18.0-nightly (c58c928e6 2017-04-11)
 16 | 
 17 | These benchmarks compare performance characteristics of 10 different programming languages. Each benchmark includes a nearly identical implementation of the same program in each language. The pre-calculated statistics found in this repository were all collected on the same machine with a 2.6GHz Intel Core i7 with 1600 MHz DDR3 RAM. The first set of benchmarks were run under Mac OS X 10.9.3; the second were run under Mac OS X 10.10 (14A389).
 18 | 
 19 | # Results
 20 | 
 21 | Here is a recap of each of the three benchmarks I have done so far. You should really, really read the benchmark-specific README if you notice anything unusual.
 22 | 
 23 | [Force field benchmark](force-field)
 24 | 
 25 | | Language   | Time (s) |
 26 | |------------|----------|
 27 | |C++ (-O2)   |1.892     |
 28 | |C++ (-O3)   |1.895     |
 29 | |Rust        |2.105     |
 30 | |Java        |2.469     |
 31 | |Go          |3.581     |
 32 | |C++ (-O1)   |5.290     |
 33 | |Dart        |5.844     |
 34 | |Swift       |7.675     |
 35 | |C++ (-O0)   |7.773     |
 36 | |C# (-O=all) |10.639    |
 37 | |C# (normal) |10.712    |
 38 | |JavaScript  |16.159    |
 39 | |Ruby        |300.4     |
 40 | |PHP         |557.2     |
 41 | |Python 2    |717.2     |
 42 | |Python 3    |880.7     |
 43 | 
 44 | [Array reverse benchmark](array-reverse)
 45 | 
 46 | | Language   | Time (s) |
 47 | |------------|----------|
 48 | |Java        |3.776     |
 49 | |C (-O3)     |4.273     |
 50 | |C (-O2)     |4.367     |
 51 | |C (-O1)     |4.395     |
 52 | |Rust        |5.698     |
 53 | |Go          |7.825     |
 54 | |C# (-O=all) |8.378     |
 55 | |Dart        |8.988     |
 56 | |JavaScript  |13.162    |
 57 | |C# (normal) |14.071    |
 58 | |C (-O0)     |17.034    |
 59 | |Swift       |25.658    |
 60 | |Ruby        |1439      |
 61 | |Python 3    |1466      |
 62 | |Python 2    |1485      |
 63 | 
 64 | *PHP is not listed in this table because it runs the array-reverse benchmark in O(n^2) complexity rather than O(n) complexity and is thus "infinitely" slower.*
 65 | 
 66 | [Rolling average benchmark](roll-avg)
 67 | 
 68 | | Language   | Time (s) |
 69 | |------------|----------|
 70 | |C (-O1)     |0.005     |
 71 | |C (-O2)     |0.005     |
 72 | |C (-O3)     |0.005     |
 73 | |Rust        |0.007     |
 74 | |Swift       |0.008     |
 75 | |Java        |0.463     |
 76 | |Go          |0.603     |
 77 | |C# (normal) |0.621     |
 78 | |C# (-O=all) |0.681     |
 79 | |Dart        |1.057     |
 80 | |JavaScript  |1.312     |
 81 | |C (-O0)     |2.763     |
 82 | |Ruby        |31.582    |
 83 | |PHP         |40.925    |
 84 | |Python 2    |71.550    |
 85 | |Python 3    |81.143    |
 86 | 
 87 | *In the rolling average README, you will see an explanation of why C and Swift are so much faster than the rest*
 88 | 
 89 | # Fairness
 90 | 
 91 | I tried very hard to make every implementation of each test close in structure. With that being said, some languages have features others don't, and I could have missed a feature along the way. If this is the case, go ahead and make a pull request or file an issue and explain why I tested a certain language unfairly.
 92 | 
 93 | None of these tests are the "best way" to do what they do. Instead, the tests are *designed* to be inefficient in order to get a significant result from various optimizers.
 94 | 
 95 | # Areas to Compare
 96 | 
 97 | ### Loops
 98 | 
 99 | Some looping mechanisms are better than others. For instance, creating an array with 10000 consecutive integers and then iterating over them is *not* an efficient way to loop. But don't worry, in Python 2 I avoid using `range()` for large loops in favor of `xrange()`.
100 | 
101 | ### Function calls
102 | 
103 | Function calls have overhead. In C with optimizations, this overhead is pretty low and sometimes even non-existant (with inlining). However, in other languages like Python and Ruby, function calls may be rather expensive.
104 | 
105 | ### Arithmetic
106 | 
107 | Arithmetic operations are (mostly) single CPU instructions. It is up to various languages to leverage this to perform to the best of the CPU's ability.
108 | 
109 | ### Memory access
110 | 
111 | Accessing elements in arrays and updating variables should both be speedy operations.
112 | 
113 | ### Object creation
114 | 
115 | Allocating memory through object construction should be very fast. In a langauge like C++, it is sometimes possible to avoid dynamic memory allocation altogether in favor of stack allocation. On the other hand, a langauge like Java forces you to create objects using the `new` operator.
116 | 


--------------------------------------------------------------------------------
/roll-avg/swift/rolling-avg/rolling-avg.xcodeproj/project.pbxproj:
--------------------------------------------------------------------------------
  1 | // !$*UTF8*$!
  2 | {
  3 | 	archiveVersion = 1;
  4 | 	classes = {
  5 | 	};
  6 | 	objectVersion = 46;
  7 | 	objects = {
  8 | 
  9 | /* Begin PBXBuildFile section */
 10 | 		FA0E8558196F609500955123 /* main.swift in Sources */ = {isa = PBXBuildFile; fileRef = FA0E8557196F609500955123 /* main.swift */; };
 11 | /* End PBXBuildFile section */
 12 | 
 13 | /* Begin PBXCopyFilesBuildPhase section */
 14 | 		FA0E8552196F609500955123 /* CopyFiles */ = {
 15 | 			isa = PBXCopyFilesBuildPhase;
 16 | 			buildActionMask = 2147483647;
 17 | 			dstPath = /usr/share/man/man1/;
 18 | 			dstSubfolderSpec = 0;
 19 | 			files = (
 20 | 			);
 21 | 			runOnlyForDeploymentPostprocessing = 1;
 22 | 		};
 23 | /* End PBXCopyFilesBuildPhase section */
 24 | 
 25 | /* Begin PBXFileReference section */
 26 | 		FA0E8554196F609500955123 /* rolling-avg */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "rolling-avg"; sourceTree = BUILT_PRODUCTS_DIR; };
 27 | 		FA0E8557196F609500955123 /* main.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = main.swift; sourceTree = "<group>"; };
 28 | /* End PBXFileReference section */
 29 | 
 30 | /* Begin PBXFrameworksBuildPhase section */
 31 | 		FA0E8551196F609500955123 /* Frameworks */ = {
 32 | 			isa = PBXFrameworksBuildPhase;
 33 | 			buildActionMask = 2147483647;
 34 | 			files = (
 35 | 			);
 36 | 			runOnlyForDeploymentPostprocessing = 0;
 37 | 		};
 38 | /* End PBXFrameworksBuildPhase section */
 39 | 
 40 | /* Begin PBXGroup section */
 41 | 		FA0E854B196F609500955123 = {
 42 | 			isa = PBXGroup;
 43 | 			children = (
 44 | 				FA0E8556196F609500955123 /* rolling-avg */,
 45 | 				FA0E8555196F609500955123 /* Products */,
 46 | 			);
 47 | 			sourceTree = "<group>";
 48 | 		};
 49 | 		FA0E8555196F609500955123 /* Products */ = {
 50 | 			isa = PBXGroup;
 51 | 			children = (
 52 | 				FA0E8554196F609500955123 /* rolling-avg */,
 53 | 			);
 54 | 			name = Products;
 55 | 			sourceTree = "<group>";
 56 | 		};
 57 | 		FA0E8556196F609500955123 /* rolling-avg */ = {
 58 | 			isa = PBXGroup;
 59 | 			children = (
 60 | 				FA0E8557196F609500955123 /* main.swift */,
 61 | 			);
 62 | 			path = "rolling-avg";
 63 | 			sourceTree = "<group>";
 64 | 		};
 65 | /* End PBXGroup section */
 66 | 
 67 | /* Begin PBXNativeTarget section */
 68 | 		FA0E8553196F609500955123 /* rolling-avg */ = {
 69 | 			isa = PBXNativeTarget;
 70 | 			buildConfigurationList = FA0E855B196F609500955123 /* Build configuration list for PBXNativeTarget "rolling-avg" */;
 71 | 			buildPhases = (
 72 | 				FA0E8550196F609500955123 /* Sources */,
 73 | 				FA0E8551196F609500955123 /* Frameworks */,
 74 | 				FA0E8552196F609500955123 /* CopyFiles */,
 75 | 			);
 76 | 			buildRules = (
 77 | 			);
 78 | 			dependencies = (
 79 | 			);
 80 | 			name = "rolling-avg";
 81 | 			productName = "rolling-avg";
 82 | 			productReference = FA0E8554196F609500955123 /* rolling-avg */;
 83 | 			productType = "com.apple.product-type.tool";
 84 | 		};
 85 | /* End PBXNativeTarget section */
 86 | 
 87 | /* Begin PBXProject section */
 88 | 		FA0E854C196F609500955123 /* Project object */ = {
 89 | 			isa = PBXProject;
 90 | 			attributes = {
 91 | 				LastUpgradeCheck = 0600;
 92 | 				ORGANIZATIONNAME = "Alex Nichol";
 93 | 				TargetAttributes = {
 94 | 					FA0E8553196F609500955123 = {
 95 | 						CreatedOnToolsVersion = 6.0;
 96 | 					};
 97 | 				};
 98 | 			};
 99 | 			buildConfigurationList = FA0E854F196F609500955123 /* Build configuration list for PBXProject "rolling-avg" */;
100 | 			compatibilityVersion = "Xcode 3.2";
101 | 			developmentRegion = English;
102 | 			hasScannedForEncodings = 0;
103 | 			knownRegions = (
104 | 				en,
105 | 			);
106 | 			mainGroup = FA0E854B196F609500955123;
107 | 			productRefGroup = FA0E8555196F609500955123 /* Products */;
108 | 			projectDirPath = "";
109 | 			projectRoot = "";
110 | 			targets = (
111 | 				FA0E8553196F609500955123 /* rolling-avg */,
112 | 			);
113 | 		};
114 | /* End PBXProject section */
115 | 
116 | /* Begin PBXSourcesBuildPhase section */
117 | 		FA0E8550196F609500955123 /* Sources */ = {
118 | 			isa = PBXSourcesBuildPhase;
119 | 			buildActionMask = 2147483647;
120 | 			files = (
121 | 				FA0E8558196F609500955123 /* main.swift in Sources */,
122 | 			);
123 | 			runOnlyForDeploymentPostprocessing = 0;
124 | 		};
125 | /* End PBXSourcesBuildPhase section */
126 | 
127 | /* Begin XCBuildConfiguration section */
128 | 		FA0E8559196F609500955123 /* Debug */ = {
129 | 			isa = XCBuildConfiguration;
130 | 			buildSettings = {
131 | 				ALWAYS_SEARCH_USER_PATHS = NO;
132 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
133 | 				CLANG_CXX_LIBRARY = "libc++";
134 | 				CLANG_ENABLE_MODULES = YES;
135 | 				CLANG_ENABLE_OBJC_ARC = YES;
136 | 				CLANG_WARN_BOOL_CONVERSION = YES;
137 | 				CLANG_WARN_CONSTANT_CONVERSION = YES;
138 | 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
139 | 				CLANG_WARN_EMPTY_BODY = YES;
140 | 				CLANG_WARN_ENUM_CONVERSION = YES;
141 | 				CLANG_WARN_INT_CONVERSION = YES;
142 | 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
143 | 				CLANG_WARN_UNREACHABLE_CODE = YES;
144 | 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
145 | 				COPY_PHASE_STRIP = NO;
146 | 				ENABLE_STRICT_OBJC_MSGSEND = YES;
147 | 				GCC_C_LANGUAGE_STANDARD = gnu99;
148 | 				GCC_DYNAMIC_NO_PIC = NO;
149 | 				GCC_OPTIMIZATION_LEVEL = 0;
150 | 				GCC_PREPROCESSOR_DEFINITIONS = (
151 | 					"DEBUG=1",
152 | 					"$(inherited)",
153 | 				);
154 | 				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
155 | 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
156 | 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
157 | 				GCC_WARN_UNDECLARED_SELECTOR = YES;
158 | 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
159 | 				GCC_WARN_UNUSED_FUNCTION = YES;
160 | 				GCC_WARN_UNUSED_VARIABLE = YES;
161 | 				MACOSX_DEPLOYMENT_TARGET = 10.9;
162 | 				MTL_ENABLE_DEBUG_INFO = YES;
163 | 				ONLY_ACTIVE_ARCH = YES;
164 | 				SDKROOT = macosx;
165 | 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
166 | 			};
167 | 			name = Debug;
168 | 		};
169 | 		FA0E855A196F609500955123 /* Release */ = {
170 | 			isa = XCBuildConfiguration;
171 | 			buildSettings = {
172 | 				ALWAYS_SEARCH_USER_PATHS = NO;
173 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
174 | 				CLANG_CXX_LIBRARY = "libc++";
175 | 				CLANG_ENABLE_MODULES = YES;
176 | 				CLANG_ENABLE_OBJC_ARC = YES;
177 | 				CLANG_WARN_BOOL_CONVERSION = YES;
178 | 				CLANG_WARN_CONSTANT_CONVERSION = YES;
179 | 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
180 | 				CLANG_WARN_EMPTY_BODY = YES;
181 | 				CLANG_WARN_ENUM_CONVERSION = YES;
182 | 				CLANG_WARN_INT_CONVERSION = YES;
183 | 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
184 | 				CLANG_WARN_UNREACHABLE_CODE = YES;
185 | 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
186 | 				COPY_PHASE_STRIP = YES;
187 | 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
188 | 				ENABLE_NS_ASSERTIONS = NO;
189 | 				ENABLE_STRICT_OBJC_MSGSEND = YES;
190 | 				GCC_C_LANGUAGE_STANDARD = gnu99;
191 | 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
192 | 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
193 | 				GCC_WARN_UNDECLARED_SELECTOR = YES;
194 | 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
195 | 				GCC_WARN_UNUSED_FUNCTION = YES;
196 | 				GCC_WARN_UNUSED_VARIABLE = YES;
197 | 				MACOSX_DEPLOYMENT_TARGET = 10.9;
198 | 				MTL_ENABLE_DEBUG_INFO = NO;
199 | 				SDKROOT = macosx;
200 | 			};
201 | 			name = Release;
202 | 		};
203 | 		FA0E855C196F609500955123 /* Debug */ = {
204 | 			isa = XCBuildConfiguration;
205 | 			buildSettings = {
206 | 				GCC_OPTIMIZATION_LEVEL = 3;
207 | 				PRODUCT_NAME = "$(TARGET_NAME)";
208 | 				SWIFT_OPTIMIZATION_LEVEL = "-Ounchecked";
209 | 			};
210 | 			name = Debug;
211 | 		};
212 | 		FA0E855D196F609500955123 /* Release */ = {
213 | 			isa = XCBuildConfiguration;
214 | 			buildSettings = {
215 | 				GCC_OPTIMIZATION_LEVEL = 3;
216 | 				PRODUCT_NAME = "$(TARGET_NAME)";
217 | 				SWIFT_OPTIMIZATION_LEVEL = "-Ounchecked";
218 | 			};
219 | 			name = Release;
220 | 		};
221 | /* End XCBuildConfiguration section */
222 | 
223 | /* Begin XCConfigurationList section */
224 | 		FA0E854F196F609500955123 /* Build configuration list for PBXProject "rolling-avg" */ = {
225 | 			isa = XCConfigurationList;
226 | 			buildConfigurations = (
227 | 				FA0E8559196F609500955123 /* Debug */,
228 | 				FA0E855A196F609500955123 /* Release */,
229 | 			);
230 | 			defaultConfigurationIsVisible = 0;
231 | 			defaultConfigurationName = Release;
232 | 		};
233 | 		FA0E855B196F609500955123 /* Build configuration list for PBXNativeTarget "rolling-avg" */ = {
234 | 			isa = XCConfigurationList;
235 | 			buildConfigurations = (
236 | 				FA0E855C196F609500955123 /* Debug */,
237 | 				FA0E855D196F609500955123 /* Release */,
238 | 			);
239 | 			defaultConfigurationIsVisible = 0;
240 | 			defaultConfigurationName = Release;
241 | 		};
242 | /* End XCConfigurationList section */
243 | 	};
244 | 	rootObject = FA0E854C196F609500955123 /* Project object */;
245 | }
246 | 


--------------------------------------------------------------------------------
/array-reverse/swift/array-reverse/array-reverse.xcodeproj/project.pbxproj:
--------------------------------------------------------------------------------
  1 | // !$*UTF8*$!
  2 | {
  3 | 	archiveVersion = 1;
  4 | 	classes = {
  5 | 	};
  6 | 	objectVersion = 46;
  7 | 	objects = {
  8 | 
  9 | /* Begin PBXBuildFile section */
 10 | 		FAC83ACA1970A1F100E03EAC /* main.swift in Sources */ = {isa = PBXBuildFile; fileRef = FAC83AC91970A1F100E03EAC /* main.swift */; };
 11 | /* End PBXBuildFile section */
 12 | 
 13 | /* Begin PBXCopyFilesBuildPhase section */
 14 | 		FAC83AC41970A1F100E03EAC /* CopyFiles */ = {
 15 | 			isa = PBXCopyFilesBuildPhase;
 16 | 			buildActionMask = 2147483647;
 17 | 			dstPath = /usr/share/man/man1/;
 18 | 			dstSubfolderSpec = 0;
 19 | 			files = (
 20 | 			);
 21 | 			runOnlyForDeploymentPostprocessing = 1;
 22 | 		};
 23 | /* End PBXCopyFilesBuildPhase section */
 24 | 
 25 | /* Begin PBXFileReference section */
 26 | 		FAC83AC61970A1F100E03EAC /* array-reverse */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "array-reverse"; sourceTree = BUILT_PRODUCTS_DIR; };
 27 | 		FAC83AC91970A1F100E03EAC /* main.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = main.swift; sourceTree = "<group>"; };
 28 | /* End PBXFileReference section */
 29 | 
 30 | /* Begin PBXFrameworksBuildPhase section */
 31 | 		FAC83AC31970A1F100E03EAC /* Frameworks */ = {
 32 | 			isa = PBXFrameworksBuildPhase;
 33 | 			buildActionMask = 2147483647;
 34 | 			files = (
 35 | 			);
 36 | 			runOnlyForDeploymentPostprocessing = 0;
 37 | 		};
 38 | /* End PBXFrameworksBuildPhase section */
 39 | 
 40 | /* Begin PBXGroup section */
 41 | 		FAC83ABD1970A1F100E03EAC = {
 42 | 			isa = PBXGroup;
 43 | 			children = (
 44 | 				FAC83AC81970A1F100E03EAC /* array-reverse */,
 45 | 				FAC83AC71970A1F100E03EAC /* Products */,
 46 | 			);
 47 | 			sourceTree = "<group>";
 48 | 		};
 49 | 		FAC83AC71970A1F100E03EAC /* Products */ = {
 50 | 			isa = PBXGroup;
 51 | 			children = (
 52 | 				FAC83AC61970A1F100E03EAC /* array-reverse */,
 53 | 			);
 54 | 			name = Products;
 55 | 			sourceTree = "<group>";
 56 | 		};
 57 | 		FAC83AC81970A1F100E03EAC /* array-reverse */ = {
 58 | 			isa = PBXGroup;
 59 | 			children = (
 60 | 				FAC83AC91970A1F100E03EAC /* main.swift */,
 61 | 			);
 62 | 			path = "array-reverse";
 63 | 			sourceTree = "<group>";
 64 | 		};
 65 | /* End PBXGroup section */
 66 | 
 67 | /* Begin PBXNativeTarget section */
 68 | 		FAC83AC51970A1F100E03EAC /* array-reverse */ = {
 69 | 			isa = PBXNativeTarget;
 70 | 			buildConfigurationList = FAC83ACD1970A1F100E03EAC /* Build configuration list for PBXNativeTarget "array-reverse" */;
 71 | 			buildPhases = (
 72 | 				FAC83AC21970A1F100E03EAC /* Sources */,
 73 | 				FAC83AC31970A1F100E03EAC /* Frameworks */,
 74 | 				FAC83AC41970A1F100E03EAC /* CopyFiles */,
 75 | 			);
 76 | 			buildRules = (
 77 | 			);
 78 | 			dependencies = (
 79 | 			);
 80 | 			name = "array-reverse";
 81 | 			productName = "array-reverse";
 82 | 			productReference = FAC83AC61970A1F100E03EAC /* array-reverse */;
 83 | 			productType = "com.apple.product-type.tool";
 84 | 		};
 85 | /* End PBXNativeTarget section */
 86 | 
 87 | /* Begin PBXProject section */
 88 | 		FAC83ABE1970A1F100E03EAC /* Project object */ = {
 89 | 			isa = PBXProject;
 90 | 			attributes = {
 91 | 				LastUpgradeCheck = 0600;
 92 | 				ORGANIZATIONNAME = "Alex Nichol";
 93 | 				TargetAttributes = {
 94 | 					FAC83AC51970A1F100E03EAC = {
 95 | 						CreatedOnToolsVersion = 6.0;
 96 | 					};
 97 | 				};
 98 | 			};
 99 | 			buildConfigurationList = FAC83AC11970A1F100E03EAC /* Build configuration list for PBXProject "array-reverse" */;
100 | 			compatibilityVersion = "Xcode 3.2";
101 | 			developmentRegion = English;
102 | 			hasScannedForEncodings = 0;
103 | 			knownRegions = (
104 | 				en,
105 | 			);
106 | 			mainGroup = FAC83ABD1970A1F100E03EAC;
107 | 			productRefGroup = FAC83AC71970A1F100E03EAC /* Products */;
108 | 			projectDirPath = "";
109 | 			projectRoot = "";
110 | 			targets = (
111 | 				FAC83AC51970A1F100E03EAC /* array-reverse */,
112 | 			);
113 | 		};
114 | /* End PBXProject section */
115 | 
116 | /* Begin PBXSourcesBuildPhase section */
117 | 		FAC83AC21970A1F100E03EAC /* Sources */ = {
118 | 			isa = PBXSourcesBuildPhase;
119 | 			buildActionMask = 2147483647;
120 | 			files = (
121 | 				FAC83ACA1970A1F100E03EAC /* main.swift in Sources */,
122 | 			);
123 | 			runOnlyForDeploymentPostprocessing = 0;
124 | 		};
125 | /* End PBXSourcesBuildPhase section */
126 | 
127 | /* Begin XCBuildConfiguration section */
128 | 		FAC83ACB1970A1F100E03EAC /* Debug */ = {
129 | 			isa = XCBuildConfiguration;
130 | 			buildSettings = {
131 | 				ALWAYS_SEARCH_USER_PATHS = NO;
132 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
133 | 				CLANG_CXX_LIBRARY = "libc++";
134 | 				CLANG_ENABLE_MODULES = YES;
135 | 				CLANG_ENABLE_OBJC_ARC = YES;
136 | 				CLANG_WARN_BOOL_CONVERSION = YES;
137 | 				CLANG_WARN_CONSTANT_CONVERSION = YES;
138 | 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
139 | 				CLANG_WARN_EMPTY_BODY = YES;
140 | 				CLANG_WARN_ENUM_CONVERSION = YES;
141 | 				CLANG_WARN_INT_CONVERSION = YES;
142 | 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
143 | 				CLANG_WARN_UNREACHABLE_CODE = YES;
144 | 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
145 | 				COPY_PHASE_STRIP = NO;
146 | 				ENABLE_STRICT_OBJC_MSGSEND = YES;
147 | 				GCC_C_LANGUAGE_STANDARD = gnu99;
148 | 				GCC_DYNAMIC_NO_PIC = NO;
149 | 				GCC_OPTIMIZATION_LEVEL = 0;
150 | 				GCC_PREPROCESSOR_DEFINITIONS = (
151 | 					"DEBUG=1",
152 | 					"$(inherited)",
153 | 				);
154 | 				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
155 | 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
156 | 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
157 | 				GCC_WARN_UNDECLARED_SELECTOR = YES;
158 | 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
159 | 				GCC_WARN_UNUSED_FUNCTION = YES;
160 | 				GCC_WARN_UNUSED_VARIABLE = YES;
161 | 				MACOSX_DEPLOYMENT_TARGET = 10.9;
162 | 				MTL_ENABLE_DEBUG_INFO = YES;
163 | 				ONLY_ACTIVE_ARCH = YES;
164 | 				SDKROOT = macosx;
165 | 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
166 | 			};
167 | 			name = Debug;
168 | 		};
169 | 		FAC83ACC1970A1F100E03EAC /* Release */ = {
170 | 			isa = XCBuildConfiguration;
171 | 			buildSettings = {
172 | 				ALWAYS_SEARCH_USER_PATHS = NO;
173 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
174 | 				CLANG_CXX_LIBRARY = "libc++";
175 | 				CLANG_ENABLE_MODULES = YES;
176 | 				CLANG_ENABLE_OBJC_ARC = YES;
177 | 				CLANG_WARN_BOOL_CONVERSION = YES;
178 | 				CLANG_WARN_CONSTANT_CONVERSION = YES;
179 | 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
180 | 				CLANG_WARN_EMPTY_BODY = YES;
181 | 				CLANG_WARN_ENUM_CONVERSION = YES;
182 | 				CLANG_WARN_INT_CONVERSION = YES;
183 | 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
184 | 				CLANG_WARN_UNREACHABLE_CODE = YES;
185 | 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
186 | 				COPY_PHASE_STRIP = YES;
187 | 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
188 | 				ENABLE_NS_ASSERTIONS = NO;
189 | 				ENABLE_STRICT_OBJC_MSGSEND = YES;
190 | 				GCC_C_LANGUAGE_STANDARD = gnu99;
191 | 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
192 | 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
193 | 				GCC_WARN_UNDECLARED_SELECTOR = YES;
194 | 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
195 | 				GCC_WARN_UNUSED_FUNCTION = YES;
196 | 				GCC_WARN_UNUSED_VARIABLE = YES;
197 | 				MACOSX_DEPLOYMENT_TARGET = 10.9;
198 | 				MTL_ENABLE_DEBUG_INFO = NO;
199 | 				SDKROOT = macosx;
200 | 			};
201 | 			name = Release;
202 | 		};
203 | 		FAC83ACE1970A1F100E03EAC /* Debug */ = {
204 | 			isa = XCBuildConfiguration;
205 | 			buildSettings = {
206 | 				GCC_OPTIMIZATION_LEVEL = 3;
207 | 				PRODUCT_NAME = "$(TARGET_NAME)";
208 | 				SWIFT_OPTIMIZATION_LEVEL = "-Ounchecked";
209 | 			};
210 | 			name = Debug;
211 | 		};
212 | 		FAC83ACF1970A1F100E03EAC /* Release */ = {
213 | 			isa = XCBuildConfiguration;
214 | 			buildSettings = {
215 | 				GCC_OPTIMIZATION_LEVEL = 3;
216 | 				PRODUCT_NAME = "$(TARGET_NAME)";
217 | 				SWIFT_OPTIMIZATION_LEVEL = "-Ounchecked";
218 | 			};
219 | 			name = Release;
220 | 		};
221 | /* End XCBuildConfiguration section */
222 | 
223 | /* Begin XCConfigurationList section */
224 | 		FAC83AC11970A1F100E03EAC /* Build configuration list for PBXProject "array-reverse" */ = {
225 | 			isa = XCConfigurationList;
226 | 			buildConfigurations = (
227 | 				FAC83ACB1970A1F100E03EAC /* Debug */,
228 | 				FAC83ACC1970A1F100E03EAC /* Release */,
229 | 			);
230 | 			defaultConfigurationIsVisible = 0;
231 | 			defaultConfigurationName = Release;
232 | 		};
233 | 		FAC83ACD1970A1F100E03EAC /* Build configuration list for PBXNativeTarget "array-reverse" */ = {
234 | 			isa = XCConfigurationList;
235 | 			buildConfigurations = (
236 | 				FAC83ACE1970A1F100E03EAC /* Debug */,
237 | 				FAC83ACF1970A1F100E03EAC /* Release */,
238 | 			);
239 | 			defaultConfigurationIsVisible = 0;
240 | 			defaultConfigurationName = Release;
241 | 		};
242 | /* End XCConfigurationList section */
243 | 	};
244 | 	rootObject = FAC83ABE1970A1F100E03EAC /* Project object */;
245 | }
246 | 


--------------------------------------------------------------------------------
/force-field/swift/force-field/force-field.xcodeproj/project.pbxproj:
--------------------------------------------------------------------------------
  1 | // !$*UTF8*$!
  2 | {
  3 | 	archiveVersion = 1;
  4 | 	classes = {
  5 | 	};
  6 | 	objectVersion = 46;
  7 | 	objects = {
  8 | 
  9 | /* Begin PBXBuildFile section */
 10 | 		FABFCB9D197211810093E1E1 /* main.swift in Sources */ = {isa = PBXBuildFile; fileRef = FABFCB9C197211810093E1E1 /* main.swift */; };
 11 | 		FABFCBA4197211EE0093E1E1 /* Vector.swift in Sources */ = {isa = PBXBuildFile; fileRef = FABFCBA3197211EE0093E1E1 /* Vector.swift */; };
 12 | 		FABFCBA6197213700093E1E1 /* Particle.swift in Sources */ = {isa = PBXBuildFile; fileRef = FABFCBA5197213700093E1E1 /* Particle.swift */; };
 13 | /* End PBXBuildFile section */
 14 | 
 15 | /* Begin PBXCopyFilesBuildPhase section */
 16 | 		FABFCB97197211810093E1E1 /* CopyFiles */ = {
 17 | 			isa = PBXCopyFilesBuildPhase;
 18 | 			buildActionMask = 2147483647;
 19 | 			dstPath = /usr/share/man/man1/;
 20 | 			dstSubfolderSpec = 0;
 21 | 			files = (
 22 | 			);
 23 | 			runOnlyForDeploymentPostprocessing = 1;
 24 | 		};
 25 | /* End PBXCopyFilesBuildPhase section */
 26 | 
 27 | /* Begin PBXFileReference section */
 28 | 		FABFCB99197211810093E1E1 /* force-field */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "force-field"; sourceTree = BUILT_PRODUCTS_DIR; };
 29 | 		FABFCB9C197211810093E1E1 /* main.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = main.swift; sourceTree = "<group>"; };
 30 | 		FABFCBA3197211EE0093E1E1 /* Vector.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Vector.swift; sourceTree = "<group>"; };
 31 | 		FABFCBA5197213700093E1E1 /* Particle.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Particle.swift; sourceTree = "<group>"; };
 32 | /* End PBXFileReference section */
 33 | 
 34 | /* Begin PBXFrameworksBuildPhase section */
 35 | 		FABFCB96197211810093E1E1 /* Frameworks */ = {
 36 | 			isa = PBXFrameworksBuildPhase;
 37 | 			buildActionMask = 2147483647;
 38 | 			files = (
 39 | 			);
 40 | 			runOnlyForDeploymentPostprocessing = 0;
 41 | 		};
 42 | /* End PBXFrameworksBuildPhase section */
 43 | 
 44 | /* Begin PBXGroup section */
 45 | 		FABFCB90197211810093E1E1 = {
 46 | 			isa = PBXGroup;
 47 | 			children = (
 48 | 				FABFCB9B197211810093E1E1 /* force-field */,
 49 | 				FABFCB9A197211810093E1E1 /* Products */,
 50 | 			);
 51 | 			sourceTree = "<group>";
 52 | 		};
 53 | 		FABFCB9A197211810093E1E1 /* Products */ = {
 54 | 			isa = PBXGroup;
 55 | 			children = (
 56 | 				FABFCB99197211810093E1E1 /* force-field */,
 57 | 			);
 58 | 			name = Products;
 59 | 			sourceTree = "<group>";
 60 | 		};
 61 | 		FABFCB9B197211810093E1E1 /* force-field */ = {
 62 | 			isa = PBXGroup;
 63 | 			children = (
 64 | 				FABFCB9C197211810093E1E1 /* main.swift */,
 65 | 				FABFCBA3197211EE0093E1E1 /* Vector.swift */,
 66 | 				FABFCBA5197213700093E1E1 /* Particle.swift */,
 67 | 			);
 68 | 			path = "force-field";
 69 | 			sourceTree = "<group>";
 70 | 		};
 71 | /* End PBXGroup section */
 72 | 
 73 | /* Begin PBXNativeTarget section */
 74 | 		FABFCB98197211810093E1E1 /* force-field */ = {
 75 | 			isa = PBXNativeTarget;
 76 | 			buildConfigurationList = FABFCBA0197211810093E1E1 /* Build configuration list for PBXNativeTarget "force-field" */;
 77 | 			buildPhases = (
 78 | 				FABFCB95197211810093E1E1 /* Sources */,
 79 | 				FABFCB96197211810093E1E1 /* Frameworks */,
 80 | 				FABFCB97197211810093E1E1 /* CopyFiles */,
 81 | 			);
 82 | 			buildRules = (
 83 | 			);
 84 | 			dependencies = (
 85 | 			);
 86 | 			name = "force-field";
 87 | 			productName = "force-field";
 88 | 			productReference = FABFCB99197211810093E1E1 /* force-field */;
 89 | 			productType = "com.apple.product-type.tool";
 90 | 		};
 91 | /* End PBXNativeTarget section */
 92 | 
 93 | /* Begin PBXProject section */
 94 | 		FABFCB91197211810093E1E1 /* Project object */ = {
 95 | 			isa = PBXProject;
 96 | 			attributes = {
 97 | 				LastUpgradeCheck = 0600;
 98 | 				ORGANIZATIONNAME = "Alex Nichol";
 99 | 				TargetAttributes = {
100 | 					FABFCB98197211810093E1E1 = {
101 | 						CreatedOnToolsVersion = 6.0;
102 | 					};
103 | 				};
104 | 			};
105 | 			buildConfigurationList = FABFCB94197211810093E1E1 /* Build configuration list for PBXProject "force-field" */;
106 | 			compatibilityVersion = "Xcode 3.2";
107 | 			developmentRegion = English;
108 | 			hasScannedForEncodings = 0;
109 | 			knownRegions = (
110 | 				en,
111 | 			);
112 | 			mainGroup = FABFCB90197211810093E1E1;
113 | 			productRefGroup = FABFCB9A197211810093E1E1 /* Products */;
114 | 			projectDirPath = "";
115 | 			projectRoot = "";
116 | 			targets = (
117 | 				FABFCB98197211810093E1E1 /* force-field */,
118 | 			);
119 | 		};
120 | /* End PBXProject section */
121 | 
122 | /* Begin PBXSourcesBuildPhase section */
123 | 		FABFCB95197211810093E1E1 /* Sources */ = {
124 | 			isa = PBXSourcesBuildPhase;
125 | 			buildActionMask = 2147483647;
126 | 			files = (
127 | 				FABFCBA4197211EE0093E1E1 /* Vector.swift in Sources */,
128 | 				FABFCBA6197213700093E1E1 /* Particle.swift in Sources */,
129 | 				FABFCB9D197211810093E1E1 /* main.swift in Sources */,
130 | 			);
131 | 			runOnlyForDeploymentPostprocessing = 0;
132 | 		};
133 | /* End PBXSourcesBuildPhase section */
134 | 
135 | /* Begin XCBuildConfiguration section */
136 | 		FABFCB9E197211810093E1E1 /* Debug */ = {
137 | 			isa = XCBuildConfiguration;
138 | 			buildSettings = {
139 | 				ALWAYS_SEARCH_USER_PATHS = NO;
140 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
141 | 				CLANG_CXX_LIBRARY = "libc++";
142 | 				CLANG_ENABLE_MODULES = YES;
143 | 				CLANG_ENABLE_OBJC_ARC = YES;
144 | 				CLANG_WARN_BOOL_CONVERSION = YES;
145 | 				CLANG_WARN_CONSTANT_CONVERSION = YES;
146 | 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
147 | 				CLANG_WARN_EMPTY_BODY = YES;
148 | 				CLANG_WARN_ENUM_CONVERSION = YES;
149 | 				CLANG_WARN_INT_CONVERSION = YES;
150 | 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
151 | 				CLANG_WARN_UNREACHABLE_CODE = YES;
152 | 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
153 | 				COPY_PHASE_STRIP = NO;
154 | 				ENABLE_STRICT_OBJC_MSGSEND = YES;
155 | 				GCC_C_LANGUAGE_STANDARD = gnu99;
156 | 				GCC_DYNAMIC_NO_PIC = NO;
157 | 				GCC_OPTIMIZATION_LEVEL = 0;
158 | 				GCC_PREPROCESSOR_DEFINITIONS = (
159 | 					"DEBUG=1",
160 | 					"$(inherited)",
161 | 				);
162 | 				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
163 | 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
164 | 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
165 | 				GCC_WARN_UNDECLARED_SELECTOR = YES;
166 | 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
167 | 				GCC_WARN_UNUSED_FUNCTION = YES;
168 | 				GCC_WARN_UNUSED_VARIABLE = YES;
169 | 				MACOSX_DEPLOYMENT_TARGET = 10.9;
170 | 				MTL_ENABLE_DEBUG_INFO = YES;
171 | 				ONLY_ACTIVE_ARCH = YES;
172 | 				SDKROOT = macosx;
173 | 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
174 | 			};
175 | 			name = Debug;
176 | 		};
177 | 		FABFCB9F197211810093E1E1 /* Release */ = {
178 | 			isa = XCBuildConfiguration;
179 | 			buildSettings = {
180 | 				ALWAYS_SEARCH_USER_PATHS = NO;
181 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
182 | 				CLANG_CXX_LIBRARY = "libc++";
183 | 				CLANG_ENABLE_MODULES = YES;
184 | 				CLANG_ENABLE_OBJC_ARC = YES;
185 | 				CLANG_WARN_BOOL_CONVERSION = YES;
186 | 				CLANG_WARN_CONSTANT_CONVERSION = YES;
187 | 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
188 | 				CLANG_WARN_EMPTY_BODY = YES;
189 | 				CLANG_WARN_ENUM_CONVERSION = YES;
190 | 				CLANG_WARN_INT_CONVERSION = YES;
191 | 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
192 | 				CLANG_WARN_UNREACHABLE_CODE = YES;
193 | 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
194 | 				COPY_PHASE_STRIP = YES;
195 | 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
196 | 				ENABLE_NS_ASSERTIONS = NO;
197 | 				ENABLE_STRICT_OBJC_MSGSEND = YES;
198 | 				GCC_C_LANGUAGE_STANDARD = gnu99;
199 | 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
200 | 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
201 | 				GCC_WARN_UNDECLARED_SELECTOR = YES;
202 | 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
203 | 				GCC_WARN_UNUSED_FUNCTION = YES;
204 | 				GCC_WARN_UNUSED_VARIABLE = YES;
205 | 				MACOSX_DEPLOYMENT_TARGET = 10.9;
206 | 				MTL_ENABLE_DEBUG_INFO = NO;
207 | 				SDKROOT = macosx;
208 | 			};
209 | 			name = Release;
210 | 		};
211 | 		FABFCBA1197211810093E1E1 /* Debug */ = {
212 | 			isa = XCBuildConfiguration;
213 | 			buildSettings = {
214 | 				GCC_OPTIMIZATION_LEVEL = fast;
215 | 				PRODUCT_NAME = "$(TARGET_NAME)";
216 | 				SWIFT_OPTIMIZATION_LEVEL = "-Ounchecked";
217 | 			};
218 | 			name = Debug;
219 | 		};
220 | 		FABFCBA2197211810093E1E1 /* Release */ = {
221 | 			isa = XCBuildConfiguration;
222 | 			buildSettings = {
223 | 				GCC_OPTIMIZATION_LEVEL = fast;
224 | 				PRODUCT_NAME = "$(TARGET_NAME)";
225 | 				SWIFT_OPTIMIZATION_LEVEL = "-Ounchecked";
226 | 			};
227 | 			name = Release;
228 | 		};
229 | /* End XCBuildConfiguration section */
230 | 
231 | /* Begin XCConfigurationList section */
232 | 		FABFCB94197211810093E1E1 /* Build configuration list for PBXProject "force-field" */ = {
233 | 			isa = XCConfigurationList;
234 | 			buildConfigurations = (
235 | 				FABFCB9E197211810093E1E1 /* Debug */,
236 | 				FABFCB9F197211810093E1E1 /* Release */,
237 | 			);
238 | 			defaultConfigurationIsVisible = 0;
239 | 			defaultConfigurationName = Release;
240 | 		};
241 | 		FABFCBA0197211810093E1E1 /* Build configuration list for PBXNativeTarget "force-field" */ = {
242 | 			isa = XCConfigurationList;
243 | 			buildConfigurations = (
244 | 				FABFCBA1197211810093E1E1 /* Debug */,
245 | 				FABFCBA2197211810093E1E1 /* Release */,
246 | 			);
247 | 			defaultConfigurationIsVisible = 0;
248 | 			defaultConfigurationName = Release;
249 | 		};
250 | /* End XCConfigurationList section */
251 | 	};
252 | 	rootObject = FABFCB91197211810093E1E1 /* Project object */;
253 | }
254 | 


--------------------------------------------------------------------------------