ProjectionIndexer

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def andThen[A](g: (Int) ⇒ A): (Int) ⇒ A

def apply(f: Int): Int

Same as project(f)

final def asInstanceOf[T0]: T0

def clone(): AnyRef

val coarseEncoder: Encoder[C]

val coarseIndex: Index[C]

def coarseSymbol(f: Int): C

def compose[F2](finerProjections: ProjectionIndexer[F, F2]): ProjectionIndexer[C, F2]

From a PI[C, F] and a PI[F, F2], makes a PI[C, F2]

def compose[A](g: (A) ⇒ Int): (A) ⇒ Int

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val fineIndex: Index[F]

final def getClass(): Class[_]

val globalRefinements: Array[Array[Int]]

def globalize(c: C, f: Int): F

def globalize(c: Int, f: Int): Int

def hashCode(): Int

def indexAndLocalize(f: F): (Int, Int)

final def isInstanceOf[T0]: Boolean

def localRefinements(c: Int): Array[Int]

val localizationArray: Array[Int]

def localize(f: F): (C, Int)

def localize(f: Int): Int

def localizeArray[T](array: Array[T])(implicit arg0: ClassTag[T]): Array[Array[T]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def numRefinements(c: Int): Int

val perSymbolRefinements: Array[Array[Int]]

def project(f: F): C

def project(f: Int): Int

Computes the projection of the indexed fine label f to an indexed coarse label.

def refinementsOf(c: C): IndexedSeq[F]

def refinementsOf(c: Int): Array[Int]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit