Number - Scala Mathematical Library
1.10.6
API
Generated with
Number - Scala Mathematical Library/com.phasmidsoftware.number/com.phasmidsoftware.number.core/com.phasmidsoftware.number.core.misc

com.phasmidsoftware.number.core.misc

package com.phasmidsoftware.number.core.misc

Members list

Type members

Classlikes

case class AndThen[X](f: X => X, g: X => X)(using evidence$1: Numeric[X]) extends LazyFunction[X]

the order of the parameters is significant. The result of applying this function is: g(f(x))

the order of the parameters is significant. The result of applying this function is: g(f(x))

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class LazyFunction[X]
trait X => X
class Object
trait Matchable
class Any
Show all
trait Approximate[X]

The Approximate trait provides a mechanism to compute approximate representations of values of type X as Double. Implementations of this trait define how to compute this approximation while adhering to a specified maximum allowable error.

The Approximate trait provides a mechanism to compute approximate representations of values of type X as Double. Implementations of this trait define how to compute this approximation while adhering to a specified maximum allowable error.

This is particularly useful for applications where an approximation with controlled precision is sufficient and can improve performance.

It operates based on an implicit epsilon value, which determines the acceptable error tolerance between the true value and the approximate result.

Type parameters

X

The type of the input object to be approximated.

Attributes

Supertypes
class Object
trait Matchable
class Any
abstract class BaseRNG[T](val get: T) extends RNG[T]

Attributes

Supertypes
trait RNG[T]
class Object
trait Matchable
class Any
Known subtypes
class RandomLong
object Benchmark

An object providing benchmarking utilities for measuring the execution time of code snippets. It includes an implicit class that extends the functionality of the Int type, allowing expressions to be evaluated multiple times with performance metrics.

An object providing benchmarking utilities for measuring the execution time of code snippets. It includes an implicit class that extends the functionality of the Int type, allowing expressions to be evaluated multiple times with performance metrics.

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
Benchmark.type
case class Bounded(mu: Double, delta: Double) extends FuzzyBase

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class FuzzyBase
trait Fuzzy
class Object
trait Matchable
class Any
Show all
case class Bumperator[T](xs: Iterator[T])(f: (T, T) => Boolean) extends Iterator[T]

Bumperator is a concrete Iterator that selectively filters out elements based on a user-supplied function. Elements are compared using a binary predicate, and if the function returns true for a pair of elements, both elements are skipped in the resulting iteration.

Bumperator is a concrete Iterator that selectively filters out elements based on a user-supplied function. Elements are compared using a binary predicate, and if the function returns true for a pair of elements, both elements are skipped in the resulting iteration.

The name comes from the rowing races at Oxford and Cambridge whereby when a boat "bumps" the boat in front, both withdraw for the day but return the following day with their former order reversed. See Bumps race

TODO move this into expression module.

Type parameters

T

the type of each element in the iterator

Value parameters

f

a binary predicate function that determines whether two consecutive elements should be "bumped out" (skipped)

xs

an input iterator providing elements to iterate over

Attributes

Note

Throws java.lang.IllegalArgumentException if the input iterator is empty

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
trait Iterator[T]
trait IterableOnceOps[T, Iterator, Iterator[T]]
trait IterableOnce[T]
class Object
trait Matchable
class Any
Show all
object Bumperator

The Bumperator companion object provides a factory method to create an instance of the Bumperator iterator. It applies a filtering function to consecutive elements of a sequence, ensuring only those satisfying the provided condition remain in the iteration pipeline.

The Bumperator companion object provides a factory method to create an instance of the Bumperator iterator. It applies a filtering function to consecutive elements of a sequence, ensuring only those satisfying the provided condition remain in the iteration pipeline.

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
Bumperator.type
case class CF(a: Long, c: ConFrac)

Scaled ConFrac. The "value" of the ConFrac is "divided" by a.

Scaled ConFrac. The "value" of the ConFrac is "divided" by a.

CONSIDER making CF a trait.

Value parameters

a

