net.sf.phiweave.collection

MappedVector

class MappedVector extends SparseVector with TrieMap with MappedVectorAdapter

go to: companion
Inherited
  1. Hide All
  2. Show all
  1. MappedVectorAdapter
  2. JObjectMutable
  3. JText
  4. JEntity
  5. TrieMap
  6. SparseVector
  7. Map
  8. MapLike
  9. Cloneable
  10. Shrinkable
  11. Builder
  12. Growable
  13. Map
  14. MapLike
  15. Subtractable
  16. PartialFunction
  17. Function1
  18. Iterable
  19. Iterable
  20. IterableLike
  21. Equals
  22. Traversable
  23. Mutable
  24. Traversable
  25. GenericTraversableTemplate
  26. TraversableLike
  27. TraversableOnce
  28. FilterMonadic
  29. HasNewBuilder
  30. AnyRef
  31. Any
Visibility
  1. Public
  2. All

Type Members

  1. type Self = TrieMap

Value Members

  1. def !=(arg0: AnyRef): Boolean

  2. def !=(arg0: Any): Boolean

    o != arg0 is the same as !(o == (arg0)).

  3. def ##(): Int

  4. def $asInstanceOf[T0](): T0

  5. def $isInstanceOf[T0](): Boolean

  6. def +[B1 >: Double](elem1: (Int, B1), elem2: (Int, B1), elems: (Int, B1)*): Map[Int, B1]

  7. def +[B1 >: Double](kv: (Int, B1)): Map[Int, B1]

  8. def ++[B1 >: Double](xs: TraversableOnce[(Int, B1)]): Map[Int, B1]

  9. def ++[B >: (Int, Double), That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[TrieMap, B, That]): That

  10. def ++=(xs: TraversableOnce[(Int, Double)]): Growable[(Int, Double)]

  11. def +=(kv: (Int, Double)): TrieMap

  12. def +=(elem1: (Int, Double), elem2: (Int, Double), elems: (Int, Double)*): Growable[(Int, Double)]

  13. def -(elem1: Int, elem2: Int, elems: Int*): TrieMap

  14. def -(key: Int): TrieMap

  15. def --(xs: TraversableOnce[Int]): TrieMap

  16. def --=(xs: TraversableOnce[Int]): Shrinkable[Int]

  17. def -=(k: Int): TrieMap

  18. def -=(elem1: Int, elem2: Int, elems: Int*): Shrinkable[Int]

  19. def /:[B](z: B)(op: (B, (Int, Double)) ⇒ B): B

  20. def :\[B](z: B)(op: ((Int, Double), B) ⇒ B): B

  21. def ==(arg0: AnyRef): Boolean

    o == arg0 is the same as if (o eq null) arg0 eq null else o.equals(arg0).

  22. def ==(arg0: Any): Boolean

    o == arg0 is the same as o.equals(arg0).

  23. var N: Int

  24. def add(v: SparseVector): Unit

    Component-wise vector addition; a new entry will be allocated for any component occuring in vector v that is currently unsupported in this vector

  25. def addScaled(v: SparseVector, alpha: Double): Unit

    Similar to < href="#add">add, except that all components of v are scaled by alpha before they are added

  26. def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

  27. def addString(b: StringBuilder): StringBuilder

  28. def addString(b: StringBuilder, sep: String): StringBuilder

  29. def addSupported(v: SparseVector): Unit

    Component-wise vector addition; only those indices that actually occur in both sparse vectors are updated

  30. def addSupportedScaled(w: Iterator[Double], alpha: Double): Unit

  31. def addSupportedScaled(v: SparseVector, alpha: Double): Unit

    Similar to addSupported, except that all components of v are scaled by alpha before they are added

  32. def andThen[C](k: (Double) ⇒ C): PartialFunction[Int, C]

  33. def apply(key: Int): Double

  34. def asInstanceOf[T0]: T0

    This method is used to cast the receiver object to be of type T0.

  35. def canEqual(that: Any): Boolean

  36. def clear(): Unit

  37. def clone(): MappedVector

    This method creates and returns a copy of the receiver object.

  38. def collect[B, That](pf: PartialFunction[(Int, Double), B])(implicit bf: CanBuildFrom[TrieMap, B, That]): That

  39. def companion: GenericCompanion[Iterable[A][A]]

  40. def compose[A](g: (A) ⇒ Int): (A) ⇒ Double

  41. def contains(key: Int): Boolean

  42. def copyToArray[B >: (Int, Double)](xs: Array[B], start: Int, len: Int): Unit

  43. def copyToArray[B >: (Int, Double)](xs: Array[B]): Unit

  44. def copyToArray[B >: (Int, Double)](xs: Array[B], start: Int): Unit

  45. def copyToBuffer[B >: (Int, Double)](dest: Buffer[B]): Unit

  46. def count(p: ((Int, Double)) ⇒ Boolean): Int

  47. def default(key: Int): Double

  48. def denseValues(): Array[Double]

  49. def dotProduct(v: SparseVector): Double

    Computes the dot product of this vector and another sparse vector

  50. def drop(n: Int): TrieMap

  51. def dropRight(n: Int): TrieMap

  52. def dropWhile(p: ((Int, Double)) ⇒ Boolean): TrieMap

  53. def elements: Iterator[(Int, Double)]

  54. def empty: TrieMap

  55. def entries: Iterator[Int] {...}

  56. def eq(arg0: AnyRef): Boolean

    This method is used to test whether the argument (arg0) is a reference to the receiver object (this).

  57. def equals(that: Any): Boolean

    This method is used to compare the receiver object (this) with the argument object (arg0) for equivalence.

  58. def exists(p: ((Int, Double)) ⇒ Boolean): Boolean

  59. def filter(p: ((Int, Double)) ⇒ Boolean): TrieMap

  60. def filterKeys(p: (Int) ⇒ Boolean): Map[Int, Double]

  61. def filterNot(p: ((Int, Double)) ⇒ Boolean): TrieMap

  62. def finalize(): Unit

    This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object.

  63. def find(k: Int): Int

  64. def find(p: ((Int, Double)) ⇒ Boolean): Option[(Int, Double)]

  65. def findOrCreate(k: Int): Int

  66. def first: (Int, Double)

  67. def firstOption: Option[(Int, Double)]

  68. def flatMap[B, That](f: ((Int, Double)) ⇒ Traversable[B])(implicit bf: CanBuildFrom[TrieMap, B, That]): That

  69. def flatten[B](implicit asTraversable: ((Int, Double)) ⇒ Traversable[B]): Iterable[B]

  70. def foldLeft[B](z: B)(op: (B, (Int, Double)) ⇒ B): B

  71. def foldRight[B](z: B)(op: ((Int, Double), B) ⇒ B): B

  72. def forall(p: ((Int, Double)) ⇒ Boolean): Boolean

  73. def foreach[U](f: ((Int, Double)) ⇒ U): Unit

  74. def genericBuilder[B]: Builder[B, Iterable[B]]

  75. def get(k: Int): Option[Double]

  76. def getClass(): java.lang.Class[_]

    Returns a representation that corresponds to the dynamic class of the receiver object.

  77. def getOrElse[B1 >: Double](key: Int, default: ⇒ B1): B1

  78. def getOrElseUpdate(key: Int, op: ⇒ Double): Double

  79. def groupBy[K](f: ((Int, Double)) ⇒ K): Map[K, TrieMap]

  80. def grouped(size: Int): Iterator[TrieMap]

  81. def hasDefiniteSize: Boolean

  82. def hashCode(): Int

    Returns a hash code value for the object.

  83. def head: (Int, Double)

  84. def headOption: Option[(Int, Double)]

  85. def init: TrieMap

  86. def initializedAs(alpha: Double): MappedVector

    Returns a clone of this vector, with all supported components set to alpha

  87. def isDefinedAt(key: Int): Boolean

  88. def isEmpty: Boolean

  89. def isInstanceOf[T0]: Boolean

    This method is used to test whether the dynamic type of the receiver object is T0.

  90. def isTraversableAgain: Boolean

  91. def iterator: Iterator[(Int, Double)]

  92. def jadd(key: JString, value: JEntity): Unit

  93. def jderror(unexpected: JEntity, expected: String, id: String): Nothing

  94. def jnew(key: JString): JEntity

  95. def jserror(unserializable: String, id: String): Nothing

  96. var key: Array[Int]

  97. def keySet: Set[Int]

  98. def keys: Iterable[Int]

  99. def keysIterator: Iterator[Int]

  100. def last: (Int, Double)

  101. def lastOption: Option[(Int, Double)]

  102. def lift: (Int) ⇒ Option[Double]

  103. def map[B, That](f: ((Int, Double)) ⇒ B)(implicit bf: CanBuildFrom[TrieMap, B, That]): That

  104. def mapElements[C](f: (Double) ⇒ C): Map[Int, C]

  105. def mapResult[NewTo](f: (TrieMap) ⇒ NewTo): Builder[(Int, Double), NewTo]

  106. def mapValues[C](f: (Double) ⇒ C): Map[Int, C]

  107. def max[B >: (Int, Double)](implicit cmp: Ordering[B]): (Int, Double)

  108. def min[B >: (Int, Double)](implicit cmp: Ordering[B]): (Int, Double)

  109. def mkString: String

  110. def mkString(sep: String): String

  111. def mkString(start: String, sep: String, end: String): String

  112. var n: Int

  113. def ne(arg0: AnyRef): Boolean

    o.ne(arg0) is the same as !(o.eq(arg0)).

  114. def newBuilder: Builder[(Int, Double), TrieMap]

  115. def nonEmpty: Boolean

  116. def notify(): Unit

    Wakes up a single thread that is waiting on the receiver object's monitor.

  117. def notifyAll(): Unit

    Wakes up all threads that are waiting on the receiver object's monitor.

  118. var one: Array[Int]

  119. def orElse[A1 <: Int, B1 >: Double](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

  120. def partition(p: ((Int, Double)) ⇒ Boolean): (TrieMap, TrieMap)

  121. def print(buf: OutputBuffer, path: List[String], verbose: (JEntity, List[String]) ⇒ Boolean): Unit

  122. def product[B >: (Int, Double)](implicit num: Numeric[B]): B

  123. def projection: IterableView[(Int, Double), TrieMap]

  124. def put(key: Int, value: Double): Option[Double]

  125. def reduceLeft[B >: (Int, Double)](op: (B, (Int, Double)) ⇒ B): B

  126. def reduceLeftOption[B >: (Int, Double)](op: (B, (Int, Double)) ⇒ B): Option[B]

  127. def reduceRight[B >: (Int, Double)](op: ((Int, Double), B) ⇒ B): B

  128. def reduceRightOption[B >: (Int, Double)](op: ((Int, Double), B) ⇒ B): Option[B]

  129. def remove(key: Int): Option[Double]

  130. def removeKey(key: Int): Option[Double]

  131. def repr: TrieMap

  132. def result(): TrieMap

  133. def retain(p: (Int, Double) ⇒ Boolean): MapLike[Int, Double, TrieMap]

  134. def reversed: List[(Int, Double)]

  135. val root: Int

  136. var s: Int

  137. def sameElements[B >: (Int, Double)](that: Iterable[B]): Boolean

  138. def scale(alpha: Double): Unit

    Scales each component of the sparse vector

  139. def scanLeft[B, That](z: B)(op: (B, (Int, Double)) ⇒ B)(implicit bf: CanBuildFrom[TrieMap, B, That]): That

  140. def scanRight[B, That](z: B)(op: ((Int, Double), B) ⇒ B)(implicit bf: CanBuildFrom[TrieMap, B, That]): That

  141. def set(idx: Int, alpha: Double): Unit

    Sets the given component to the given scalar value; a new entry will be allocated if required

  142. def setSupported(alpha: Double): Unit

    Sets all supported, i.

  143. def size: Int

  144. def sizeHint(coll: scala.collection.TraversableLike[_, _], delta: Int): Unit

  145. def sizeHint(size: Int): Unit

  146. def sizeHintBounded(size: Int, boundingColl: scala.collection.TraversableLike[_, _]): Unit

  147. def slice(from: Int, until: Int): TrieMap

  148. def sliding[B >: (Int, Double)](size: Int, step: Int): Iterator[TrieMap]

  149. def sliding[B >: (Int, Double)](size: Int): Iterator[TrieMap]

  150. def span(p: ((Int, Double)) ⇒ Boolean): (TrieMap, TrieMap)

  151. def splitAt(n: Int): (TrieMap, TrieMap)

  152. def stringPrefix: String

  153. def sum[B >: (Int, Double)](implicit num: Numeric[B]): B

  154. def synchronized[T0](arg0: T0): T0

  155. def tail: TrieMap

  156. def take(n: Int): TrieMap

  157. def takeRight(n: Int): TrieMap

  158. def takeWhile(p: ((Int, Double)) ⇒ Boolean): TrieMap

  159. def thisCollection: Iterable[(Int, Double)]

  160. def toArray[B >: (Int, Double)](implicit arg0: ClassManifest[B]): Array[B]

  161. def toBuffer[B >: (Int, Double)]: Buffer[B]

  162. def toCollection(repr: TrieMap): Iterable[(Int, Double)]

  163. def toIndexedSeq[B >: (Int, Double)]: IndexedSeq[B]

  164. def toIterable: Iterable[(Int, Double)]

  165. def toIterator: Iterator[(Int, Double)]

  166. def toList: List[(Int, Double)]

  167. def toMap[T, U](implicit ev: <:<[(Int, Double), (T, U)]): Map[T, U]

  168. def toSeq: Seq[(Int, Double)]

  169. def toSet[B >: (Int, Double)]: Set[B]

  170. def toStream: Stream[(Int, Double)]

  171. def toString(): String

    Returns a string representation of the object.

  172. def toTraversable: Traversable[(Int, Double)]

  173. def transform(f: (Int, Double) ⇒ Double): MapLike[Int, Double, TrieMap]

  174. def transpose[B](implicit asTraversable: ((Int, Double)) ⇒ Traversable[B]): Iterable[Iterable[B]]

  175. def unzip[A1, A2](implicit asPair: ((Int, Double)) ⇒ (A1, A2)): (Iterable[A1], Iterable[A2])

  176. def update(key: Int, value: Double): Unit

  177. def updated[B1 >: Double](key: Int, value: B1): Map[Int, B1]

  178. var value: Array[Double]

  179. def values: Iterable[Double]

  180. def valuesIterator: Iterator[Double]

  181. def view(from: Int, until: Int): IterableView[(Int, Double), TrieMap]

  182. def view: IterableView[(Int, Double), TrieMap]

  183. def wait(): Unit

  184. def wait(arg0: Long, arg1: Int): Unit

  185. def wait(arg0: Long): Unit

  186. def withFilter(p: ((Int, Double)) ⇒ Boolean): FilterMonadic[(Int, Double), TrieMap]

  187. var zero: Array[Int]

  188. def zip[A1 >: (Int, Double), B, That](that: Iterable[B])(implicit bf: CanBuildFrom[TrieMap, (A1, B), That]): That

  189. def zipAll[B, A1 >: (Int, Double), That](that: Iterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[TrieMap, (A1, B), That]): That

  190. def zipWithIndex[A1 >: (Int, Double), That](implicit bf: CanBuildFrom[TrieMap, (A1, Int), That]): That