diff --git a/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala new file mode 100644 index 0000000..ac80cd7 --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala @@ -0,0 +1,34 @@ +package org.xcit.nback.generators + +import scala.collection.mutable +import scala.util.Random + +/** + * Generate uniformly random alphanumeric string of size N, with target item evenly distributed. + * Reference: Ralph2014 + * + * @param alphabet All allowed alphabets (default is "BCDEFGJKLMNQRSQVWXYZ" excluding target and similar + * characters). Default alphabet contains 20 characters. + * @param target target item (default is 'A'). + */ +class EvenSequenceGenerator(alphabet: String = "BCDEFGJKLMNQRSQVWXYZ", target: Char = 'A') extends SequenceGenerator { + /** + * Generate the actual sequence as a string, takes only the length of desired sequence + * @param length number of items in n-back sequence. + * @return string of size "length" with random alphanumeric characters. + */ + override def generate(length: Int = 8): String = { + var results = mutable.ListBuffer[String]() + val items = List.range(0, length) + + // decide if target or non-target with 50/50 chance. + //TODO change probability according to a new class param + if (Random.nextBoolean) + results += target.toString + else + items.foreach( + results += alphabet.charAt(Random.nextInt(alphabet.length)).toString + ) + results.mkString("") + } +} diff --git a/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala new file mode 100644 index 0000000..ac80cd7 --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala @@ -0,0 +1,34 @@ +package org.xcit.nback.generators + +import scala.collection.mutable +import scala.util.Random + +/** + * Generate uniformly random alphanumeric string of size N, with target item evenly distributed. + * Reference: Ralph2014 + * + * @param alphabet All allowed alphabets (default is "BCDEFGJKLMNQRSQVWXYZ" excluding target and similar + * characters). Default alphabet contains 20 characters. + * @param target target item (default is 'A'). + */ +class EvenSequenceGenerator(alphabet: String = "BCDEFGJKLMNQRSQVWXYZ", target: Char = 'A') extends SequenceGenerator { + /** + * Generate the actual sequence as a string, takes only the length of desired sequence + * @param length number of items in n-back sequence. + * @return string of size "length" with random alphanumeric characters. + */ + override def generate(length: Int = 8): String = { + var results = mutable.ListBuffer[String]() + val items = List.range(0, length) + + // decide if target or non-target with 50/50 chance. + //TODO change probability according to a new class param + if (Random.nextBoolean) + results += target.toString + else + items.foreach( + results += alphabet.charAt(Random.nextInt(alphabet.length)).toString + ) + results.mkString("") + } +} diff --git a/src/main/scala/org/xcit/nback/generators/MarkovChainSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/MarkovChainSequenceGenerator.scala new file mode 100644 index 0000000..d10e633 --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/MarkovChainSequenceGenerator.scala @@ -0,0 +1,6 @@ +package org.xcit.nback.generators + +//TODO +class MarkovChainSequenceGenerator { + +} diff --git a/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala new file mode 100644 index 0000000..ac80cd7 --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala @@ -0,0 +1,34 @@ +package org.xcit.nback.generators + +import scala.collection.mutable +import scala.util.Random + +/** + * Generate uniformly random alphanumeric string of size N, with target item evenly distributed. + * Reference: Ralph2014 + * + * @param alphabet All allowed alphabets (default is "BCDEFGJKLMNQRSQVWXYZ" excluding target and similar + * characters). Default alphabet contains 20 characters. + * @param target target item (default is 'A'). + */ +class EvenSequenceGenerator(alphabet: String = "BCDEFGJKLMNQRSQVWXYZ", target: Char = 'A') extends SequenceGenerator { + /** + * Generate the actual sequence as a string, takes only the length of desired sequence + * @param length number of items in n-back sequence. + * @return string of size "length" with random alphanumeric characters. + */ + override def generate(length: Int = 8): String = { + var results = mutable.ListBuffer[String]() + val items = List.range(0, length) + + // decide if target or non-target with 50/50 chance. + //TODO change probability according to a new class param + if (Random.nextBoolean) + results += target.toString + else + items.foreach( + results += alphabet.charAt(Random.nextInt(alphabet.length)).toString + ) + results.mkString("") + } +} diff --git a/src/main/scala/org/xcit/nback/generators/MarkovChainSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/MarkovChainSequenceGenerator.scala new file mode 100644 index 0000000..d10e633 --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/MarkovChainSequenceGenerator.scala @@ -0,0 +1,6 @@ +package org.xcit.nback.generators + +//TODO +class MarkovChainSequenceGenerator { + +} diff --git a/src/main/scala/org/xcit/nback/generators/RandomSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/RandomSequenceGenerator.scala new file mode 100644 index 0000000..bcef1e2 --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/RandomSequenceGenerator.scala @@ -0,0 +1,15 @@ +package org.xcit.nback.generators + +import scala.util.Random + +class RandomSequenceGenerator(n: Int) extends SequenceGenerator { + /** + * Generate simple alphanumeric string of size N + * + * @param length number of items in n-back sequence. + * @return string of size "length" with random alphanumeric characters. + */ + override def generate(length: Int = 0): String = { + Random.alphanumeric.take(length).mkString("") + } +} diff --git a/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala new file mode 100644 index 0000000..ac80cd7 --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala @@ -0,0 +1,34 @@ +package org.xcit.nback.generators + +import scala.collection.mutable +import scala.util.Random + +/** + * Generate uniformly random alphanumeric string of size N, with target item evenly distributed. + * Reference: Ralph2014 + * + * @param alphabet All allowed alphabets (default is "BCDEFGJKLMNQRSQVWXYZ" excluding target and similar + * characters). Default alphabet contains 20 characters. + * @param target target item (default is 'A'). + */ +class EvenSequenceGenerator(alphabet: String = "BCDEFGJKLMNQRSQVWXYZ", target: Char = 'A') extends SequenceGenerator { + /** + * Generate the actual sequence as a string, takes only the length of desired sequence + * @param length number of items in n-back sequence. + * @return string of size "length" with random alphanumeric characters. + */ + override def generate(length: Int = 8): String = { + var results = mutable.ListBuffer[String]() + val items = List.range(0, length) + + // decide if target or non-target with 50/50 chance. + //TODO change probability according to a new class param + if (Random.nextBoolean) + results += target.toString + else + items.foreach( + results += alphabet.charAt(Random.nextInt(alphabet.length)).toString + ) + results.mkString("") + } +} diff --git a/src/main/scala/org/xcit/nback/generators/MarkovChainSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/MarkovChainSequenceGenerator.scala new file mode 100644 index 0000000..d10e633 --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/MarkovChainSequenceGenerator.scala @@ -0,0 +1,6 @@ +package org.xcit.nback.generators + +//TODO +class MarkovChainSequenceGenerator { + +} diff --git a/src/main/scala/org/xcit/nback/generators/RandomSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/RandomSequenceGenerator.scala new file mode 100644 index 0000000..bcef1e2 --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/RandomSequenceGenerator.scala @@ -0,0 +1,15 @@ +package org.xcit.nback.generators + +import scala.util.Random + +class RandomSequenceGenerator(n: Int) extends SequenceGenerator { + /** + * Generate simple alphanumeric string of size N + * + * @param length number of items in n-back sequence. + * @return string of size "length" with random alphanumeric characters. + */ + override def generate(length: Int = 0): String = { + Random.alphanumeric.take(length).mkString("") + } +} diff --git a/src/main/scala/org/xcit/nback/generators/SequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/SequenceGenerator.scala new file mode 100644 index 0000000..74ad01c --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/SequenceGenerator.scala @@ -0,0 +1,27 @@ +package org.xcit.nback.generators + +/** + * Companion object and buiilders interface for Strategy pattern of the sequence generators. + * Params: + * "n": The "n" property in n-back (N items back must match the current stimuli). + * "offline": if it should generate the whole sequence at once of use MDP to consider rewards with reinforcement + * learning methods. + * + */ +object SequenceGenerator { + def random(n: Int = 3, length: Int = 0): String = new RandomSequenceGenerator(n).generate(length) + def even(n: Int = 3, length: Int = 0, alphabet: String = "", target: Char): String = new EvenSequenceGenerator().generate(length) +} + +/** + * Generic n-back class to generate a sequence of n-back items with HMM. + */ +trait SequenceGenerator { + + /** + * Generate simple alphanumeric string of size N + * @param length number of items in n-back sequence. + * @return string of size "length" with random alphanumeric characters. + */ + def generate(length: Int = 0): String +} diff --git a/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala new file mode 100644 index 0000000..ac80cd7 --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala @@ -0,0 +1,34 @@ +package org.xcit.nback.generators + +import scala.collection.mutable +import scala.util.Random + +/** + * Generate uniformly random alphanumeric string of size N, with target item evenly distributed. + * Reference: Ralph2014 + * + * @param alphabet All allowed alphabets (default is "BCDEFGJKLMNQRSQVWXYZ" excluding target and similar + * characters). Default alphabet contains 20 characters. + * @param target target item (default is 'A'). + */ +class EvenSequenceGenerator(alphabet: String = "BCDEFGJKLMNQRSQVWXYZ", target: Char = 'A') extends SequenceGenerator { + /** + * Generate the actual sequence as a string, takes only the length of desired sequence + * @param length number of items in n-back sequence. + * @return string of size "length" with random alphanumeric characters. + */ + override def generate(length: Int = 8): String = { + var results = mutable.ListBuffer[String]() + val items = List.range(0, length) + + // decide if target or non-target with 50/50 chance. + //TODO change probability according to a new class param + if (Random.nextBoolean) + results += target.toString + else + items.foreach( + results += alphabet.charAt(Random.nextInt(alphabet.length)).toString + ) + results.mkString("") + } +} diff --git a/src/main/scala/org/xcit/nback/generators/MarkovChainSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/MarkovChainSequenceGenerator.scala new file mode 100644 index 0000000..d10e633 --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/MarkovChainSequenceGenerator.scala @@ -0,0 +1,6 @@ +package org.xcit.nback.generators + +//TODO +class MarkovChainSequenceGenerator { + +} diff --git a/src/main/scala/org/xcit/nback/generators/RandomSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/RandomSequenceGenerator.scala new file mode 100644 index 0000000..bcef1e2 --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/RandomSequenceGenerator.scala @@ -0,0 +1,15 @@ +package org.xcit.nback.generators + +import scala.util.Random + +class RandomSequenceGenerator(n: Int) extends SequenceGenerator { + /** + * Generate simple alphanumeric string of size N + * + * @param length number of items in n-back sequence. + * @return string of size "length" with random alphanumeric characters. + */ + override def generate(length: Int = 0): String = { + Random.alphanumeric.take(length).mkString("") + } +} diff --git a/src/main/scala/org/xcit/nback/generators/SequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/SequenceGenerator.scala new file mode 100644 index 0000000..74ad01c --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/SequenceGenerator.scala @@ -0,0 +1,27 @@ +package org.xcit.nback.generators + +/** + * Companion object and buiilders interface for Strategy pattern of the sequence generators. + * Params: + * "n": The "n" property in n-back (N items back must match the current stimuli). + * "offline": if it should generate the whole sequence at once of use MDP to consider rewards with reinforcement + * learning methods. + * + */ +object SequenceGenerator { + def random(n: Int = 3, length: Int = 0): String = new RandomSequenceGenerator(n).generate(length) + def even(n: Int = 3, length: Int = 0, alphabet: String = "", target: Char): String = new EvenSequenceGenerator().generate(length) +} + +/** + * Generic n-back class to generate a sequence of n-back items with HMM. + */ +trait SequenceGenerator { + + /** + * Generate simple alphanumeric string of size N + * @param length number of items in n-back sequence. + * @return string of size "length" with random alphanumeric characters. + */ + def generate(length: Int = 0): String +} diff --git a/src/main/scala/org/xcit/nback/generators/SkewedSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/SkewedSequenceGenerator.scala new file mode 100644 index 0000000..627109f --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/SkewedSequenceGenerator.scala @@ -0,0 +1,5 @@ +package org.xcit.nback.generators + +class SkewedSequenceGenerator { + +} diff --git a/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala new file mode 100644 index 0000000..ac80cd7 --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/EvenSequenceGenerator.scala @@ -0,0 +1,34 @@ +package org.xcit.nback.generators + +import scala.collection.mutable +import scala.util.Random + +/** + * Generate uniformly random alphanumeric string of size N, with target item evenly distributed. + * Reference: Ralph2014 + * + * @param alphabet All allowed alphabets (default is "BCDEFGJKLMNQRSQVWXYZ" excluding target and similar + * characters). Default alphabet contains 20 characters. + * @param target target item (default is 'A'). + */ +class EvenSequenceGenerator(alphabet: String = "BCDEFGJKLMNQRSQVWXYZ", target: Char = 'A') extends SequenceGenerator { + /** + * Generate the actual sequence as a string, takes only the length of desired sequence + * @param length number of items in n-back sequence. + * @return string of size "length" with random alphanumeric characters. + */ + override def generate(length: Int = 8): String = { + var results = mutable.ListBuffer[String]() + val items = List.range(0, length) + + // decide if target or non-target with 50/50 chance. + //TODO change probability according to a new class param + if (Random.nextBoolean) + results += target.toString + else + items.foreach( + results += alphabet.charAt(Random.nextInt(alphabet.length)).toString + ) + results.mkString("") + } +} diff --git a/src/main/scala/org/xcit/nback/generators/MarkovChainSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/MarkovChainSequenceGenerator.scala new file mode 100644 index 0000000..d10e633 --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/MarkovChainSequenceGenerator.scala @@ -0,0 +1,6 @@ +package org.xcit.nback.generators + +//TODO +class MarkovChainSequenceGenerator { + +} diff --git a/src/main/scala/org/xcit/nback/generators/RandomSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/RandomSequenceGenerator.scala new file mode 100644 index 0000000..bcef1e2 --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/RandomSequenceGenerator.scala @@ -0,0 +1,15 @@ +package org.xcit.nback.generators + +import scala.util.Random + +class RandomSequenceGenerator(n: Int) extends SequenceGenerator { + /** + * Generate simple alphanumeric string of size N + * + * @param length number of items in n-back sequence. + * @return string of size "length" with random alphanumeric characters. + */ + override def generate(length: Int = 0): String = { + Random.alphanumeric.take(length).mkString("") + } +} diff --git a/src/main/scala/org/xcit/nback/generators/SequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/SequenceGenerator.scala new file mode 100644 index 0000000..74ad01c --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/SequenceGenerator.scala @@ -0,0 +1,27 @@ +package org.xcit.nback.generators + +/** + * Companion object and buiilders interface for Strategy pattern of the sequence generators. + * Params: + * "n": The "n" property in n-back (N items back must match the current stimuli). + * "offline": if it should generate the whole sequence at once of use MDP to consider rewards with reinforcement + * learning methods. + * + */ +object SequenceGenerator { + def random(n: Int = 3, length: Int = 0): String = new RandomSequenceGenerator(n).generate(length) + def even(n: Int = 3, length: Int = 0, alphabet: String = "", target: Char): String = new EvenSequenceGenerator().generate(length) +} + +/** + * Generic n-back class to generate a sequence of n-back items with HMM. + */ +trait SequenceGenerator { + + /** + * Generate simple alphanumeric string of size N + * @param length number of items in n-back sequence. + * @return string of size "length" with random alphanumeric characters. + */ + def generate(length: Int = 0): String +} diff --git a/src/main/scala/org/xcit/nback/generators/SkewedSequenceGenerator.scala b/src/main/scala/org/xcit/nback/generators/SkewedSequenceGenerator.scala new file mode 100644 index 0000000..627109f --- /dev/null +++ b/src/main/scala/org/xcit/nback/generators/SkewedSequenceGenerator.scala @@ -0,0 +1,5 @@ +package org.xcit.nback.generators + +class SkewedSequenceGenerator { + +} diff --git a/src/main/scala/org/xcit/nback/markov/models/SequenceGenerator.scala b/src/main/scala/org/xcit/nback/markov/models/SequenceGenerator.scala deleted file mode 100644 index fbe5503..0000000 --- a/src/main/scala/org/xcit/nback/markov/models/SequenceGenerator.scala +++ /dev/null @@ -1,22 +0,0 @@ -package org.xcit.nback.markov.models - -import scala.util.Random - -/** - * Generic n-back class to generate a sequence of n-back items with HMM. - * @param length length of n-back sequence (number of items) - * @param offline if it should generate the whole sequence at once of use MDP to consider rewards with reinforcement learning methods - */ -class SequenceGenerator( - length: Int, // sequence length - offline: Boolean = true - ) { - - /** - * Generate simple alphanumeric string of size N - * @return string of size "length" with random alphanumeric characters. - */ - def generate(): String = { - Random.alphanumeric.take(length).mkString - } -}