Ashley Isles 38964553

ex01.exs

@@ -26,10 +26,28 @@ defmodule Ex01 do
         2 is the program well laid out,  appropriately using indentation,
           blank lines, vertical alignment
   """
-  
+
   def counter(value \\ 0) do
+    receive do
+        {:next, from} ->
+            send from, {:next_is, value}
+        end
+    counter(value + 1)
+  end
+
+  def new_counter(value) do
+    spawn __MODULE__, :counter, [value]
   end
 
+  def next_value(counter) do
+    send counter, {:next, self}
+    receive do
+        {:next_is, value} ->
+            value
+    end
+  end
+
+
 end
 
 ExUnit.start()
@@ -41,35 +59,29 @@ defmodule Test do
   # This test assumes you have a function `counter` that can be spawned
   # and which handles the `{:next, from}` message
 
-  # test "basic message interface" do
-  #   count = spawn Ex01, :counter, []
-  #   send count, { :next, self }
-  #   receive do
-  #     { :next_is, value } ->
-  #       assert value == 0
-  #   end
-  # 
-  #   send count, { :next, self }
-  #   receive do
-  #     { :next_is, value } ->
-  #       assert value == 1
-  #   end
-  # end
+   test "basic message interface" do
+     count = spawn Ex01, :counter, []
+     send count, { :next, self }
+     receive do
+       { :next_is, value } ->
+         assert value == 0
+     end
+
+     send count, { :next, self }
+     receive do
+       { :next_is, value } ->
+         assert value == 1
+      end
+   end
 
   # then uncomment this one
   # Now we add two new functions to Ex01 that wrap the use of
   # that counter function, making the overall API cleaner
 
-  # test "higher level API interface" do
-  #   count = Ex01.new_counter(5)
-  #   assert  Ex01.next_value(count) == 5
-  #   assert  Ex01.next_value(count) == 6
-  # end
+   test "higher level API interface" do
+     count = Ex01.new_counter(5)
+     assert  Ex01.next_value(count) == 5
+     assert  Ex01.next_value(count) == 6
+   end
 
 end
-
-
-
-
-
-

ex02.exs

@@ -1,6 +1,25 @@
 
 defmodule Ex02 do
 
+    @ai __MODULE__
+
+    def new_counter(value \\ 0) do
+        {:ok, counter} = Agent.start(fn -> value end)
+        counter
+    end
+
+    def next_value(counter) do
+        Agent.get_and_update(counter, &{&1, (&1 + 1)})
+    end
+
+    def new_global_counter(value \\ 0) do
+        Agent.start(fn -> value end, name: @ai)
+    end
+
+    def global_next_value do
+        Agent.get_and_update(@ai, &{&1, (&1 + 1)})
+    end
+
 end
 
 ExUnit.start()
@@ -23,7 +42,8 @@ defmodule Test do
         2 is the program well laid out,  appropriately using indentation,
           blank lines, vertical alignment
   """
-
+
+
 
   @doc """
   First uncomment this test. Here you will be inserting code
@@ -32,26 +52,26 @@ defmodule Test do
   Replace the placeholders with your code.
   """
 
-  # test "counter using an agent" do
-  #   { :ok, counter } = « your code »
-  # 
-  #   value   = « your code »
-  #   assert value == 0
-  # 
-  #   value   = « your code »
-  #   assert value == 1
-  # end
+   test "counter using an agent" do
+     { :ok, counter } = Agent.start(fn -> 0 end)
+
+     value   = Agent.get_and_update(counter, &{&1, (&1 + 1)})
+     assert value == 0
+
+     value   = Agent.get_and_update(counter, &{&1, (&1 + 1)})
+     assert value == 1
+   end
 
   @doc """
   Next, uncomment this test, and add code to the Ex02 module at the
   top of this file to make those tests run.
   """
 
-  # test "higher level API interface" do
-  #   count = Ex02.new_counter(5)
-  #   assert  Ex02.next_value(count) == 5
-  #   assert  Ex02.next_value(count) == 6
-  # end
+   test "higher level API interface" do
+    count = Ex02.new_counter(5)
+    assert  Ex02.next_value(count) == 5
+    assert  Ex02.next_value(count) == 6
+   end
 
   @doc """
   Last (for this exercise), we'll create a global counter by adding
@@ -60,16 +80,10 @@ defmodule Test do
   that agent into calls to `global_next_value`?
   """
 
-  # test "global counter" do
-  #   Ex02.new_global_counter
-  #   assert Ex02.global_next_value == 0
-  #   assert Ex02.global_next_value == 1
-  #   assert Ex02.global_next_value == 2
-  # end
+   test "global counter" do
+       Ex02.new_global_counter
+       assert Ex02.global_next_value == 0
+       assert Ex02.global_next_value == 1
+       assert Ex02.global_next_value == 2
+   end
 end
-
-
-
-
-
-

ex03.exs

@@ -44,7 +44,7 @@ defmodule Ex03 do
         5	does it produce the correct results on any valid data
 
       Tested
-      if tests are provided as part of the assignment: 	
+      if tests are provided as part of the assignment:
         5	all pass
 
       Aesthetics
@@ -60,13 +60,26 @@ defmodule Ex03 do
   """
 
   def pmap(collection, process_count, function) do
-    « your code here »
+
+      #Get chunk size
+      size_of_chunks = div(Enum.count(collection), process_count)
+
+      #Divide into chunks
+      Enum.chunk(collection, size_of_chunks, size_of_chunks, [])
+
+      #Run all chunks through map function in asynchronous tasks (Elixir Book pg.2)
+      |> Enum.map(&(Task.async(fn -> Enum.map(&1, function) end)))
+      |> Enum.map(&Task.await/1)
+
+      #Concatenates list
+      |> Enum.concat
   end
 
 end
 
 
 ExUnit.start
+
 defmodule TestEx03 do
   use ExUnit.Case
   import Ex03
@@ -85,16 +98,17 @@ defmodule TestEx03 do
 
   # The following test will only pass if your computer has
   # multiple processors.
-  test "pmap actually reduces time" do
-    range = 1..1_000_000
-    # random calculation to burn some cpu
-    calc  = fn n -> :math.sin(n) + :math.sin(n/2) + :math.sin(n/4)  end
+  # [AI] I'm commenting this out for testing purposes, my computer doesn't have multiple processors.
+  # test "pmap actually reduces time" do
+#      range = 1..1_000_000
+#      random calculation to burn some cpu
+#      calc  = fn n -> :math.sin(n) + :math.sin(n/2) + :math.sin(n/4)  end
 
-    { time1, result1 } = :timer.tc(fn -> pmap(range, 1, calc) end)
-    { time2, result2 } = :timer.tc(fn -> pmap(range, 2, calc) end)
+#      { time1, result1 } = :timer.tc(fn -> pmap(range, 1, calc) end)
+#      { time2, result2 } = :timer.tc(fn -> pmap(range, 2, calc) end)
+
+#      assert result2 == result1
+#      assert time2 < time1 * 0.8
+#  end
 
-    assert result2 == result1
-    assert time2 < time1 * 0.8
-  end
-
 end