cilib

Type Members

1. final case class Adjusted extends Fit with Product with Serializable

   

2. abstract class Comparison extends AnyRef

   

3. sealed trait Constraint[A, B] extends AnyRef

   

4. case class ConstraintFunction[A, B](f: (NonEmptyList[A]) ⇒ B) extends Product with Serializable

   

5. type Crossover[A] = (NonEmptyList[Position[A]]) ⇒ Step[A, NonEmptyList[Position[A]]]

   

6. type Distance[F[_], A] = (F[A], F[A]) ⇒ A

   

7. final case class Entity[S, A](state: S, pos: Position[A]) extends Product with Serializable

   

8. case class Equal[A, B](f: ConstraintFunction[A, B], v: B) extends Constraint[A, B] with Product with Serializable

   

9. sealed abstract class Eval[A] extends AnyRef

   

10. final case class Feasible(v: Double) extends Fit with Product with Serializable

    

11. sealed trait Fit extends AnyRef

    

12. trait Fitness[F[_], A] extends AnyRef

    

    Annotations

    @implicitNotFound( ... )

13. sealed trait Generator[A] extends AnyRef

    

14. case class GreaterThan[A, B](f: ConstraintFunction[A, B], v: B) extends Constraint[A, B] with Product with Serializable

    

15. case class GreaterThanEqual[A, B](f: ConstraintFunction[A, B], v: B) extends Constraint[A, B] with Product with Serializable

    

16. trait HasCharge[A] extends AnyRef

    

17. trait HasMemory[S, A] extends AnyRef

    

18. trait HasPBestStagnation[A] extends AnyRef

    

19. trait HasVelocity[S, A] extends AnyRef

    

20. case class InInterval[A, B](f: ConstraintFunction[A, B], interval: Interval[B]) extends Constraint[A, B] with Product with Serializable

    

21. final case class Infeasible(v: Double, violations: Int) extends Fit with Product with Serializable

    

22. trait Input[F[_]] extends AnyRef

    

23. implicit final class IntervalOps[A] extends AnyVal

    

24. sealed trait Iteration[M[_], A] extends AnyRef

    

    An Iteration is an atomic action that applies a given "algorithm" for each item within the provided List[A].

    An Iteration is an atomic action that applies a given "algorithm" for each item within the provided List[A].

    An Iteration may either run synchronously or asynchronously (but not in terms of concurrency - at least, not yet)

    The Algorithm passed to an Iteration scheme has the shape:

    NonEmptyList[B] => B => Step[A,NonEmptyList[B]]

    NB: Should consider trying to define this based on the Free monad?

25. case class LessThan[A, B](f: ConstraintFunction[A, B], v: B) extends Constraint[A, B] with Product with Serializable

    

26. case class LessThanEqual[A, B](f: ConstraintFunction[A, B], v: B) extends Constraint[A, B] with Product with Serializable

    

27. case class Mem[A](b: Position[A], v: Position[A]) extends Product with Serializable

    

28. trait MetricSpace[A, B] extends AnyRef

    

    A MetricSpace is a set together with a notion of distance between elements.

    A MetricSpace is a set together with a notion of distance between elements. Distance is computed by a function dist which has the following four laws:

    1. non-negative: forall x y. dist x y >= 0 2. identity of indiscernibles: forall x y. dist x y == 0 <=> x == y 3. symmetry: forall x y. dist x y == dist y x 4. triangle inequality: forall x y z. dist x z <= dist x y + dist y z

    See the Wikipedia article on metric spaces for more details.

29. final case class Multi[A](x: List[Single[A]]) extends Objective[A] with Product with Serializable

    

30. sealed abstract class Objective[A] extends AnyRef

    

    An Objective represents the result of an evaluation.

    An Objective represents the result of an evaluation.

    In most cases, Objective values are Single values that contain the fitness and the violation count of an objective function evaluation.

    Multi duplicates the evaluation for multiple potential objective functions.

31. sealed trait Opt extends AnyRef

    

32. final case class Point[A] extends Position[A] with Product with Serializable

    

33. sealed abstract class Position[A] extends AnyRef

    

34. sealed trait RNG extends AnyRef

    

35. sealed abstract class RVar[A] extends AnyRef

    

36. type Selection[A] = (List[A], A) ⇒ List[A]

    

37. final case class Single[A](f: Fit, v: List[Constraint[A, Double]]) extends Objective[A] with Product with Serializable

    

38. final case class Solution[A] extends Position[A] with Product with Serializable

    

39. final case class Step[A, B] extends Product with Serializable

    

    A Step is a type that models a single step / operation within a CI Algorithm.

    A Step is a type that models a single step / operation within a CI Algorithm.

    The general idea would be that you would compose different Steps to produce the desired algorithmic behaviour.

    Even though this is an initial pass at modeling the compuation of CI algorithms this way, it does provide a recursive, list-like composition allowing a multitude of different usages (or it is hoped to be so).

    Step is nothing more than a data structure that hides the details of a monad transformer stack which represents the algoritmic parts.

40. final case class StepS[A, S, B](run: StateT[[β]Step[A, β], S, B]) extends Product with Serializable

    

41. final class ViolationCount extends AnyVal