IntervalsMatrix.scala

package io.sease.ra

object IntervalsMatrix {

  case class IntervalsMatrix(matrix: Iterator[Seq[Int]]) {
    def length: Int = Option(matrix).map(_.length).getOrElse(0)

    def isEmpty: Boolean = matrix.isEmpty

    override def toString: String = toString(_.toString)

    override def equals(that: Any): Boolean = {
      that match {
        case other: IntervalsMatrix => other.matrix sameElements matrix
        case _                      => false
      }
    }

    def toString(valueExtractor: Int => String): String = {
      safeCopy.zipWithIndex.map {
        case (vector, index) =>
          s"t$index - t${index + 1}\t=>" + vector
            .map(valueExtractor)
            .mkString(" [", "] [", "]\n")
      }.mkString
    }

    private def safeCopy = matrix.duplicate._1
  }

  def apply(chromaMatrix: IndexedSeq[Seq[Double]],
            k: Int,
            table: IntervalsTable): IntervalsMatrix = {
    val matrix = Option(chromaMatrix).getOrElse(Seq.empty)

    require(matrix.nonEmpty, "Chroma Matrix cannot be empty!")
    require(k <= 12, "Chroma Matrix must be [m,<=12]")
    require(Option(table).isDefined, "IntervalsTable cannot be null")

    IntervalsMatrix(
      matrix
        .filter(_.length >= k)
        .map(
          vector =>
            vector.zipWithIndex
              .sortBy(_._1)(Ordering[Double].reverse)
              .take(k)
              .map(_._2))
        .sliding(2)
        .map(t => table.distanceBetween(t.head, t.tail.head)))
  }

  def apply(chromaMatrix: Array[Array[Double]],
            k: Int,
            table: IntervalsTable): IntervalsMatrix = {
    this(for (i <- chromaMatrix.indices) yield chromaMatrix(i).toSeq, k, table)
  }

  def apply(matrix: Iterator[Seq[Int]]): IntervalsMatrix =
    IntervalsMatrix(matrix)
}