| 1 | namespace HeuristicLab.Tests.Benchmark {
|
|---|
| 2 |
|
|---|
| 3 | using HeuristicLab.BenchmarkSuite;
|
|---|
| 4 | using HeuristicLab.BenchmarkSuite.Problems;
|
|---|
| 5 | using HeuristicLab.Core;
|
|---|
| 6 | using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
|
|---|
| 7 | using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
|
|---|
| 8 | using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
|
|---|
| 9 | using HeuristicLab.Problems.ProgramSynthesis.Push.Parser;
|
|---|
| 10 | using HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite;
|
|---|
| 11 | using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
|
|---|
| 12 | using HeuristicLab.Random;
|
|---|
| 13 |
|
|---|
| 14 | using Microsoft.VisualStudio.TestTools.UnitTesting;
|
|---|
| 15 |
|
|---|
| 16 | [TestClass]
|
|---|
| 17 | public class SolutionTests {
|
|---|
| 18 |
|
|---|
| 19 | private IRandom random;
|
|---|
| 20 |
|
|---|
| 21 | [TestInitialize]
|
|---|
| 22 | public void BeforeTest() {
|
|---|
| 23 | random = new MersenneTwister(1337);
|
|---|
| 24 | }
|
|---|
| 25 |
|
|---|
| 26 | private void TestProgram(PushProgram program, IBenchmarkSuiteDataDescriptor descriptor, string floatStringFormat = "R") {
|
|---|
| 27 | var data = descriptor.CreateProblemData();
|
|---|
| 28 | var config = new PushConfiguration {
|
|---|
| 29 | EvalPushLimit = data.EvalLimit,
|
|---|
| 30 | MaxPointsInProgram = data.MaxSize,
|
|---|
| 31 | ErcOptions = data.ErcOptions,
|
|---|
| 32 | FloatStringFormat = floatStringFormat
|
|---|
| 33 | };
|
|---|
| 34 |
|
|---|
| 35 | config.SetEnabledStacks((StackTypes)data.EnabledDataTypes);
|
|---|
| 36 | config.InitInExpressions(data.TotalInputArgumentCount);
|
|---|
| 37 |
|
|---|
| 38 | var evaluator = new PushBenchmarkSuiteEvaluator(data);
|
|---|
| 39 | var pool = new PushInterpreterPool(config);
|
|---|
| 40 | var result = evaluator.EvaluateTraining(pool, program, random);
|
|---|
| 41 |
|
|---|
| 42 | Assert.AreEqual(0, result.AvgQuality);
|
|---|
| 43 | }
|
|---|
| 44 |
|
|---|
| 45 | [TestMethod]
|
|---|
| 46 | [TestProperty("Time", "Short")]
|
|---|
| 47 | [TestCategory("ProblemTest")]
|
|---|
| 48 | public void Checksum() {
|
|---|
| 49 | TestProgram(
|
|---|
| 50 | PushParser.ParseProgram("( IN1 0 STRING.ITERATE ( INTEGER.FROMCHAR INTEGER.+ ) 64 INTEGER.% \' \' INTEGER.FROMCHAR INTEGER.+ \"Check sum is \" PRINT.PRINTSTRING CHAR.FROMINTEGER PRINT.PRINTCHAR )"),
|
|---|
| 51 | new Checksum());
|
|---|
| 52 | }
|
|---|
| 53 |
|
|---|
| 54 | [TestMethod]
|
|---|
| 55 | [TestProperty("Time", "Short")]
|
|---|
| 56 | [TestCategory("ProblemTest")]
|
|---|
| 57 | public void CollatzNumbers() {
|
|---|
| 58 | TestProgram(
|
|---|
| 59 | PushParser.ParseProgram("( IN1 INTEGER.DUP 1 INTEGER.= BOOLEAN.NOT EXEC.WHILE ( INTEGER.DUP INTEGER.DUP 2 INTEGER.% 0 INTEGER.= EXEC.IF ( 2 INTEGER./ ) ( 3 INTEGER.* 1 INTEGER.+ ) INTEGER.DUP 1 INTEGER.= BOOLEAN.NOT ) INTEGER.POP INTEGER.STACKDEPTH )"),
|
|---|
| 60 | new CollatzNumbers());
|
|---|
| 61 | }
|
|---|
| 62 |
|
|---|
| 63 | [TestMethod]
|
|---|
| 64 | [TestProperty("Time", "Short")]
|
|---|
| 65 | [TestCategory("ProblemTest")]
|
|---|
| 66 | public void CompareStringLengths() {
|
|---|
| 67 | TestProgram(
|
|---|
| 68 | PushParser.ParseProgram("IN1 IN2 IN3 STRING.LENGTH STRING.LENGTH INTEGER.DUP STRING.LENGTH INTEGER.> INTEGER.> BOOLEAN.AND"),
|
|---|
| 69 | new CompareStringLengths());
|
|---|
| 70 | }
|
|---|
| 71 |
|
|---|
| 72 | [TestMethod]
|
|---|
| 73 | [TestProperty("Time", "Short")]
|
|---|
| 74 | [TestCategory("ProblemTest")]
|
|---|
| 75 | public void CountOdds() {
|
|---|
| 76 | TestProgram(
|
|---|
| 77 | PushParser.ParseProgram("( IN1 0 INTEGER[].ITERATE ( 2 INTEGER.% INTEGER.DUP 1 INTEGER.= -1 INTEGER.= BOOLEAN.OR EXEC.WHEN INTEGER.INC ) )"),
|
|---|
| 78 | new CountOdds());
|
|---|
| 79 | }
|
|---|
| 80 |
|
|---|
| 81 | [TestMethod]
|
|---|
| 82 | [TestProperty("Time", "Short")]
|
|---|
| 83 | [TestCategory("ProblemTest")]
|
|---|
| 84 | public void Digits() {
|
|---|
| 85 | TestProgram(
|
|---|
| 86 | PushParser.ParseProgram("( IN1 INTEGER.DUP STRING.FROMINTEGER 0 INTEGER.< BOOLEAN.DUP EXEC.WHEN ( STRING.REST STRING.DUP STRING.FIRST STRING.SWAP STRING.REST ) STRING.REVERSE STRING.ITERATE ( PRINT.NEWLINE PRINT.PRINTCHAR ) EXEC.WHEN ( PRINT.NEWLINE \'-\' PRINT.PRINTCHAR PRINT.PRINTSTRING ) )"),
|
|---|
| 87 | new Digits());
|
|---|
| 88 | }
|
|---|
| 89 |
|
|---|
| 90 | [TestMethod]
|
|---|
| 91 | [TestProperty("Time", "Short")]
|
|---|
| 92 | [TestCategory("ProblemTest")]
|
|---|
| 93 | public void DoubleLetters() {
|
|---|
| 94 | TestProgram(
|
|---|
| 95 | PushParser.ParseProgram(
|
|---|
| 96 | @"IN1
|
|---|
| 97 | STRING.ITERATE (
|
|---|
| 98 | 3 EXEC.DO*COUNT CHAR.DUP
|
|---|
| 99 | CHAR.ISLETTER EXEC.WHEN PRINT.PRINTCHAR
|
|---|
| 100 | '!' CHAR.= EXEC.WHEN ( CHAR.DUP PRINT.PRINTCHAR PRINT.PRINTCHAR )
|
|---|
| 101 | PRINT.PRINTCHAR
|
|---|
| 102 | )"),
|
|---|
| 103 | new DoubleLetters());
|
|---|
| 104 | }
|
|---|
| 105 |
|
|---|
| 106 | [TestMethod]
|
|---|
| 107 | [TestProperty("Time", "Short")]
|
|---|
| 108 | [TestCategory("ProblemTest")]
|
|---|
| 109 | public void EvenSquares() {
|
|---|
| 110 | TestProgram(
|
|---|
| 111 | PushParser.ParseProgram(
|
|---|
| 112 | @"IN1 INTEGER.DUP EXEC.DO*COUNT (
|
|---|
| 113 | INTEGER.DUP 0 INTEGER.>
|
|---|
| 114 | EXEC.WHEN (
|
|---|
| 115 | INTEGER.DUP 2 INTEGER.*
|
|---|
| 116 | INTEGER.DUP INTEGER.DUP INTEGER.*
|
|---|
| 117 | INTEGER.DUP 4 INTEGER.YANKDUP INTEGER.<
|
|---|
| 118 | EXEC.IF (
|
|---|
| 119 | PRINT.PRINTINTEGER
|
|---|
| 120 | PRINT.NEWLINE
|
|---|
| 121 | )
|
|---|
| 122 | EXEC.FLUSH
|
|---|
| 123 | INTEGER.POP
|
|---|
| 124 | )
|
|---|
| 125 | INTEGER.POP
|
|---|
| 126 | )"),
|
|---|
| 127 | new EvenSquares());
|
|---|
| 128 | }
|
|---|
| 129 |
|
|---|
| 130 | [TestMethod]
|
|---|
| 131 | [TestProperty("Time", "Short")]
|
|---|
| 132 | [TestCategory("ProblemTest")]
|
|---|
| 133 | public void ForLoopIndex() {
|
|---|
| 134 | TestProgram(
|
|---|
| 135 | PushParser.ParseProgram(
|
|---|
| 136 | @"( IN1 IN2 IN3 STRING.FROMINTEGER INTEGER.SWAP true EXEC.WHILE ( INTEGER.DUP PRINT.NEWLINE PRINT.PRINTINTEGER STRING.DUP INTEGER.FROMSTRING INTEGER.+ INTEGER.DUP 2 INTEGER.YANKDUP INTEGER.< ) )"),
|
|---|
| 137 | new ForLoopIndex());
|
|---|
| 138 | }
|
|---|
| 139 |
|
|---|
| 140 | [TestMethod]
|
|---|
| 141 | [TestProperty("Time", "Short")]
|
|---|
| 142 | [TestCategory("ProblemTest")]
|
|---|
| 143 | public void Grades() {
|
|---|
| 144 | TestProgram(
|
|---|
| 145 | PushParser.ParseProgram("( IN1 IN2 IN3 IN4 IN5 \"Student has a \" PRINT.PRINTSTRING INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"F\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"D\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"C\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"B\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) \"A\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING )"),
|
|---|
| 146 | new Grades());
|
|---|
| 147 | }
|
|---|
| 148 |
|
|---|
| 149 | [TestMethod]
|
|---|
| 150 | [TestProperty("Time", "Short")]
|
|---|
| 151 | [TestCategory("ProblemTest")]
|
|---|
| 152 | public void LastIndexOfZero() {
|
|---|
| 153 | TestProgram(
|
|---|
| 154 | PushParser.ParseProgram("( IN1 INTEGER[].DUP INTEGER[].LENGTH INTEGER[].REVERSE 0 INTEGER[].INDEXOF INTEGER.- INTEGER.DEC )"),
|
|---|
| 155 | new LastIndexOfZero());
|
|---|
| 156 | }
|
|---|
| 157 |
|
|---|
| 158 | [TestMethod]
|
|---|
| 159 | [TestProperty("Time", "Short")]
|
|---|
| 160 | [TestCategory("ProblemTest")]
|
|---|
| 161 | public void Median() {
|
|---|
| 162 | TestProgram(
|
|---|
| 163 | PushParser.ParseProgram("( IN1 IN2 IN3 INTEGER.ROT INTEGER.DUP 2 INTEGER.YANKDUP INTEGER.MAX 3 INTEGER.YANKDUP INTEGER.MIN INTEGER.ROT INTEGER.MIN INTEGER.MAX PRINT.PRINTINTEGER )"),
|
|---|
| 164 | new Median());
|
|---|
| 165 | }
|
|---|
| 166 |
|
|---|
| 167 | [TestMethod]
|
|---|
| 168 | [TestProperty("Time", "Short")]
|
|---|
| 169 | [TestCategory("ProblemTest")]
|
|---|
| 170 | public void MirrorImage() {
|
|---|
| 171 | TestProgram(
|
|---|
| 172 | PushParser.ParseProgram(
|
|---|
| 173 | @"( IN1 IN2
|
|---|
| 174 | INTEGER[].PUSHALL INTEGER[].ITERATE (
|
|---|
| 175 | INTEGER.= BOOLEAN.NOT EXEC.WHEN ( false EXEC.FLUSH )
|
|---|
| 176 | )
|
|---|
| 177 | true
|
|---|
| 178 | )"),
|
|---|
| 179 | new MirrorImage());
|
|---|
| 180 | }
|
|---|
| 181 |
|
|---|
| 182 | [TestMethod]
|
|---|
| 183 | [TestProperty("Time", "Short")]
|
|---|
| 184 | [TestCategory("ProblemTest")]
|
|---|
| 185 | public void NegativeToZero() {
|
|---|
| 186 | TestProgram(
|
|---|
| 187 | PushParser.ParseProgram("( IN1 INTEGER[].DUP INTEGER[].LENGTH INTEGER.DEC EXEC.DO*COUNT ( INTEGER.DUP INTEGER[].DUP INTEGER[].NTH 0 INTEGER.< EXEC.WHEN ( 0 INTEGER[].SET ) ) )"),
|
|---|
| 188 | new NegativeToZero());
|
|---|
| 189 | }
|
|---|
| 190 |
|
|---|
| 191 | [TestMethod]
|
|---|
| 192 | [TestProperty("Time", "Short")]
|
|---|
| 193 | [TestCategory("ProblemTest")]
|
|---|
| 194 | public void NumberIo() {
|
|---|
| 195 | TestProgram(
|
|---|
| 196 | PushParser.ParseProgram("IN1 IN2 FLOAT.FROMINTEGER FLOAT.+ PRINT.PRINTFLOAT"),
|
|---|
| 197 | new NumberIO());
|
|---|
| 198 | }
|
|---|
| 199 |
|
|---|
| 200 |
|
|---|
| 201 | [TestMethod]
|
|---|
| 202 | [TestProperty("Time", "Short")]
|
|---|
| 203 | [TestCategory("ProblemTest")]
|
|---|
| 204 | public void PigLatin() {
|
|---|
| 205 | TestProgram(
|
|---|
| 206 | PushParser.ParseProgram("@( IN1 STRING.SPLIT STRING.STACKDEPTH 0 INTEGER.= EXEC.WHEN EXEC.FLUSH STRING.STACKDEPTH EXEC.DO*TIMES ( STRING.DUP STRING.FIRST CHAR.ALLFROMSTRING CHAR.DUP \"aeiou\" STRING.CONTAINSCHAR EXEC.IF ( CHAR.POP ) ( STRING.REST STRING.CONJCHAR ) \"ay\" STRING.CONCAT STRING.STACKDEPTH 1 INTEGER.> EXEC.WHEN ( ' ' STRING.CONJCHAR ) PRINT.PRINTSTRING ) )"),
|
|---|
| 207 | new PigLatin());
|
|---|
| 208 | }
|
|---|
| 209 |
|
|---|
| 210 | [TestMethod]
|
|---|
| 211 | [TestProperty("Time", "Short")]
|
|---|
| 212 | [TestCategory("ProblemTest")]
|
|---|
| 213 | public void ReplaceSpaceWithNewLine() {
|
|---|
| 214 |
|
|---|
| 215 | TestProgram(
|
|---|
| 216 | PushParser.ParseProgram("IN1 STRING.DUP 0 STRING.ITERATE ( CHAR.DUP ' ' CHAR.= EXEC.IF ( CHAR.POP '\n' ) INTEGER.INC PRINT.PRINTCHAR )"),
|
|---|
| 217 | new ReplaceSpaceWithNewline());
|
|---|
| 218 | }
|
|---|
| 219 |
|
|---|
| 220 | [TestMethod]
|
|---|
| 221 | [TestProperty("Time", "Short")]
|
|---|
| 222 | [TestCategory("ProblemTest")]
|
|---|
| 223 | public void ScrabbleScore() {
|
|---|
| 224 | TestProgram(
|
|---|
| 225 | PushParser.ParseProgram("( IN1 STRING.ITERATE ( INTEGER.FROMCHAR INTEGER.DUP INTEGER.DUP 96 INTEGER.> 123 INTEGER.< BOOLEAN.AND EXEC.WHEN ( 32 INTEGER.- ) 65 INTEGER.- INTEGER.DUP INTEGER.DUP 0 INTEGER.>= 26 INTEGER.< BOOLEAN.AND EXEC.IF ( [1 3 3 2 1 4 2 4 1 8 5 1 3 1 1 3 10 1 1 1 1 4 4 8 4 10] INTEGER[].NTH INTEGER.+ ) ( INTEGER.POP ) ) )"),
|
|---|
| 226 | new ScrabbleScore());
|
|---|
| 227 | }
|
|---|
| 228 |
|
|---|
| 229 | [TestMethod]
|
|---|
| 230 | [TestProperty("Time", "Short")]
|
|---|
| 231 | [TestCategory("ProblemTest")]
|
|---|
| 232 | public void Smallest() {
|
|---|
| 233 | TestProgram(
|
|---|
| 234 | PushParser.ParseProgram("( IN1 IN2 IN3 IN4 3 EXEC.DO*TIMES INTEGER.MIN )"),
|
|---|
| 235 | new Smallest());
|
|---|
| 236 | }
|
|---|
| 237 |
|
|---|
| 238 | [TestMethod]
|
|---|
| 239 | [TestProperty("Time", "Short")]
|
|---|
| 240 | [TestCategory("ProblemTest")]
|
|---|
| 241 | public void SmallOrLarge() {
|
|---|
| 242 | TestProgram(
|
|---|
| 243 | PushParser.ParseProgram(
|
|---|
| 244 | @"IN1
|
|---|
| 245 | INTEGER.DUP 1000 INTEGER.< 2000 INTEGER.>=
|
|---|
| 246 | EXEC.WHEN ""large""
|
|---|
| 247 | EXEC.WHEN ""small""
|
|---|
| 248 | STRING.EMPTY
|
|---|
| 249 | EXEC.WHEN """"
|
|---|
| 250 | PRINT.PRINTSTRING"),
|
|---|
| 251 | new SmallOrLarge());
|
|---|
| 252 | }
|
|---|
| 253 |
|
|---|
| 254 | [TestMethod]
|
|---|
| 255 | [TestProperty("Time", "Short")]
|
|---|
| 256 | [TestCategory("ProblemTest")]
|
|---|
| 257 | public void StringDifferences() {
|
|---|
| 258 | TestProgram(
|
|---|
| 259 | PushParser.ParseProgram(
|
|---|
| 260 | @"IN1 IN2
|
|---|
| 261 | CHAR.ALLFROMSTRING 0 STRING.ITERATE (
|
|---|
| 262 | CHAR.DUP 2 CHAR.YANKDUP CHAR.= BOOLEAN.NOT EXEC.IF (
|
|---|
| 263 | INTEGER.DUP PRINT.PRINTINTEGER
|
|---|
| 264 | ' ' PRINT.PRINTCHAR PRINT.PRINTCHAR
|
|---|
| 265 | ' ' PRINT.PRINTCHAR PRINT.PRINTCHAR
|
|---|
| 266 | PRINT.NEWLINE
|
|---|
| 267 | )
|
|---|
| 268 | ( CHAR.POP CHAR.POP )
|
|---|
| 269 | INTEGER.INC )"),
|
|---|
| 270 | new StringDifferences());
|
|---|
| 271 | }
|
|---|
| 272 |
|
|---|
| 273 | [TestMethod]
|
|---|
| 274 | [TestProperty("Time", "Short")]
|
|---|
| 275 | [TestCategory("ProblemTest")]
|
|---|
| 276 | public void StringLengthsBackwards() {
|
|---|
| 277 | TestProgram(
|
|---|
| 278 | PushParser.ParseProgram(@"IN1 STRING[].ITERATE ( STRING.LENGTH PRINT.NEWLINE PRINT.PRINTINTEGER )"),
|
|---|
| 279 | new StringLengthsBackwards());
|
|---|
| 280 | }
|
|---|
| 281 |
|
|---|
| 282 | [TestMethod]
|
|---|
| 283 | [TestProperty("Time", "Short")]
|
|---|
| 284 | [TestCategory("ProblemTest")]
|
|---|
| 285 | public void SumOfSquares() {
|
|---|
| 286 | TestProgram(
|
|---|
| 287 | PushParser.ParseProgram(@"( IN1 EXEC.DO*COUNT ( INTEGER.DUP INTEGER.* INTEGER.+ ) )"),
|
|---|
| 288 | new SumOfSquares());
|
|---|
| 289 | }
|
|---|
| 290 |
|
|---|
| 291 | [TestMethod]
|
|---|
| 292 | [TestProperty("Time", "Short")]
|
|---|
| 293 | [TestCategory("ProblemTest")]
|
|---|
| 294 | public void SuperAnagrams() {
|
|---|
| 295 | TestProgram(
|
|---|
| 296 | PushParser.ParseProgram(@"( IN1 IN2 STRING.SWAP STRING.DUP STRING.ITERATE ( CHAR.DUP STRING.DUP STRING.OCCURRENCESOFCHAR 1 STRING.YANKDUP STRING.OCCURRENCESOFCHAR INTEGER.> EXEC.WHEN ( false EXEC.FLUSH ) ) true )"),
|
|---|
| 297 | new SuperAnagrams());
|
|---|
| 298 | }
|
|---|
| 299 |
|
|---|
| 300 | [TestMethod]
|
|---|
| 301 | [TestProperty("Time", "Short")]
|
|---|
| 302 | [TestCategory("ProblemTest")]
|
|---|
| 303 | public void Syllables() {
|
|---|
| 304 | TestProgram(
|
|---|
| 305 | PushParser.ParseProgram("( IN1 \"aeiouy\" 0 STRING.ITERATE ( STRING.DUP STRING.OCCURRENCESOFCHAR INTEGER.+ ) \"The number of syllables is \" PRINT.PRINTSTRING PRINT.PRINTINTEGER )"),
|
|---|
| 306 | new Syllables());
|
|---|
| 307 | }
|
|---|
| 308 |
|
|---|
| 309 | [TestMethod]
|
|---|
| 310 | [TestProperty("Time", "Short")]
|
|---|
| 311 | [TestCategory("ProblemTest")]
|
|---|
| 312 | public void VectorAverage() {
|
|---|
| 313 | TestProgram(
|
|---|
| 314 | PushParser.ParseProgram("( IN1 FLOAT[].DUP FLOAT[].LENGTH FLOAT[].ITERATE FLOAT.+ FLOAT.FROMINTEGER FLOAT./ )"),
|
|---|
| 315 | new VectorAverage());
|
|---|
| 316 | }
|
|---|
| 317 |
|
|---|
| 318 | [TestMethod]
|
|---|
| 319 | [TestProperty("Time", "Short")]
|
|---|
| 320 | [TestCategory("ProblemTest")]
|
|---|
| 321 | public void VectorSummed() {
|
|---|
| 322 | TestProgram(
|
|---|
| 323 | PushParser.ParseProgram(@"( IN1 IN2 INTEGER[].PUSHALL INTEGER[].DUP INTEGER[].LENGTH INTEGER.DEC EXEC.DO*COUNT ( INTEGER.DUP INTEGER[].DUP INTEGER[].NTH INTEGER.SWAP INTEGER.ROT INTEGER.+ INTEGER[].SET ) )"),
|
|---|
| 324 | new VectorSummed());
|
|---|
| 325 | }
|
|---|
| 326 |
|
|---|
| 327 | [TestMethod]
|
|---|
| 328 | [TestProperty("Time", "Short")]
|
|---|
| 329 | [TestCategory("ProblemTest")]
|
|---|
| 330 | public void WallisPi() {
|
|---|
| 331 | TestProgram(
|
|---|
| 332 | PushParser.ParseProgram(@"( IN1 2 3 INTEGER.ROT INTEGER.ROT EXEC.DO*TIMES ( 2 EXEC.DO*TIMES ( 1 INTEGER.YANKDUP 1 INTEGER.YANKDUP ) FLOAT.FROMINTEGER FLOAT.FROMINTEGER FLOAT.SWAP FLOAT./ FLOAT.* INTEGER.< EXEC.IF ( INTEGER.SWAP 2 INTEGER.+ INTEGER.SWAP ) ( 2 INTEGER.+ ) ) )"),
|
|---|
| 333 | new WallisPi());
|
|---|
| 334 | }
|
|---|
| 335 |
|
|---|
| 336 | [TestMethod]
|
|---|
| 337 | [TestProperty("Time", "Short")]
|
|---|
| 338 | [TestCategory("ProblemTest")]
|
|---|
| 339 | public void WordStats() {
|
|---|
| 340 | TestProgram(
|
|---|
| 341 | PushParser.ParseProgram("( IN1 STRING.DUP STRING.SPLIT STRING.STACKDEPTH 1 INTEGER.= BOOLEAN.NOT EXEC.WHEN ( true EXEC.WHILE ( STRING.LENGTH INTEGER.MAX STRING.STACKDEPTH 1 INTEGER.= BOOLEAN.NOT ) [0] 2 INTEGER.- INTEGER.DUP 0 INTEGER.>= EXEC.WHEN ( INTEGER.INC EXEC.DO*TIMES ( 0 INTEGER[].CONJ ) ) STRING.DUP STRING.SPLIT STRING.STACKDEPTH 1 INTEGER.> EXEC.WHILE ( STRING.LENGTH INTEGER.DEC INTEGER.DUP INTEGER[].DUP INTEGER[].NTH INTEGER.INC INTEGER[].SET STRING.STACKDEPTH 1 INTEGER.> ) INTEGER[].DUP INTEGER[].LENGTH INTEGER.DEC EXEC.DO*COUNT ( PRINT.NEWLINE \"words of length \" PRINT.PRINTSTRING INTEGER.DUP INTEGER.INC PRINT.PRINTINTEGER \": \" PRINT.PRINTSTRING INTEGER[].DUP INTEGER[].NTH PRINT.PRINTINTEGER ) \'.\' STRING.DUP STRING.OCCURRENCESOFCHAR \'!\' STRING.DUP STRING.OCCURRENCESOFCHAR INTEGER.+ \'?\' STRING.DUP STRING.OCCURRENCESOFCHAR INTEGER.+ INTEGER.DUP PRINT.NEWLINE \"number of sentences: \" PRINT.PRINTSTRING PRINT.PRINTINTEGER STRING.SPLIT STRING.STACKDEPTH FLOAT.FROMINTEGER FLOAT.FROMINTEGER FLOAT./ PRINT.NEWLINE \"average sentence length: \" PRINT.PRINTSTRING PRINT.PRINTFLOAT ) )"),
|
|---|
| 342 | new WordStats(),
|
|---|
| 343 | "0.0#########");
|
|---|
| 344 | }
|
|---|
| 345 |
|
|---|
| 346 | [TestMethod]
|
|---|
| 347 | [TestProperty("Time", "Short")]
|
|---|
| 348 | [TestCategory("ProblemTest")]
|
|---|
| 349 | public void XWordLines() {
|
|---|
| 350 | TestProgram(
|
|---|
| 351 | PushParser.ParseProgram(@"( IN1 IN2 STRING.SPLIT STRING.EMPTY BOOLEAN.NOT INTEGER.DUP 1 INTEGER.= EXEC.IF ( EXEC.WHILE ( PRINT.NEWLINE PRINT.PRINTSTRING STRING.EMPTY BOOLEAN.NOT ) ) ( 2 INTEGER.- EXEC.WHILE ( STRING.STACKDEPTH 2 INTEGER.- 1 INTEGER.YANKDUP INTEGER.MIN INTEGER.DUP 0 INTEGER.>= EXEC.IF ( INTEGER.INC EXEC.DO*TIMES ( ' ' STRING.CONJCHAR STRING.SWAP STRING.CONCAT ) PRINT.NEWLINE PRINT.PRINTSTRING STRING.EMPTY BOOLEAN.NOT ) ( PRINT.NEWLINE PRINT.PRINTSTRING STRING.EMPTY BOOLEAN.NOT ) ) ) )"),
|
|---|
| 352 | new XWordLines());
|
|---|
| 353 | }
|
|---|
| 354 | }
|
|---|
| 355 | }
|
|---|