the coefficient to apply to c`.

c

a ConFrac.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
case class Composed[X](f: X => X, g: X => X)(using evidence$1: Numeric[X]) extends LazyFunction[X]

the order of the parameters is significant. The result of applying this function is: f(g(x))

the order of the parameters is significant. The result of applying this function is: f(g(x))

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class LazyFunction[X]
trait X => X
class Object
trait Matchable
class Any
Show all
case class ComposedDifferentiable[X](g1: DiFunc[X], g2: DiFunc[X])(using evidence$1: Numeric[X]) extends LazyFunction[X], DiFunc[X]

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
trait DiFunc[X]
class LazyFunction[X]
trait X => X
class Object
trait Matchable
class Any
Show all
class ConFrac(val b: Long, co: => Option[CF]) extends Evaluatable, Takeable

This Class defines a lazily-evaluated Generalized Continued Fraction, somewhat like a LazyList.

This Class defines a lazily-evaluated Generalized Continued Fraction, somewhat like a LazyList.

Value parameters

b

the (additive) coefficient, represented on the Wikipedia page (Generalized CF) as b.

co

an optional reference to a ConFrac.

Attributes

Companion
object
Supertypes
trait Takeable
trait Evaluatable
class Object
trait Matchable
class Any
object ConFrac

Companion object for ConFrac.

Companion object for ConFrac.

This object defines an apply method which takes a LazyList of Pairs and returns a ConFrac. This object defines a "simple" method which takes a LazyList of Int and returns a ConFrac.

In addition, several ConFrac objects are defined, one each for pi, e, phi, and sqrt(19).

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
ConFrac.type
case class ConFracException(str: String) extends RuntimeException

Represents an exception that is specifically thrown in the context of continued fraction computations or related operations.

Represents an exception that is specifically thrown in the context of continued fraction computations or related operations.

Value parameters

str

The error message associated with this exception.

Attributes

Constructor

Creates a new instance of ConFracException with the provided error message.

Supertypes
trait Product
trait Equals
class RuntimeException
class Exception
class Throwable
trait Serializable
class Object
trait Matchable
class Any
Show all
case class ContinuedFraction(cf: ConFrac, infinite: Boolean = ..., markov: Double = ...)

This Class defines a Continued Fraction. See Continued Fraction.

This Class defines a Continued Fraction. See Continued Fraction.

Continued fractions are an interesting way of defining irrational (or rational) numbers. There are two distinct types:

Finite

Gives rise to a rational number or an approximation to an irrational number
Infinite
Gives rise to an irrational number

Value parameters

cf

the ConFrac that defines this ContinuedFraction.

infinite

whether this ContinuedFraction is infinite (defaults to true).

markov

the Markov constant for this particular ContinuedFraction (defaults to Hurwitz, i.e. the square root of 5)

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object ContinuedFraction

This object represents utility methods and predefined constants for working with continued fractions. It provides functionality to construct, transform, and manipulate ContinuedFraction instances.

This object represents utility methods and predefined constants for working with continued fractions. It provides functionality to construct, transform, and manipulate ContinuedFraction instances.

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
object Converters

These converters are used by the tryMap and transpose.

These converters are used by the tryMap and transpose.

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
Converters.type
trait DiFunc[X]

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
class DiFuncBase[X]
object Inverse
object Negative
class Power
class Times
Show all
abstract class DiFuncBase[X](g: X => X, ds: X => Double*) extends DiFunc[X]

Base class for trait DiFunc

Base class for trait DiFunc

Value parameters

ds

a variable number of one-functions

g

function which transforms value (THE function)

Attributes

Supertypes
trait DiFunc[X]
class Object
trait Matchable
class Any
Known subtypes
object Inverse
object Negative
class Power
class Times
Show all
abstract class DifferentiableFunction[X](g: X => X, ds: X => Double*) extends DiFuncBase[X], X => X

Attributes

Supertypes
trait X => X
class DiFuncBase[X]
trait DiFunc[X]
class Object
trait Matchable
class Any
Show all
Known subtypes
trait Evaluatable

A trait representing an entity that can be evaluated for an approximate double value.

A trait representing an entity that can be evaluated for an approximate double value.

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
class ConFrac
case class Exact(x: Double) extends FuzzyBase

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class FuzzyBase
trait Fuzzy
class Object
trait Matchable
class Any
Show all
case class Exp[X]()(implicit ev: Numeric[X]) extends Known[X]

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Known[X]
class LazyFunction[X]
trait X => X
class Object
trait Matchable
class Any
Show all
case class ExpDifferentiable[X]()(ev: FuzzyIsFractional) extends KnownDifferentiableFunction[X]

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
trait X => X
class DiFuncBase[X]
trait DiFunc[X]
class Object
trait Matchable
class Any
Show all
object FP

This module is concerned with the generic operations for operating on Numbers.

This module is concerned with the generic operations for operating on Numbers.

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
FP.type
object Factorial

The Factorial object provides methods to compute the factorial of a given non-negative integer. The calculation is implemented using tail recursion for improved performance and optimization.

The Factorial object provides methods to compute the factorial of a given non-negative integer. The calculation is implemented using tail recursion for improved performance and optimization.

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
Factorial.type
sealed trait Fuzzy

The Fuzzy trait defines a quantity for which there is doubt about its actual value. This Fuzzy trait is Numeric (it extends Fractional), and thus Fuzzy values can be ordered, compared, and take part in arithmetic operations, including division.

The Fuzzy trait defines a quantity for which there is doubt about its actual value. This Fuzzy trait is Numeric (it extends Fractional), and thus Fuzzy values can be ordered, compared, and take part in arithmetic operations, including division.

In this implementation of Fuzzy, the actual value is represented by a Double (see the get method).

In general, a Fuzzy trait would only require ordering.

Numeric fuzzy objects define a probability distribution such that it is possible to determine the likelihood that the actual value of the fuzzy object is between two limits. Typical distributions are Gaussian (i.e. "Normal") and Box (i.e. a truncated Uniform distribution). Additionally, we support Trapezoid shape. Other distributions are possible, of course, especially when Gaussian fuzzy objects are combined with other fuzzy objects. This package does not properly handle these situations.

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class FuzzyBase
class Bounded
class Exact
class Gaussian
object Fuzzy

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Fuzzy.type
abstract class FuzzyBase(nominal: Double, delta: Double, distribution: AbstractRealDistribution) extends Fuzzy

Base class for the implementation of Fuzzy objects

Base class for the implementation of Fuzzy objects

Attributes

Supertypes
trait Fuzzy
class Object
trait Matchable
class Any
Known subtypes
class Bounded
class Exact
class Gaussian
class FuzzyParser extends JavaTokenParsers

Attributes

Supertypes
trait JavaTokenParsers
trait RegexParsers
trait Parsers
class Object
trait Matchable
class Any
Show all
Self type
case class Gaussian(mu: Double, sigma: Double) extends FuzzyBase

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class FuzzyBase
trait Fuzzy
class Object
trait Matchable
class Any
Show all
case class Identity[X]()(using evidence$1: Numeric[X]) extends Known[X]

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Known[X]
class LazyFunction[X]
trait X => X
class Object
trait Matchable
class Any
Show all
Known subtypes
case class InfiniteProduct[X](f: Int => X)(using evidence$1: Numeric[X]) extends Int => X

This case class represents an infinite product of terms which can be derived by a function (f) which takes as its parameter a prime number.

This case class represents an infinite product of terms which can be derived by a function (f) which takes as its parameter a prime number.

Each successive term in the product is based on the list of primes starting with 2.

Type parameters

X

a type for which there is evidence of Numeric[X].

Value parameters

f

the function (see description above).

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
trait Int => X
class Object
trait Matchable
class Any
Show all
case class InfiniteSum[X](x0: X, f: (Long, X) => X)(using evidence$1: Numeric[X]) extends Int => X

This case class represents an infinite sum of terms which can be derived by a function (f) which takes as its parameters the index of the term and the previous value of the term.

This case class represents an infinite sum of terms which can be derived by a function (f) which takes as its parameters the index of the term and the previous value of the term.

Type parameters

X

a type for which there is evidence of Numeric[X].

Value parameters

f

the function (see description above).

x0

the initial value of type X which is used for the first term.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
trait Int => X
class Object
trait Matchable
class Any
Show all
case object Inverse extends DiFuncBase[Double]

Attributes

Supertypes
trait Singleton
trait Product
trait Mirror
trait Serializable
trait Product
trait Equals
class DiFuncBase[Double]
trait DiFunc[Double]
class Object
trait Matchable
class Any
Show all
Self type
Inverse.type
abstract class Known[X](name: String)(using evidence$1: Numeric[X]) extends LazyFunction[X]

Attributes

Supertypes
class LazyFunction[X]
trait X => X
class Object
trait Matchable
class Any
Known subtypes
class Exp[X]
class Identity[X]
class Product[X]
class Sum[X]
Show all
abstract class KnownDifferentiableFunction[X](name: String, g: X => X, ds: X => Double*) extends DifferentiableFunction[X]

Attributes

Supertypes
trait X => X
class DiFuncBase[X]
trait DiFunc[X]
class Object
trait Matchable
class Any
Show all
Known subtypes
object Lab extends App

Attributes

Supertypes
trait App
trait DelayedInit
class Object
trait Matchable
class Any
Self type
Lab.type
object Lab2 extends App

Attributes

Supertypes
trait App
trait DelayedInit
class Object
trait Matchable
class Any
Self type
Lab2.type
object LazyDouble

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
LazyDouble.type
case class LazyDouble(x: Double, f: Double => Double) extends LazyNumber[Double]

Attributes

Companion
object
Supertypes
trait Product
trait Equals
class LazyNumber[Double]
trait Fractional[LazyNumber[Double]]
trait Numeric[LazyNumber[Double]]
trait Ordering[LazyNumber[Double]]
trait PartialOrdering[LazyNumber[Double]]
trait Equiv[LazyNumber[Double]]
trait Serializable
trait Comparator[LazyNumber[Double]]
trait Valuable[Double]
class Object
trait Matchable
class Any
Show all
Known subtypes
object LazyFunction

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
abstract class LazyFunction[X] extends X => X

This abstract class is the base class for various functions used by LazyNumber algebra. It's not that the functions are lazy, it's that they are used by the LazyNumber module.

This abstract class is the base class for various functions used by LazyNumber algebra. It's not that the functions are lazy, it's that they are used by the LazyNumber module.

Attributes

Companion
object
Supertypes
trait X => X
class Object
trait Matchable
class Any
Known subtypes
class AndThen[X]
class Composed[X]
class Known[X]
class Exp[X]
class Identity[X]
class Product[X]
class Sum[X]
class Named[X]
Show all
object LazyFuzzy

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
LazyFuzzy.type
case class LazyFuzzy(x: Fuzzy, f: Fuzzy => Fuzzy) extends LazyNumber[Fuzzy]

Attributes

Companion
object
Supertypes
trait Product
trait Equals
class LazyNumber[Fuzzy]
trait Fractional[LazyNumber[Fuzzy]]
trait Numeric[LazyNumber[Fuzzy]]
trait Ordering[LazyNumber[Fuzzy]]
trait PartialOrdering[LazyNumber[Fuzzy]]
trait Equiv[LazyNumber[Fuzzy]]
trait Serializable
trait Comparator[LazyNumber[Fuzzy]]
trait Valuable[Fuzzy]
class Object
trait Matchable
class Any
Show all
Known subtypes
object LazyNumber

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
LazyNumber.type
abstract class LazyNumber[X](x: => X, f: X => X)(using evidence$1: Fractional[X]) extends Valuable[X], Fractional[LazyNumber[X]]

LazyNumber is an abstract (base) class for HasValue objects. The value of a LazyNumber is determined by applying the function f to the nominal value x. A LazyNumber is lazy in two senses:

LazyNumber is an abstract (base) class for HasValue objects. The value of a LazyNumber is determined by applying the function f to the nominal value x. A LazyNumber is lazy in two senses:

  • the nominal (initial) value of a LazyNumber is call-by-name so is not evaluated until needed.

  • the any function applied to the number, via map or flatMap, is composed with the existing function such that the actual value is not evaluated until necessary.

Attributes

Companion
object
Supertypes
trait Fractional[LazyNumber[X]]
trait Numeric[LazyNumber[X]]
trait Ordering[LazyNumber[X]]
trait PartialOrdering[LazyNumber[X]]
trait Equiv[LazyNumber[X]]
trait Serializable
trait Comparator[LazyNumber[X]]
trait Valuable[X]
class Object
trait Matchable
class Any
Show all
Known subtypes
class LazyDouble
class LazyFuzzy
class LazyRational
Show all
case class LazyRational(x: Rational, f: Rational => Rational) extends LazyNumber[Rational]

Attributes

Companion
object
Supertypes
trait Product
trait Equals
trait Fractional[LazyNumber[Rational]]
trait Numeric[LazyNumber[Rational]]
trait Ordering[LazyNumber[Rational]]
trait PartialOrdering[LazyNumber[Rational]]
trait Equiv[LazyNumber[Rational]]
trait Serializable
trait Comparator[LazyNumber[Rational]]
class Object
trait Matchable
class Any
Show all
Known subtypes
object LazyRational

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
case class Named[X](name: String, f: X => X)(using evidence$1: Numeric[X]) extends LazyFunction[X]

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class LazyFunction[X]
trait X => X
class Object
trait Matchable
class Any
Show all
case object Negative extends DiFuncBase[Double]

Attributes

Supertypes
trait Singleton
trait Product
trait Mirror
trait Serializable
trait Product
trait Equals
class DiFuncBase[Double]
trait DiFunc[Double]
class Object
trait Matchable
class Any
Show all
Self type
Negative.type
case class Newton(f: Double => Double, dfByDx: Double => Double)

A case class for solving equations using Newton's approximation method (Newton-Raphson) https://en.wikipedia.org/wiki/Newton%27s_method. Newton-Raphson is a special case of Householder's more general method https://en.wikipedia.org/wiki/Householder%27s_method. CONSIDER implementing Halley's method https://en.wikipedia.org/wiki/Halley%27s_method.

A case class for solving equations using Newton's approximation method (Newton-Raphson) https://en.wikipedia.org/wiki/Newton%27s_method. Newton-Raphson is a special case of Householder's more general method https://en.wikipedia.org/wiki/Householder%27s_method. CONSIDER implementing Halley's method https://en.wikipedia.org/wiki/Halley%27s_method.

Value parameters

dfByDx

The derivative of the function.

f

The function whose root is to be found.

Attributes

Constructor

Creates a new Newton solver with the given function and its derivative.

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object Pair

Companion object for constructing and operating on Pair objects.

Companion object for constructing and operating on Pair objects.

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
Pair.type
case class Pair(b: Long, a: Long)

A pair of coefficients. The a value is always 1 in the case of a simple Continued Fraction. The b value is always positive (except for the b which precedes a Continue Fraction, which may be negative).

A pair of coefficients. The a value is always 1 in the case of a simple Continued Fraction. The b value is always positive (except for the b which precedes a Continue Fraction, which may be negative).

CONSIDER representing this by a Rational. However, these coefficients are really independent entities.

Value parameters

a

the a value.

b

the b value.

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object Pi

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
Pi.type
object PiMain extends App

Attributes

Supertypes
trait App
trait DelayedInit
class Object
trait Matchable
class Any
Self type
PiMain.type
case class Power(y: Double) extends DiFuncBase[Double]

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class DiFuncBase[Double]
trait DiFunc[Double]
class Object
trait Matchable
class Any
Show all
case class Product[X](y: X)(using evidence$1: Numeric[X]) extends Known[X]

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Known[X]
class LazyFunction[X]
trait X => X
class Object
trait Matchable
class Any
Show all
sealed trait RNG[T]

NOTE: I have no idea why I wrote this module here.

NOTE: I have no idea why I wrote this module here.

Type parameters

T

the underlying type of RNG.

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
class BaseRNG[T]
class RandomLong
case class RandomLong(value: Long) extends BaseRNG[Long]

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class BaseRNG[Long]
trait RNG[Long]
class Object
trait Matchable
class Any
Show all
Self type
object RandomLong

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
RandomLong.type
trait RandomState[T]

Monadic trait which defines a random-state.

Monadic trait which defines a random-state.

Created by scalaprof on 9/24/16.

Type parameters

T

the underlying type of this random state, i.e. the type of the result of calling get

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class RandomState_Java[T]
object RandomState

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
case class RandomState_Java[T](n: Long)(g: Long => T) extends RandomState[T]

A concrete implementation of RandomState based on the Java random number generator

A concrete implementation of RandomState based on the Java random number generator

Type parameters

T

the underlying type of this random state, i.e. the type of the result of calling get

Value parameters

g

the function which maps a Long value into a T

n

the random Long that characterizes this random state

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
trait RandomState[T]
class Object
trait Matchable
class Any
Show all
case class Sum[X](y: X)(using evidence$1: Numeric[X]) extends Known[X]

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Known[X]
class LazyFunction[X]
trait X => X
class Object
trait Matchable
class Any
Show all
trait Takeable

This trait is, essentially, a subset of IterableOnce.

This trait is, essentially, a subset of IterableOnce.

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
class ConFrac
case class Times(y: Double) extends DiFuncBase[Double]

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class DiFuncBase[Double]
trait DiFunc[Double]
class Object
trait Matchable
class Any
Show all
object TryUsing

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
TryUsing.type
trait Valuable[X]

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
class LazyNumber[X]
class LazyDouble
class LazyFuzzy
class LazyRational
Show all
object Variance extends App

Object defining a set of mathematical operations related to variance and statistical computations.

Object defining a set of mathematical operations related to variance and statistical computations.

Attributes

Supertypes
trait App
trait DelayedInit
class Object
trait Matchable
class Any
Self type
Variance.type
object XXX extends App

Attributes

Supertypes
trait App
trait DelayedInit
class Object
trait Matchable
class Any
Self type
XXX.type
Generated with