Converted MOST of the Expression subclasses into case classes, which means you can remove new operator for them all.

be careful not when using EqualExpression to compare two character types, since you need to pass in the third argument which is the non-integer type.

Author: heineman

dynamicProgramming/src/main/scala/org/combinators/README.md

@@ -1,7 +1,13 @@
-# DP Generators that Compile:
+The `EnhancedModel` adds additional capabilities to support generating various DP problems.
+
+```
+class EnhancedModel(val problem:String,
+                    val input:Seq[ArgExpression],
+                    val subproblemType:ArgumentType,        // Type of solution
+                    val solutionType:ArgumentType,          // Type of return value
+                    val solution:SubproblemInvocation,
+                    val definition:Definition,
+                    val answer:Definition,                  // all existing Expression should just use ExpressionDefinition(expr)
+                    val mode:ProblemOrder = Canonical())
+```
 
-- bottomUp/twoSequences/longestCommonSubsequence (missing cases)
-- bottomUp/twoSequences/uncrossedLines (missing cases)
-- bottomUp/oneSequence/tribonacci
-- topDown/oneSequence/tribonacci
-- 

dynamicProgramming/src/main/scala/org/combinators/archive/cogen/README.md

@@ -0,0 +1,32 @@
+This `cogen` package contains the earliest attempts to use CoGen to generate dynamic programming (DP) solutions in Java.
+
+Starting from available Java implementations of numerous DP problems, in the initial stage of this project the goal was to be able
+to replicate these code using straight CoGen code. Along the way, one hoped it would be possible to find opportunities to reuse 
+CoGen methods to be able to normalize the entire process.
+
+# Bottom Up
+
+* Pascal's Triangle
+* One Sequence
+  - DecodeWays
+  - Fibonacci
+  - MaxSubArray
+  - Tribonacci
+* Two Sequences
+  - LongestCommonSubSequence
+  - UncrossedLines
+
+# Top Down
+
+* Pascal's Triangle
+* One Sequence
+  - Delete And Earn
+  - House Robber
+  - JumpTo
+  - Tribonacci
+
+# Summary
+
+While various DP problems can be generated through straight CoGen code, this approach is untenable and ultimately did not really result
+in reusable methods for these problems.
+

dynamicProgramming/src/main/scala/org/combinators/archive/cogen/bottomUp/oneSequence/decodeways/DecodeWaysMain.scala

