Sobol

Instance Constructors

new Sobol(dims: Int, resolution: Byte = maxBits)(implicit params: SobolParams)

dims
The number of dimensions per point.
resolution
The resolution of the sequence in bits. This determines the number of direction values used to compute each dimension and thus the maximum length of the sequence (e.g. 63 bits will provide a sequence of 2^63 elements).
params
The parameters used to initialize the sequence. Default values are provided courtesy of Stephen Joe and Frances Kuo (see http://web.maths.unsw.edu.au/~fkuo/sobol) and support up to 21,201 dimensions

Type Members

class GroupedIterator[B >: A] extends AbstractIterator[Seq[B]] with Iterator[Seq[B]]

Definition Classes
Iterator

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def ++[B >: IndexedSeq[Double]](that: ⇒ GenTraversableOnce[B]): Iterator[B]

Definition Classes
Iterator
def /:[B](z: B)(op: (B, IndexedSeq[Double]) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def :\[B](z: B)(op: (IndexedSeq[Double], B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def addString(b: StringBuilder): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, sep: String): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Definition Classes
TraversableOnce
def aggregate[B](z: ⇒ B)(seqop: (B, IndexedSeq[Double]) ⇒ B, combop: (B, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def asInstanceOf[T0]: T0

Definition Classes
Any
def buffered: BufferedIterator[IndexedSeq[Double]]

Definition Classes
Iterator
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[B](pf: PartialFunction[IndexedSeq[Double], B]): Iterator[B]

Definition Classes
Iterator
Annotations
@migration
Migration
(Changed in version 2.8.0) collect has changed. The previous behavior can be reproduced with toSeq.
def collectFirst[B](pf: PartialFunction[IndexedSeq[Double], B]): Option[B]

Definition Classes
TraversableOnce
def contains(elem: Any): Boolean

Definition Classes
Iterator
def copyToArray[B >: IndexedSeq[Double]](xs: Array[B], start: Int, len: Int): Unit

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
def copyToArray[B >: IndexedSeq[Double]](xs: Array[B]): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToArray[B >: IndexedSeq[Double]](xs: Array[B], start: Int): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToBuffer[B >: IndexedSeq[Double]](dest: Buffer[B]): Unit

Definition Classes
TraversableOnce
def corresponds[B](that: GenTraversableOnce[B])(p: (IndexedSeq[Double], B) ⇒ Boolean): Boolean

Definition Classes
Iterator
def count(p: (IndexedSeq[Double]) ⇒ Boolean): Int

Definition Classes
TraversableOnce → GenTraversableOnce
var count: Int
val directionsByDim: IndexedSeq[(IndexedSeq[Long], Int)]

Initialize direction values for each dimension (direction/index tuples)
def drop(n: Int): Iterator[IndexedSeq[Double]]

Definition Classes
Iterator
def dropWhile(p: (IndexedSeq[Double]) ⇒ Boolean): Iterator[IndexedSeq[Double]]

Definition Classes
Iterator
def duplicate: (Iterator[IndexedSeq[Double]], Iterator[IndexedSeq[Double]])

Definition Classes
Iterator
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exists(p: (IndexedSeq[Double]) ⇒ Boolean): Boolean

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
def filter(p: (IndexedSeq[Double]) ⇒ Boolean): Iterator[IndexedSeq[Double]]

Definition Classes
Iterator
def filterNot(p: (IndexedSeq[Double]) ⇒ Boolean): Iterator[IndexedSeq[Double]]

Definition Classes
Iterator
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(p: (IndexedSeq[Double]) ⇒ Boolean): Option[IndexedSeq[Double]]

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
def flatMap[B](f: (IndexedSeq[Double]) ⇒ GenTraversableOnce[B]): Iterator[B]

Definition Classes
Iterator
def fold[A1 >: IndexedSeq[Double]](z: A1)(op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def foldLeft[B](z: B)(op: (B, IndexedSeq[Double]) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def foldRight[B](z: B)(op: (IndexedSeq[Double], B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def forall(p: (IndexedSeq[Double]) ⇒ Boolean): Boolean

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
def foreach[U](f: (IndexedSeq[Double]) ⇒ U): Unit

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def grouped[B >: IndexedSeq[Double]](size: Int): GroupedIterator[B]

Definition Classes
Iterator
def hasDefiniteSize: Boolean

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
def hasNext: Boolean

Will produce up to 'maxLength' values
Will produce up to 'maxLength' values

Definition Classes
Sobol → Iterator
def hashCode(): Int

Definition Classes
AnyRef → Any
def indexOf[B >: IndexedSeq[Double]](elem: B): Int

Definition Classes
Iterator
def indexWhere(p: (IndexedSeq[Double]) ⇒ Boolean): Int

Definition Classes
Iterator
def isEmpty: Boolean

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isTraversableAgain: Boolean

Definition Classes
Iterator → GenTraversableOnce
var lastX: Option[IndexedSeq[Long]]
def length: Int

Definition Classes
Iterator
def map[B](f: (IndexedSeq[Double]) ⇒ B): Iterator[B]

Definition Classes
Iterator
def max[B >: IndexedSeq[Double]](implicit cmp: Ordering[B]): IndexedSeq[Double]

Definition Classes
TraversableOnce → GenTraversableOnce
def maxBy[B](f: (IndexedSeq[Double]) ⇒ B)(implicit cmp: Ordering[B]): IndexedSeq[Double]

Definition Classes
TraversableOnce → GenTraversableOnce
val maxDims: Int
val maxLength: Long

The maximum expected length of the sequence as determined by the resolution
def min[B >: IndexedSeq[Double]](implicit cmp: Ordering[B]): IndexedSeq[Double]

Definition Classes
TraversableOnce → GenTraversableOnce
def minBy[B](f: (IndexedSeq[Double]) ⇒ B)(implicit cmp: Ordering[B]): IndexedSeq[Double]

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString: String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(sep: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(start: String, sep: String, end: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def next(): IndexedSeq[Double]

Produce next point in the sequence
Produce next point in the sequence

Definition Classes
Sobol → Iterator
def nonEmpty: Boolean

Definition Classes
TraversableOnce → GenTraversableOnce
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def padTo[A1 >: IndexedSeq[Double]](len: Int, elem: A1): Iterator[A1]

Definition Classes
Iterator
implicit val params: SobolParams

The parameters used to initialize the sequence.
The parameters used to initialize the sequence. Default values are provided courtesy of Stephen Joe and Frances Kuo (see http://web.maths.unsw.edu.au/~fkuo/sobol) and support up to 21,201 dimensions
def partition(p: (IndexedSeq[Double]) ⇒ Boolean): (Iterator[IndexedSeq[Double]], Iterator[IndexedSeq[Double]])

Definition Classes
Iterator
def patch[B >: IndexedSeq[Double]](from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B]

Definition Classes
Iterator
def product[B >: IndexedSeq[Double]](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
def reduce[A1 >: IndexedSeq[Double]](op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceLeft[B >: IndexedSeq[Double]](op: (B, IndexedSeq[Double]) ⇒ B): B

Definition Classes
TraversableOnce
def reduceLeftOption[B >: IndexedSeq[Double]](op: (B, IndexedSeq[Double]) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceOption[A1 >: IndexedSeq[Double]](op: (A1, A1) ⇒ A1): Option[A1]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceRight[B >: IndexedSeq[Double]](op: (IndexedSeq[Double], B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceRightOption[B >: IndexedSeq[Double]](op: (IndexedSeq[Double], B) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def reversed: List[IndexedSeq[Double]]

Attributes
protected[this]
Definition Classes
TraversableOnce
def sameElements(that: Iterator[_]): Boolean

Definition Classes
Iterator
def scanLeft[B](z: B)(op: (B, IndexedSeq[Double]) ⇒ B): Iterator[B]

Definition Classes
Iterator
def scanRight[B](z: B)(op: (IndexedSeq[Double], B) ⇒ B): Iterator[B]

Definition Classes
Iterator
def seq: Iterator[IndexedSeq[Double]]

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
def size: Int

Definition Classes
TraversableOnce → GenTraversableOnce
def slice(from: Int, until: Int): Iterator[IndexedSeq[Double]]

Definition Classes
Iterator
def sliding[B >: IndexedSeq[Double]](size: Int, step: Int): GroupedIterator[B]

Definition Classes
Iterator
def span(p: (IndexedSeq[Double]) ⇒ Boolean): (Iterator[IndexedSeq[Double]], Iterator[IndexedSeq[Double]])

Definition Classes
Iterator
def sum[B >: IndexedSeq[Double]](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def take(n: Int): Iterator[IndexedSeq[Double]]

Definition Classes
Iterator
def takeWhile(p: (IndexedSeq[Double]) ⇒ Boolean): Iterator[IndexedSeq[Double]]

Definition Classes
Iterator
def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, IndexedSeq[Double], Col[IndexedSeq[Double]]]): Col[IndexedSeq[Double]]

Definition Classes
TraversableOnce → GenTraversableOnce
def toArray[B >: IndexedSeq[Double]](implicit arg0: ClassTag[B]): Array[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toBuffer[B >: IndexedSeq[Double]]: Buffer[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toIndexedSeq: IndexedSeq[IndexedSeq[Double]]

Definition Classes
TraversableOnce → GenTraversableOnce
def toIterable: Iterable[IndexedSeq[Double]]

Definition Classes
TraversableOnce → GenTraversableOnce
def toIterator: Iterator[IndexedSeq[Double]]

Definition Classes
Iterator → GenTraversableOnce
def toList: List[IndexedSeq[Double]]

Definition Classes
TraversableOnce → GenTraversableOnce
def toMap[T, U](implicit ev: <:<[IndexedSeq[Double], (T, U)]): Map[T, U]

Definition Classes
TraversableOnce → GenTraversableOnce
def toSeq: Seq[IndexedSeq[Double]]

Definition Classes
TraversableOnce → GenTraversableOnce
def toSet[B >: IndexedSeq[Double]]: Set[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toStream: Stream[IndexedSeq[Double]]

Definition Classes
Iterator → GenTraversableOnce
def toString(): String

Definition Classes
Iterator → AnyRef → Any
def toTraversable: Traversable[IndexedSeq[Double]]

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
def toVector: Vector[IndexedSeq[Double]]

Definition Classes
TraversableOnce → GenTraversableOnce
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withFilter(p: (IndexedSeq[Double]) ⇒ Boolean): Iterator[IndexedSeq[Double]]

Definition Classes
Iterator
def zip[B](that: Iterator[B]): Iterator[(IndexedSeq[Double], B)]

Definition Classes
Iterator
def zipAll[B, A1 >: IndexedSeq[Double], B1 >: B](that: Iterator[B], thisElem: A1, thatElem: B1): Iterator[(A1, B1)]

Definition Classes
Iterator
def zipWithIndex: Iterator[(IndexedSeq[Double], Int)]

Definition Classes
Iterator

Related Docs: object Sobol | package lobos

class Sobol extends Iterator[IndexedSeq[Double]]

Instance Constructors

new Sobol(dims: Int, resolution: Byte = maxBits)(implicit params: SobolParams)

Type Members

class GroupedIterator[B >: A] extends AbstractIterator[Seq[B]] with Iterator[Seq[B]]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[B >: IndexedSeq[Double]](that: ⇒ GenTraversableOnce[B]): Iterator[B]

def /:[B](z: B)(op: (B, IndexedSeq[Double]) ⇒ B): B

def :\[B](z: B)(op: (IndexedSeq[Double], B) ⇒ B): B

final def ==(arg0: Any): Boolean

def addString(b: StringBuilder): StringBuilder

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

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

def aggregate[B](z: ⇒ B)(seqop: (B, IndexedSeq[Double]) ⇒ B, combop: (B, B) ⇒ B): B

final def asInstanceOf[T0]: T0

def buffered: BufferedIterator[IndexedSeq[Double]]

def clone(): AnyRef

def collect[B](pf: PartialFunction[IndexedSeq[Double], B]): Iterator[B]

def collectFirst[B](pf: PartialFunction[IndexedSeq[Double], B]): Option[B]

def contains(elem: Any): Boolean

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

def copyToArray[B >: IndexedSeq[Double]](xs: Array[B]): Unit

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

def copyToBuffer[B >: IndexedSeq[Double]](dest: Buffer[B]): Unit

def corresponds[B](that: GenTraversableOnce[B])(p: (IndexedSeq[Double], B) ⇒ Boolean): Boolean

def count(p: (IndexedSeq[Double]) ⇒ Boolean): Int

var count: Int

val directionsByDim: IndexedSeq[(IndexedSeq[Long], Int)]

def drop(n: Int): Iterator[IndexedSeq[Double]]

def dropWhile(p: (IndexedSeq[Double]) ⇒ Boolean): Iterator[IndexedSeq[Double]]

def duplicate: (Iterator[IndexedSeq[Double]], Iterator[IndexedSeq[Double]])

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(p: (IndexedSeq[Double]) ⇒ Boolean): Boolean

def filter(p: (IndexedSeq[Double]) ⇒ Boolean): Iterator[IndexedSeq[Double]]

def filterNot(p: (IndexedSeq[Double]) ⇒ Boolean): Iterator[IndexedSeq[Double]]

def finalize(): Unit

def find(p: (IndexedSeq[Double]) ⇒ Boolean): Option[IndexedSeq[Double]]

def flatMap[B](f: (IndexedSeq[Double]) ⇒ GenTraversableOnce[B]): Iterator[B]

def fold[A1 >: IndexedSeq[Double]](z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft[B](z: B)(op: (B, IndexedSeq[Double]) ⇒ B): B

def foldRight[B](z: B)(op: (IndexedSeq[Double], B) ⇒ B): B

def forall(p: (IndexedSeq[Double]) ⇒ Boolean): Boolean

def foreach[U](f: (IndexedSeq[Double]) ⇒ U): Unit

final def getClass(): Class[_]

def grouped[B >: IndexedSeq[Double]](size: Int): GroupedIterator[B]

def hasDefiniteSize: Boolean

def hasNext: Boolean

def hashCode(): Int

def indexOf[B >: IndexedSeq[Double]](elem: B): Int

def indexWhere(p: (IndexedSeq[Double]) ⇒ Boolean): Int

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def isTraversableAgain: Boolean

var lastX: Option[IndexedSeq[Long]]

def length: Int

def map[B](f: (IndexedSeq[Double]) ⇒ B): Iterator[B]

def max[B >: IndexedSeq[Double]](implicit cmp: Ordering[B]): IndexedSeq[Double]

def maxBy[B](f: (IndexedSeq[Double]) ⇒ B)(implicit cmp: Ordering[B]): IndexedSeq[Double]

val maxDims: Int

val maxLength: Long

def min[B >: IndexedSeq[Double]](implicit cmp: Ordering[B]): IndexedSeq[Double]

def minBy[B](f: (IndexedSeq[Double]) ⇒ B)(implicit cmp: Ordering[B]): IndexedSeq[Double]

def mkString: String

def mkString(sep: String): String

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

final def ne(arg0: AnyRef): Boolean

def next(): IndexedSeq[Double]

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def padTo[A1 >: IndexedSeq[Double]](len: Int, elem: A1): Iterator[A1]

implicit val params: SobolParams

def partition(p: (IndexedSeq[Double]) ⇒ Boolean): (Iterator[IndexedSeq[Double]], Iterator[IndexedSeq[Double]])

def patch[B >: IndexedSeq[Double]](from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B]

def product[B >: IndexedSeq[Double]](implicit num: Numeric[B]): B