@@ -134,29 +134,26 @@ object DPDirectToDiskMain extends IOApp {
 
     val zero: LiteralInt = new LiteralInt(0)
     val one: LiteralInt = new LiteralInt(1)
-    val ascii_zero:LiteralChar = new LiteralChar('0')
+    val ascii_zero:LiteralChar = LiteralChar('0')
     val two: LiteralInt = new LiteralInt(2)
 
     // what was passed into constructor of the original class
     val input:InputExpression = new InputExpression("s")   // might also need to pass in "type"
 
-    val bound = List(new ArgExpression(0, "text1", new StringType(), "r"), new ArgExpression(1, "text2", new StringType(), "c"))
+    val bound = List(ArgExpression(0, "text1", StringType(), "r"), ArgExpression(1, "text2", StringType(), "c"))
 
-    val r: IteratorExpression = new IteratorExpression(0, "r")   // only one argument, n
-    val c: IteratorExpression = new IteratorExpression(1, "c")   // only one argument, n
-
-    val im1 = new SubtractionExpression(r, one)
-    val im2 = new SubtractionExpression(c, two)
+    val r: IteratorExpression = IteratorExpression(0, "r")   // only one argument, n
+    val c: IteratorExpression = IteratorExpression(1, "c")   // only one argument, n
 
     val DecodeWays = new Model("DecodeWays",
       bound,
       cases = List(
         // s.length() == n
-        ( Some(new EqualExpression(new StringLengthExpression(input), one)),  one ),
+        ( Some(StringLengthExpression(input) == one),       one ),
         // s.CharAt(n) == '0')
-        ( Some(new EqualExpression(new CharAtExpression(input, one), ascii_zero)), zero),
+        ( Some(CharAtExpression(input, one) == ascii_zero), zero),
         // HACK == helper(n-1)
-        ( None,                                new SubproblemExpression(Seq(im1)))
+        ( None,                                             SubproblemExpression(Seq(r - one)))
       )
     )
 

dynamicProgramming/src/main/scala/org/combinators/archive/cogen/bottomUp/twoSequences/longestCommonSubsequence/LCSProvider.scala

@@ -39,7 +39,7 @@ trait LCSProvider extends DPObjectOrientedProvider {
 
     // NOTE: these tests are in the wrong place, since we defer test gen to later
     val tests = Seq(
-      new TestExample("fib0", new LiteralStringPair("ACTG", "CGATC"), new LiteralInt(2), new LiteralString("AC")) // for now, leave solution as None
+      new TestExample("fib0", LiteralStringPair("ACTG", "CGATC"), new LiteralInt(2), LiteralString("AC")) // for now, leave solution as None
     )
 
     for {

dynamicProgramming/src/main/scala/org/combinators/archive/cogen/bottomUp/twoSequences/longestCommonSubsequence/LongestCommonSubsequenceObjectOrientedProvider.scala

@@ -175,9 +175,9 @@ trait LongestCommonSubsequenceObjectOrientedProvider extends TwoSequencesUtility
 
     // https://en.wikipedia.org/wiki/Maximum_subarray_problem
     val wiki_test = new TestExample("wiki",
-      new LiteralStringPair("GAC", "AGCAT"),
+      LiteralStringPair("GAC", "AGCAT"),
       new LiteralInt(2),
-      new LiteralString("GA")
+      LiteralString("GA")
     )
 
     for {

dynamicProgramming/src/main/scala/org/combinators/archive/unenhancedModels/README.md

@@ -0,0 +1,58 @@
+We designed a Model class that was meant to provide all information for a DP problem.
+
+```class Model(val problem:String,
+               val bounds: List[ArgExpression],
+               val cases: List[(Option[Expression], Expression)],
+               val retrieveLabel: String = "take sub-solution")
+```
+
+It is best to explain this with a simple model that captures the Fibonacci domain
+
+# Fibonacci
+
+```
+    val zero: LiteralInt = new LiteralInt(0)
+    val one: LiteralInt = new LiteralInt(1)
+    val two: LiteralInt = new LiteralInt(2)
+
+    val bound = List(ArgExpression(0, "n", IntegerType(), "i"))
+
+    val i: IteratorExpression = IteratorExpression(0, "i")
+    
+    new Model("Fibonacci",
+      bound,
+      cases = List(
+        (Some(i == zero),   zero),
+        (Some(i == one),    one),
+        (None,              SubproblemExpression(Seq(i - one)) + SubproblemExpression(Seq(i - two)) )
+      )
+    )
+  }
+```
+
+The `bounds` represents the arguments to the problem -- in this case, Fibonacci(n). `n` is an argument of type integer, and it is the 0th argument
+for this problem. The variable "i" is to be used with iterating over subproblems in `n`.
+
+The `cases` represents an ordered list of pairs, where each pair has an optional guard that, if true, yields the corresponding expression.
+
+Thus `Fibonacci(0) = 0` and `Fibonacci(1) = 1`. The interesting case is the recursive case, namely that `Fibonacci(i)` is computed by adding together 
+the resulting subexpression `Fibonacci(i-1)` and `Fibonacci(i-2)`.
+
+# Solutions with Model
+
+* DecodeWays
+* Fibonacci
+* JumpTo
+* UniquePaths
+* CoinChange
+* KnapSack
+* MaxSubArray
+* ThreeStrings LongestCommonSubsequence
+* DistinctSubsequences
+* LongestCommonSubsequence
+* MinimumEditDistance
+* NeedlemanWunschSequenceAlignment
+* UncrossedLines
+
+In theory, each of these should support both a bottom-up generation and a top-down generation, using the `BottomUpStrategy` and `TopDownStrategy` found
+in the `dp.original.BottomUpStrategy` and `dp.original.TopDownStrategy` traits.  

dynamicProgramming/src/main/scala/org/combinators/archive/unenhancedModels/boilerplate/NWSA/NWSAProvider.scala

@@ -39,7 +39,7 @@ trait NWSAProvider extends DPObjectOrientedProvider {
 
     // NOTE: these tests are in the wrong place, since we defer test gen to later
     val tests = Seq(
-      new TestExample("fib0", new LiteralStringPair("ACTG", "CGATC"), new LiteralInt(2), new LiteralString("AC")) // for now, leave solution as None
+      new TestExample("fib0", LiteralStringPair("ACTG", "CGATC"), new LiteralInt(2), LiteralString("AC")) // for now, leave solution as None
     )
 
     for {

dynamicProgramming/src/main/scala/org/combinators/archive/unenhancedModels/boilerplate/coinChange/CoinChangeProvider.scala

@@ -45,7 +45,7 @@ trait CoinChangeProvider extends DPObjectOrientedProvider {
 
     // NOTE: these tests are in the wrong place, since we defer test gen to later
     val tests = Seq(
-      new TestExample("test1", new LiteralArray(Array(1,2,5)), new LiteralInt(3), new LiteralString("test"))  // HACK: amount (11) is not here!
+      new TestExample("test1", new LiteralArray(Array(1,2,5)), new LiteralInt(3), LiteralString("test"))  // HACK: amount (11) is not here!
     )
 
     for {

dynamicProgramming/src/main/scala/org/combinators/archive/unenhancedModels/boilerplate/fibonacci/FibonacciMainJava.scala

@@ -99,20 +99,20 @@ object FibonacciMainDirectToDiskMain extends IOApp {
     val two: LiteralInt = new LiteralInt(2)
 
     // Fibonacci has a single integer argument
-    val bound = List(new ArgExpression(0, "n", new IntegerType(), "i"))
+    val bound = List(ArgExpression(0, "n", IntegerType(), "i"))
 
     // COULD be inferred from the ArgExpression list, but this lets us name variable to use in iterator
-    val n: IteratorExpression = new IteratorExpression(0, "i")   // only one argument, i
+    val n: IteratorExpression = IteratorExpression(0, "i")   // only one argument, i
 
-    val im1 = new SubtractionExpression(n, one)
-    val im2 = new SubtractionExpression(n, two)
+    val im1 = SubtractionExpression(n, one)
+    val im2 = SubtractionExpression(n, two)
 
     val Fib = new Model("Fibonacci",
       bound,
       cases = List(
-        ( Some(new EqualExpression(n, zero)),  zero ),
-        ( Some(new EqualExpression(n, one)),   one ),
-        ( None, new AdditionExpression(new SubproblemExpression(Seq(im1)), new SubproblemExpression(Seq(im2))) )
+        ( Some(n == zero),  zero ),
+        ( Some(n == one),   one ),
+        ( None, SubproblemExpression(Seq(im1)) + SubproblemExpression(Seq(im2)) )
       )
     )
 

dynamicProgramming/src/main/scala/org/combinators/archive/unenhancedModels/boilerplate/jumpTo/JumpToMain.scala

@@ -131,27 +131,25 @@ object JumpToMainDirectToDiskMain extends IOApp {
 
     val zero: LiteralInt = new LiteralInt(0)
     val one: LiteralInt = new LiteralInt(1)
-    val ascii_zero:LiteralChar = new LiteralChar('0')
+    val ascii_zero:LiteralChar = LiteralChar('0')
     val two: LiteralInt = new LiteralInt(2)
 
     // what was passed into constructor of the original class
     val input:InputExpression = new InputExpression("array")   // might also need to pass in "type"
 
-    val bound = List(new ArgExpression(0, "array", new IntegerArrayType(), "i"))
+    val bound = List(ArgExpression(0, "array", IntegerArrayType(), "i"))
 
-    val n: IteratorExpression = new IteratorExpression(0, "i")   // only one argument, n
+    val n: IteratorExpression = IteratorExpression(0, "i")   // only one argument, n
 
-    val im1 = new SubtractionExpression(n, one)
-    
     val JumpTo = new Model("JumpTo",
       bound,
       cases = List(
         // array.length()-1 < n
-        ( Some(new LessThanExpression(new SubtractionExpression(new ArrayLengthExpression(input), one), n)),  zero),
+        ( Some(ArrayLengthExpression(input) - one < n),  zero),
         // array.length()-1 = n
-        ( Some(new EqualExpression(new SubtractionExpression(new ArrayLengthExpression(input), one), n)),  zero),
+        ( Some(ArrayLengthExpression(input) - one == n),                        zero),
         // HACK == helper(n-1)
-        ( None,                                new SubproblemExpression(Seq(im1)))
+        ( None,                                                                 SubproblemExpression(Seq(n - one)))
       )
     )