scalation
API
Generated with
scalation/scalation

scalation

package scalation

Members list

Packages

package scalation.animation
package scalation.calculus
package scalation.database
package scalation.dynamics
package scalation.mathstat
package scalation.modeling
package scalation.optimization
package scalation.random
package scalation.scala2d
package scalation.simulation

Type members

Classlikes

class BiMap[K, V]

The BiMap class maps keys to values and values to keys.

The BiMap class maps keys to values and values to keys.

Type parameters

K

the key type

V

the value type

Attributes

Supertypes
class Object
trait Matchable
class Any
object Calc

The Calc object provides a template for evaluating/calculating scalar functions. Replace the part after the equal sign with your formula.

The Calc object provides a template for evaluating/calculating scalar functions. Replace the part after the equal sign with your formula.

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
Calc.type
class CircularQueue[A](cap: Int)(implicit evidence$1: ClassTag[A])

The CircularQueue provides a circular queue that can be used to store the latest 'cap' elements.

The CircularQueue provides a circular queue that can be used to store the latest 'cap' elements.

Value parameters

cap

the capacity or maximum number of elements that can be stored

Attributes

Supertypes
class Object
trait Matchable
class Any
class Counter(value_: Int)

The Counter class supports the creation of counters.

The Counter class supports the creation of counters.

Value parameters

value_

the initial value for the counter

Attributes

Supertypes
class Object
trait Matchable
class Any
class DoublyLinkedList[A] extends AbstractIterable[A], Serializable

The DoubleLinked class provides a data structure implementing mutable doubly-linked lists. succ --> --> tail (last car) --> [e1] [e2] [e3] <-- head (lead car) pred <-- <--

The DoubleLinked class provides a data structure implementing mutable doubly-linked lists. succ --> --> tail (last car) --> [e1] [e2] [e3] <-- head (lead car) pred <-- <--

Type parameters

A

the type of the elements/values in the list

Attributes

Supertypes
trait Serializable
class AbstractIterable[A]
trait Iterable[A]
class AbstractIterable[A]
trait Iterable[A]
trait IterableFactoryDefaults[A, Iterable]
trait IterableOps[A, Iterable, Iterable[A]]
trait IterableOnceOps[A, Iterable, Iterable[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
object Earth

The Earth object stores basic Earth properties.

The Earth object stores basic Earth properties.

Attributes

See also

en.wikipedia.org/wiki/Earth_radius

Supertypes
class Object
trait Matchable
class Any
Self type
Earth.type
class EasyWriter(project: String, filename: String, var toFile: Boolean) extends Writer

The EasyWriter class makes it easy to switch between writing to standard output and a (log) file.

The EasyWriter class makes it easy to switch between writing to standard output and a (log) file.

Value parameters

filename

the name of the file to be written

project

the project or directory involved

toFile

flag indicating whether to write to a file

Attributes

Supertypes
class Writer
trait Flushable
trait Closeable
trait AutoCloseable
trait Appendable
class Object
trait Matchable
class Any
Show all
class HyperParameter extends Cloneable

The HyperParameter class provides a simple and flexible means for handling model/optimization hyper-parameters. A model/optimizer may have one or more hyper-parameters that are organized into a map name -> (value, defaultV). Allows hyper-parameters to be changed without constant re-compilation or resorting to long arguments lists Usage: hp("eta") = 0.01

The HyperParameter class provides a simple and flexible means for handling model/optimization hyper-parameters. A model/optimizer may have one or more hyper-parameters that are organized into a map name -> (value, defaultV). Allows hyper-parameters to be changed without constant re-compilation or resorting to long arguments lists Usage: hp("eta") = 0.01

Attributes

Supertypes
trait Cloneable
class Object
trait Matchable
class Any
case class LatLong(lat: Double, long: Double)

The LatLong class stores Latitude-Longitude coordinates. Note: when converting from String to a number use 'mk' not 'to' (e.g., mkInt not toInt).

The LatLong class stores Latitude-Longitude coordinates. Note: when converting from String to a number use 'mk' not 'to' (e.g., mkInt not toInt).

Value parameters

lat

the latitude in degrees North of the Equator

long

the longitude in degrees East of the Prime Meridian

Attributes

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

The LatLong2UTM object support conversion from Latitude-Longitude coordinates to Universal Transverse Mercator (UTM) coordinates.

The LatLong2UTM object support conversion from Latitude-Longitude coordinates to Universal Transverse Mercator (UTM) coordinates.

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
class MergeSortIndirect(a: Array[ValueType])(perm: Array[Int])

The MergeSortIndirect class provides an implementation of Indirect Merge Sort, a version of mergesort that does not re-arrange the array, but modifies an Int array called perm such that perm(i) is the index of the i-th smallest entry in the array (i.e., a(perm(i)) <= a(perm(i+1)). The isort method returns the permutation that sorts array a in perm.

The MergeSortIndirect class provides an implementation of Indirect Merge Sort, a version of mergesort that does not re-arrange the array, but modifies an Int array called perm such that perm(i) is the index of the i-th smallest entry in the array (i.e., a(perm(i)) <= a(perm(i+1)). The isort method returns the permutation that sorts array a in perm.

Value parameters

a

the array to be indirectly sorted

perm

the initial permutation, either 0 until a.length or result of last isort

Attributes

Supertypes
class Object
trait Matchable
class Any
class MultiArrayDeques[A](nLanes: Int)(implicit evidence$1: ClassTag[A])

The MultiArrayDeques class provides a data structure for storing multiple ArrayDeques for the purpose of maintaining multiple parallel lanes. For example cars on a multi-lane road can be positioned in this data structure. It allows cars to added and removed and supports finding cars at a similar distance (from the start) to be found in another lane.

The MultiArrayDeques class provides a data structure for storing multiple ArrayDeques for the purpose of maintaining multiple parallel lanes. For example cars on a multi-lane road can be positioned in this data structure. It allows cars to added and removed and supports finding cars at a similar distance (from the start) to be found in another lane.

Value parameters

nLanes

the number of lanes

Attributes

Supertypes
class Object
trait Matchable
class Any
class PriorityQueue[A](implicit val ord: Ordering[A]) extends AbstractIterable[A], Iterable[A], IterableOps[A, Iterable, PriorityQueue[A]], StrictOptimizedIterableOps[A, Iterable, PriorityQueue[A]], Builder[A, PriorityQueue[A]], Cloneable[PriorityQueue[A]], Growable[A], Serializable

The PriorityQueue class implements priority queues using a heap. To prioritize elements of type A there must be an implicit Ordering [A] available at creation.

The PriorityQueue class implements priority queues using a heap. To prioritize elements of type A there must be an implicit Ordering [A] available at creation.

If multiple elements have the same priority in the ordering of this PriorityQueue, no guarantees are made regarding the order in which elements are returned by dequeue or dequeueAll. In particular, that means this class does not guarantee first in first out behaviour that may be incorrectly inferred from the Queue part of the name of this class.

Only the dequeue and dequeueAll methods will return elements in priority order (while removing elements from the heap). Standard collection methods including drop, iterator, and toString will remove or traverse the heap in whichever order seems most convenient.

Therefore, printing a PriorityQueue will not reveal the priority order of the elements, though the highest-priority element will be printed first. To print the elements in order, one must duplicate the PriorityQueue (by using clone, for instance) and then dequeue them:

Type parameters

A

type of the elements in this priority queue.

Value parameters

ord

implicit ordering used to compare the elements of type A.

Attributes

Example 
val pq = collection.mutable.PriorityQueue(1, 2, 5, 3, 7)
println(pq)                  // elements probably not in order
println(pq.clone.dequeueAll) // prints ArraySeq(7, 5, 3, 2, 1)
Companion
object
Supertypes
trait Serializable
trait Cloneable[PriorityQueue[A]]
trait Cloneable
trait Builder[A, PriorityQueue[A]]
trait Growable[A]
trait Clearable
trait StrictOptimizedIterableOps[A, Iterable, PriorityQueue[A]]
class AbstractIterable[A]
trait Iterable[A]
class AbstractIterable[A]
trait Iterable[A]
trait IterableFactoryDefaults[A, Iterable]
trait IterableOps[A, Iterable, PriorityQueue[A]]
trait IterableOnceOps[A, Iterable, PriorityQueue[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
object PriorityQueue extends SortedIterableFactory[PriorityQueue]

The PriorityQueue object ...

The PriorityQueue object ...

Attributes

Companion
class
Supertypes
trait SortedIterableFactory[PriorityQueue]
trait EvidenceIterableFactory[PriorityQueue, Ordering]
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
class Ring[A](cap: Int, zero: A)(implicit evidence$1: ClassTag[A])

The Ring class provides a circular array that can be used to store the latest cap elements. Example to add elements 1, 2, 3, 4, 5, 6, 7 keeping the most recebt 5: [ 1, 2, 3, 4, 5 ] f = 0, l = 4 [ 6, 7, 3, 4, 5 ] f = 2, l = 1

The Ring class provides a circular array that can be used to store the latest cap elements. Example to add elements 1, 2, 3, 4, 5, 6, 7 keeping the most recebt 5: [ 1, 2, 3, 4, 5 ] f = 0, l = 4 [ 6, 7, 3, 4, 5 ] f = 2, l = 1

Value parameters

cap

the capacity or maximum number of elements that can be stored

zero

an element that indicates zero for type A

Attributes

Supertypes
class Object
trait Matchable
class Any
case class SimpleUniform(a: Double, b: Double)

The SimpleUniform case class for generating random numbers in the interval [a, b].

The SimpleUniform case class for generating random numbers in the interval [a, b].

Attributes

See also

scalation.random.Uniform

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
class SkipList[K, V](implicit evidence$1: ClassTag[K], evidence$2: ClassTag[V], ordering: Ordering[K])

The SkipList class ...

The SkipList class ...

Type parameters

K

the type of the keys contained in this sorted map

V

the type of the values assigned to keys in this sorted map

Value parameters

ordering

the implicit ordering used to compare objects of type K

Attributes

Supertypes
class Object
trait Matchable
class Any
class SkipNodeType[K, V](var key: K, var value: V, val next: Array[SkipNodeType[K, V]])

The SkipNodeType ...

The SkipNodeType ...

Type parameters

K

the type of the keys contained in this sorted map

V

the type of the values assigned to keys in this sorted map

Value parameters

key

the key for this node

next

array of references to next nodes

value

the value for this node

Attributes

Supertypes
class Object
trait Matchable
class Any
object TimeNum

The TimeNum companion object is used to represent and operate on date-time values. It contains an implicit class definition for TimeNum, which extends Instant with Numeric operations that can be used in VectorT. The java.time.Instant class stores nano-seconds since the UNIX Epoch using a long for seconds and int for nano-seconds (12 bytes or 96 bits). The java.time.ZonedDateTime class is used with it to handle various date-time formats.

The TimeNum companion object is used to represent and operate on date-time values. It contains an implicit class definition for TimeNum, which extends Instant with Numeric operations that can be used in VectorT. The java.time.Instant class stores nano-seconds since the UNIX Epoch using a long for seconds and int for nano-seconds (12 bytes or 96 bits). The java.time.ZonedDateTime class is used with it to handle various date-time formats.

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
TimeNum.type
class TimeNum(val inst: Instant) extends Numeric[TimeNum], Ordered[TimeNum], Serializable

The TimeNum class is used to represent and operate on date-time numbers. Internally, a date-time number is represented as an Instant.

The TimeNum class is used to represent and operate on date-time numbers. Internally, a date-time number is represented as an Instant.

Value parameters

inst

the underlying Instant of time

Attributes

Companion
object
Supertypes
trait Ordered[TimeNum]
trait Comparable[TimeNum]
trait Numeric[TimeNum]
trait Ordering[TimeNum]
trait PartialOrdering[TimeNum]
trait Equiv[TimeNum]
trait Serializable
trait Comparator[TimeNum]
class Object
trait Matchable
class Any
Show all
object UTM2LatLong

The UTM2LatLong object support conversion from Universal_Transverse_Mercator (UTM) coordinates to Latitude-Longitude coordinates.

The UTM2LatLong object support conversion from Universal_Transverse_Mercator (UTM) coordinates to Latitude-Longitude coordinates.

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
object Unicode

The Unicode object provides arrays to facilitate the use of Unicode. ScalaTion currently uses a few UTF-16 characters, see code below. Most UTF-16 characters are 2 bytes (16 bits). Extended characters are encoded in 4 bytes. ScalaTion limits characters to the range 'U+0000' to 'U+2bff'. Developers should test Unicode symbols here before trying them in the code.

The Unicode object provides arrays to facilitate the use of Unicode. ScalaTion currently uses a few UTF-16 characters, see code below. Most UTF-16 characters are 2 bytes (16 bits). Extended characters are encoded in 4 bytes. ScalaTion limits characters to the range 'U+0000' to 'U+2bff'. Developers should test Unicode symbols here before trying them in the code.

Attributes

See also

en.wikipedia.org/wiki/UTF-16

en.wikipedia.org/wiki/List_of_Unicode_characters

arxiv.org/abs/1112.1751

Supertypes
class Object
trait Matchable
class Any
Self type
Unicode.type
object ValueTypeOrd extends Ordering[ValueType]

The ValueTypeOrd object provides Ordering for ValueType via the compare method. Used by methods that need Ordering for ValueType, e.g., max (ValueTypeOrd).

The ValueTypeOrd object provides Ordering for ValueType via the compare method. Used by methods that need Ordering for ValueType, e.g., max (ValueTypeOrd).

Attributes

Supertypes
trait Ordering[ValueType]
trait PartialOrdering[ValueType]
trait Equiv[ValueType]
trait Serializable
trait Comparator[ValueType]
class Object
trait Matchable
class Any
Show all
Self type
final class biMapTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class boolTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class circularQueueTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class counterTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class doublyLinkedListTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class easyWriterTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class genIndexHtml

Attributes

Supertypes
class Object
trait Matchable
class Any
final class hyperParameterTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class hyperParameterTest2

Attributes

Supertypes
class Object
trait Matchable
class Any
final class latLongTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class latLongTest2

Attributes

Supertypes
class Object
trait Matchable
class Any
final class latLongTest3

Attributes

Supertypes
class Object
trait Matchable
class Any
final class latLongTest4

Attributes

Supertypes
class Object
trait Matchable
class Any
final class makeVectorI

Attributes

Supertypes
class Object
trait Matchable
class Any
final class mergeSortIndirectTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class mergeSortIndirectTest2

Attributes

Supertypes
class Object
trait Matchable
class Any
final class multiArrayDequesTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class readFileTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class readFileTest2

Attributes

Supertypes
class Object
trait Matchable
class Any
final class redirectOutTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class ringTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class runCalc

Attributes

Supertypes
class Object
trait Matchable
class Any
final class runCalcHelp

Attributes

Supertypes
class Object
trait Matchable
class Any
final class setExtTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class skipListTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class timeNumTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class timeNumTest2

Attributes

Supertypes
class Object
trait Matchable
class Any
final class timeNumTest3

Attributes

Supertypes
class Object
trait Matchable
class Any
final class timerTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class unicodeTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class valueTypeTest

Attributes

Supertypes
class Object
trait Matchable
class Any

Types

type FunctionS2S = Double => Double

Type definition for functions mapping scalar Double to scalar Double

Type definition for functions mapping scalar Double to scalar Double

Attributes

type Interval = (Double, Double)

Type definition for an interval [a, b]

Type definition for an interval [a, b]

Attributes

type Property = Map[String, ValueType]

The Property type is a map from property names to property values.

The Property type is a map from property names to property values.

Attributes

type ValueType = Double | Int | Long | String | TimeNum

The ValueType type is a union type for atomic database values.

The ValueType type is a union type for atomic database values.

Attributes

Value members

Concrete methods

def biMapTest(): Unit

The biMapTest main function is used the test the BiMap class.

The biMapTest main function is used the test the BiMap class.

runMain scalation.biMapTest

Attributes

def boolTest(): Unit

The boolTest main function tests the Bool extension methods.

The boolTest main function tests the Bool extension methods.

runMain scalation.boolTest

Attributes

def cb(x: Double): Double

The cube function of type FunctionS2S. Its inverse function is cbrt.

The cube function of type FunctionS2S. Its inverse function is cbrt.

Value parameters

x

the value to cube

Attributes

inline def cfor(pred: => Boolean, step: => Unit)(body: => Unit): Unit

C/Java style for loop provides improved performance. usage: cfor (i < 10, i += 1) { a(i) = 2 * i }

C/Java style for loop provides improved performance. usage: cfor (i < 10, i += 1) { a(i) = 2 * i }

Value parameters

body

main body of the loop

pred

loop continuation predicate

step

increment step

Attributes

See also
inline def cfor(init: => Unit, pred: => Boolean, step: => Unit)(body: => Unit): Unit

C/Java style for loop provides improved performance. usage: cfor ({i = 0}, i < 10, i += 1) { a(i) = 2 * i }

C/Java style for loop provides improved performance. usage: cfor ({i = 0}, i < 10, i += 1) { a(i) = 2 * i }

Value parameters

body

main body of the loop

init

initialization part

pred

loop continuation predicate

step

increment step

Attributes

See also
def circularQueueTest(): Unit

The circularQueueTest main function is used to test the CircularQueue class.

The circularQueueTest main function is used to test the CircularQueue class.

runMain scalation.circularQueueTest

Attributes

def cot(x: Double): Double

The cotangent function of type FunctionS2S (function missing from scala.math). Its inverse function is atan.

The cotangent function of type FunctionS2S (function missing from scala.math). Its inverse function is atan.

Value parameters

x

the angle in radians

Attributes

def counterTest(): Unit

The counterTest main function test the Counter class.

The counterTest main function test the Counter class.

runMain scalation.counterTest

Attributes

def csc(x: Double): Double

The cosecant function of type FunctionS2S (function missing from scala.math). Its inverse function is acsc.

The cosecant function of type FunctionS2S (function missing from scala.math). Its inverse function is acsc.

Value parameters

x

the angle in radians

Attributes

def debugf(clsName: String, enabled: Boolean)(method: String, message: String): Unit

Show the debugging information that can be enabled or disabled. Usage: def debug: Unit = debugf ("MyClass", true) debug ("myMethod", s"x = $x")

Show the debugging information that can be enabled or disabled. Usage: def debug: Unit = debugf ("MyClass", true) debug ("myMethod", s"x = $x")

Value parameters

clsName

the class/trait/object containing the method

enabled

indicates whether the debug message is enabled

message

the error message

method

the method where the error occurred

Attributes

def doublyLinkedListTest(): Unit

The doublyLinkedListTest main function tests the DoublyLinkedList class.

The doublyLinkedListTest main function tests the DoublyLinkedList class.

runMain scalation.doublyLinkedListTest

Attributes

def easyWriterTest(args: String*): Unit

The easyWriterTest main function is used to test the EasyWriter class. It will write into a file, unless there is a command-line argument.

The easyWriterTest main function is used to test the EasyWriter class. It will write into a file, unless there is a command-line argument.

runMain scalation.easyWriterTest

Attributes

def flawf(clsName: String)(method: String, message: String): Boolean

Show the flaw by printing the error message and returning false. Usage: def flaw: Unit = flawf ("MyClass") flaw ("myMethod", "Houston we have a problem")

Show the flaw by printing the error message and returning false. Usage: def flaw: Unit = flawf ("MyClass") flaw ("myMethod", "Houston we have a problem")

Value parameters

clsName

the class/trait/object containing the method

message

the error message

method

the method where the error occurred

Attributes

def fmt(x: Double): String

Format a double value for printing.

Format a double value for printing.

Value parameters

x

the double value to format

Attributes

def gauge[R](block: => R): Double

Calculate the elapsed time in milliseconds (ms) for the execution of an arbitrary block of code: 'gauge { block }'. Return the block of code's elapsed time.

Calculate the elapsed time in milliseconds (ms) for the execution of an arbitrary block of code: 'gauge { block }'. Return the block of code's elapsed time.

Value parameters

block

the block of code to be executed

Attributes

See also
def genIndexHtml(): Unit

The genIndexHtml main function is used to create "index.html" files in source code directories (main and test) to enable Web browsing of source code.

The genIndexHtml main function is used to create "index.html" files in source code directories (main and test) to enable Web browsing of source code.

runMain scalation.GenIndexHtml

Attributes

def getFromURL_File(path: String): Iterator[String]

Return a line iterator for a line-oriented data source (e.g., CSV file). The data source is accessed via (1) URL, (2) file's absolute path, or (3) file's relative path (relative to 'DATA-DIR').

Return a line iterator for a line-oriented data source (e.g., CSV file). The data source is accessed via (1) URL, (2) file's absolute path, or (3) file's relative path (relative to 'DATA-DIR').

Value parameters

path

the path name of the data source (via URL or file's path name)

Attributes

See also

stackoverflow.com/questions/5713558/detect-and-extract-url-from-a-string

def hyperParameterTest(): Unit

The hyperParameterTest main function is used to test the HyperParameter class.

The hyperParameterTest main function is used to test the HyperParameter class.

runMain scalation.hyperParameterTest

Attributes

def hyperParameterTest2(): Unit

The hyperParameterTest2 main function is used to test the HyperParameter class.

The hyperParameterTest2 main function is used to test the HyperParameter class.

runMain scalation.hyperParameterTest2

Attributes

def id(x: Double): Double

The identity function of type FunctionS2S. Its inverse function is itself.

The identity function of type FunctionS2S. Its inverse function is itself.

Value parameters

x

the value to return

Attributes

inline def is(p: Boolean): Int

Convert Boolean to Int (true -> 1, false -> 0).

Convert Boolean to Int (true -> 1, false -> 0).

Value parameters

p

the predicate to convert

Attributes

inline def is_(p: Boolean): Double
def latLongTest(): Unit

The latLongTest main function tests UTM to LatLong conversions in both directions.

The latLongTest main function tests UTM to LatLong conversions in both directions.

runMain scalation.latLongTest

Attributes

def latLongTest2(): Unit

The latLongTest2 main function tests distance calculations based on latitude longitude locations for typical elevation (Athens, GA to Atlanta, GA).

The latLongTest2 main function tests distance calculations based on latitude longitude locations for typical elevation (Athens, GA to Atlanta, GA).

runMain scalation.latLongTest2

Attributes

def latLongTest3(): Unit

The latLongTest3 main function tests distance calculations based on latitude longitude locations for high elevation (Aspen, CO to Breckenridge, CO).

The latLongTest3 main function tests distance calculations based on latitude longitude locations for high elevation (Aspen, CO to Breckenridge, CO).

runMain scalation.latLongTest3

Attributes

def latLongTest4(): Unit

The latLongTest4 main function tests the kNearest method used to find locations near by to Athens, GA.

The latLongTest4 main function tests the kNearest method used to find locations near by to Athens, GA.

runMain scalation.latLongTest4

Attributes

def log2(x: Double): Double

The log base 2 function of type FunctionS2S. Its inverse function is pow2.

The log base 2 function of type FunctionS2S. Its inverse function is pow2.

Value parameters

x

the value whose log is sought

Attributes

def logb(b: Double, x: Double): Double

The log base b function (note log is the natural log). Its inverse function is pow.

The log base b function (note log is the natural log). Its inverse function is pow.

Value parameters

b

the base of the logarithm

x

the value whose log is sought

Attributes

def makeVectorI(): Unit

The makeVectorI main function make a draft version of VectorI from VectorD. It reads from standard input and writes to standard output.

The makeVectorI main function make a draft version of VectorI from VectorD. It reads from standard input and writes to standard output.

sbt run outfile

Attributes

inline def max3(x: Double, y: Double, z: Double): Double

Return the maximum of three values: x, y, z.

Return the maximum of three values: x, y, z.

Value parameters

x

the first value

y

the second value

z

the third value

Attributes

inline def maxmag(x: Double, limit: Double): Double

Return x, unless it is lees than the lower limit in absolute value, return limit with x's sign.

Return x, unless it is lees than the lower limit in absolute value, return limit with x's sign.

Value parameters

limit

the lower limit (a small positive value)

x

the given value

Attributes

def median3(a1: Double, a2: Double, a3: Double): Double

Find the median of three unordered numbers.

Find the median of three unordered numbers.

Value parameters

a1

the first number

a2

the second number

a3

the third number

Attributes

def memoryUsed: Array[Long]

Return the free, total, and max memory in MB (actually MiB).

Return the free, total, and max memory in MB (actually MiB).

Attributes

def mergeSortIndirectTest(): Unit

The mergeSortIndirectTest is used to test the MergeSortIndirect class. This test illustrates sorting multiple types.

The mergeSortIndirectTest is used to test the MergeSortIndirect class. This test illustrates sorting multiple types.

runMain scalation.mergeSortIndirectTest

Attributes

def mergeSortIndirectTest2(): Unit

The mergeSortIndirectTest2 is used to test the MergeSortIndirect class. This test illustrates sorting multiple columns.

The mergeSortIndirectTest2 is used to test the MergeSortIndirect class. This test illustrates sorting multiple columns.

runMain scalation.mergeSortIndirectTest2

Attributes

def multiArrayDequesTest(): Unit

The multiArrayDequesTest main function tests the MultiArrayDeques class.

The multiArrayDequesTest main function tests the MultiArrayDeques class.

runMain scalation.multiArrayDequesTest

Attributes

def near_eq(x: Double, y: Double): Boolean

Determine whether two double precision floating point numbers 'x' and 'y' are nearly equal. Two numbers are considered to be nearly equal, if within '2 EPSILON'. A number is considered to be nearly zero, if within '2 MIN_NORMAL'. To accommodate round-off errors, may use 'TOL' instead of 'EPSILON'.

Value parameters

x

the first double precision floating point number

y

the second double precision floating point number

Attributes

See also

stackoverflow.com/questions/4915462/how-should-i-do-floating-point-comparison

If both 'x' and 'y' are NaN (Not-a-Number), the IEEE standard indicates that should be considered always not equal. For 'near_eq', they are considered nearly equal. Comment out the first line below to conform more closely to the IEEE standard.

def pow2(x: Double): Double

The power base 2 function of type FunctionS2S. Its inverse function is log2.

The power base 2 function of type FunctionS2S. Its inverse function is log2.

Value parameters

x

the value of the exponent 2^x

Attributes

def powl(x: Long, y: Long): Long

Power function for scala Longs x ~^ y. Compute: math.pow (x, y).toLong without using floating point, so as to not lose precision.

Power function for scala Longs x ~^ y. Compute: math.pow (x, y).toLong without using floating point, so as to not lose precision.

Value parameters

x

the Long base parameter

y

the Long exponent parameter

Attributes

def readFile(fileName: String, fullPath: Boolean): Int

Read and print each line in the file.

Read and print each line in the file.

Value parameters

fileName

the file name (relative or full path)

fullPath

flag indicating whether the user wants full or relative file paths defaults to false (relative paths)

Attributes

See also

DATA_DIR in Util.scala

def readFileIntoArray(fileName: String, fullPath: Boolean, limit: Int): Array[String]

Read each line in the file and put each one into an array that's returned.

Read each line in the file and put each one into an array that's returned.

Value parameters

fileName

the file name (relative or full path)

fullPath

flag indicating whether the user wants full or relative file paths defaults to false (relative paths)

limit

the limit on the number of lines to read

Attributes

See also

DATA_DIR in Util.scala

getFromURL_File in Util.scala has similar functionality, but returns an Iterator

def readFileIter(fileName: String, fullPath: Boolean): (Iterator[String], BufferedSource)

Read the file one line at a time by returning an iterator. The client code should call hasNext to see if there are more lines, next to read the next line, and close to close the buffer at the end. The iterator and buffer are returned.

Read the file one line at a time by returning an iterator. The client code should call hasNext to see if there are more lines, next to read the next line, and close to close the buffer at the end. The iterator and buffer are returned.

Value parameters

fileName

the file name (relative or full path)

fullPath

flag indicating whether the user wants full or relative file paths defaults to false (relative paths)

Attributes

See also

DATA_DIR in Util.scala

def readFileTest(): Unit

The readFileTest main function is used to test the file reading functions. Read the travel time dataset.

The readFileTest main function is used to test the file reading functions. Read the travel time dataset.

runMain scalation.readFileTest

Attributes

def readFileTest2(): Unit

The readFileTest2 main function is used to test the file reading functions. Read the COVID-19 dataset with a limit of 200 lines.

The readFileTest2 main function is used to test the file reading functions. Read the COVID-19 dataset with a limit of 200 lines.

runMain scalation.readFileTest2

Attributes

def recip(x: Double): Double

The reciprocal function of type FunctionS2S. Its inverse function is itself.

The reciprocal function of type FunctionS2S. Its inverse function is itself.

Value parameters

x

the value to take the reciprocal of

Attributes

def redirectOutTest(): Unit

The redirectOutTest main function is used to redirect standard output (stdout). FIX - should work without writing System.out.

The redirectOutTest main function is used to redirect standard output (stdout). FIX - should work without writing System.out.

runMain scalation.redirectOutTest

Attributes

def rel_diff(x: Double, y: Double): Double

Return the relative difference between x and y.

Return the relative difference between x and y.

Value parameters

x

the first double precision floating point number

y

the second double precision floating point number

Attributes

def removeAt(str: String, i: Int, n: Int): String

Remove 'n' characters starting at position 'i' in string 'str' and return the new string.

Remove 'n' characters starting at position 'i' in string 'str' and return the new string.

Value parameters

i

the starting position for character removal

n

the number of characters to remove

str

the source string

Attributes

def removeAt(str: Array[Char], i: Int, n: Int): Array[Char]
def removeLast(s: String): String

Remove the last path element from the file/directory pathname.

Remove the last path element from the file/directory pathname.

Value parameters

s

the string to be so truncated

Attributes

def ringTest(): Unit

The ringTest main function is used to test the Ring class.

The ringTest main function is used to test the Ring class.

runMain scalation.ringTest

Attributes

inline def round2Int(x: Double): Int

Round the given double x to the closest integer (Int).

Round the given double x to the closest integer (Int).

Value parameters

x

the double number which needs to be rounded

Attributes

inline def round2Long(x: Double): Long

Round the given double x to the closest long integer (Long).

Round the given double x to the closest long integer (Long).

Value parameters

x

the double number which needs to be rounded

Attributes

inline def roundTo(x: Double, places: Int): Double

Round the given double x to the desired number of decimal places.

Round the given double x to the desired number of decimal places.

Value parameters

places

the desired number of decimal places

x

the double number which needs to be rounded off

Attributes

def runCalc(x: Double): Unit

The runCalc main function evaluates the function f on the given input.

The runCalc main function evaluates the function f on the given input.

Value parameters

x

the command-line argument passed to function f

runMain scalation.runCalc

Attributes

def runCalcHelp(): Unit

The runCalcHelp main function list the operators used in floating point calculations.

The runCalcHelp main function list the operators used in floating point calculations.

runMain scalation.runCalcHelp

Attributes

def safe_toDouble(s: String): Double

Safe method for converting a String into a Double that catches the exceptions and avoids the "infinite loop problem".

Safe method for converting a String into a Double that catches the exceptions and avoids the "infinite loop problem".

Value parameters

s

the string to convert to a Double

Attributes

def safe_toInt(s: String): Int

Safe method for converting a String into a Int that catches the exceptions and avoids the "infinite loop problem".

Safe method for converting a String into a Int that catches the exceptions and avoids the "infinite loop problem".

Value parameters

s

the string to convert to an Int

Attributes

def safe_toLong(s: String): Long

Safe method for converting a String into a Long that catches the exceptions and avoids the "infinite loop problem".

Safe method for converting a String into a Long that catches the exceptions and avoids the "infinite loop problem".

Value parameters

s

the string to convert to a Long

Attributes

def sec(x: Double): Double

The secant function of type FunctionS2S (function missing from scala.math). Its inverse function is asec.

The secant function of type FunctionS2S (function missing from scala.math). Its inverse function is asec.

Value parameters

x

the angle in radians

Attributes

def setExtTest(): Unit

The setExtTest main function test the SetExt extention methods.

The setExtTest main function test the SetExt extention methods.

runMain scalation.setExtTest

Attributes

inline def sign(x: Double, y: Double): Double

Return the absolute value of x with the sign of y.

Return the absolute value of x with the sign of y.

Value parameters

x

the value contributor

y

the sign contributor

Attributes

def skipListTest(): Unit

The skipListTest main function test the SkipList class.

The skipListTest main function test the SkipList class.

runMain scalation.database.skipListTest

Attributes

def sline(n: Int): String

Make a string for use in printing a line of '-'s.

Make a string for use in printing a line of '-'s.

Value parameters

n

the number of '-'s to use

Attributes

def sq(x: Double): Double

The square function of type FunctionS2S. Its inverse function is sqrt.

The square function of type FunctionS2S. Its inverse function is sqrt.

Value parameters

x

the value to square

Attributes

inline def summation(n: Int)(formula: => Double): Double

Summation of the formula applied n times.

Summation of the formula applied n times.

Value parameters

formula

the formula to apply, repeatedly

n

the number of iterations

Attributes

inline def swap[T](a: Array[T], i: Int, j: Int): Unit

Swap two elements in a regular array.

Swap two elements in a regular array.

Value parameters

i

first element to swap

j

second element to swap

Attributes

inline def swap[T](a: ArrayBuffer[T], i: Int, j: Int): Unit

Swap two elements in a resizable array.

Swap two elements in a resizable array.

Value parameters

i

first element to swap

j

second element to swap

Attributes

def time[R](block: => R): R

Print the elapsed time in milliseconds (ms) for the execution of an arbitrary block of code: 'time { block }'. Return any result produced by the block of code.

Print the elapsed time in milliseconds (ms) for the execution of an arbitrary block of code: 'time { block }'. Return any result produced by the block of code.

Value parameters

block

the block of code to be executed

Attributes

See also
def time[R](amplify: Int, skip: Boolean)(block: => R): R

Print the elapsed time in milliseconds (ms) for the execution of an arbitrary block of code: 'time (10) { block }'. Return any result produced by the block of code. Executes the block of code multiple times for better resolution and accuracy.

Print the elapsed time in milliseconds (ms) for the execution of an arbitrary block of code: 'time (10) { block }'. Return any result produced by the block of code. Executes the block of code multiple times for better resolution and accuracy.

Value parameters

amplify

the number of times to execute the block of code

block

the block of code to be executed

skip

whether to skip the first execution due to slowness of the JIT-Compiler

Attributes

See also
def timeNumTest(): Unit

The timeNumTest main function is used to test the TimeNum class.

The timeNumTest main function is used to test the TimeNum class.

runMain scalation.timeNumTest

Attributes

def timeNumTest2(): Unit

The timeNumTest2 main function is used to test the TimeNum class regarding approximately equal date-times.

The timeNumTest2 main function is used to test the TimeNum class regarding approximately equal date-times.

runMain scalation.timeNumTest2

Attributes

def timeNumTest3(): Unit

The timeNumTest3 main function is used to test the TimeNum class regarding its getChrono method.

The timeNumTest3 main function is used to test the TimeNum class regarding its getChrono method.

runMain scalation.timeNumTest3

Attributes

def timed[R](block: => R): (R, Double)

Calculate the elapsed time in milliseconds (ms) for the execution of an arbitrary block of code: 'timed { block }'. Return any result produced by the block of code and its elapsed time.

Calculate the elapsed time in milliseconds (ms) for the execution of an arbitrary block of code: 'timed { block }'. Return any result produced by the block of code and its elapsed time.

Value parameters

block

the block of code to be executed

Attributes

See also
def timerTest(): Unit

The timerTest main function tests the timer methods. Due to the short execution time of the quadraticEq method, the amplify value should be 1000 to 1000000.

The timerTest main function tests the timer methods. Due to the short execution time of the quadraticEq method, the amplify value should be 1000 to 1000000.

runMain scalation.timerTest

Attributes

def typeOf(o: Any): String

Return the type of an object as string, e.g., "Double".

Return the type of an object as string, e.g., "Double".

Value parameters

o

the object whose type is sought

Attributes

def typeOfStr(str: String): Char

Determine by the form of a string its likely domain using regular expression matching, returning a character: Double | Int | Long | String | TimeNum

Determine by the form of a string its likely domain using regular expression matching, returning a character: Double | Int | Long | String | TimeNum

Value parameters

str

the type un-differentiated string whose domain is sought

Attributes

See also
def unicodeTest(): Unit

The unicodeTest main function is used to the Unicode object.

The unicodeTest main function is used to the Unicode object.

runMain scalation.unicodeTest

Attributes

def valueTypeTest(): Unit

The valueTypeTest main function is used to test the ValueType type.

The valueTypeTest main function is used to test the ValueType type.

runMain scalation.valueTypeTest

Attributes

Concrete fields

val ?: Char

Universal symbol for the ? character (e.g., meaning all rows of column 2 in x(?, 2) for matrix x)

Universal symbol for the ? character (e.g., meaning all rows of column 2 in x(?, 2) for matrix x)

Attributes

val BASE: String

Base directory for ScalaTion (pick one, comment out the rest)

Base directory for ScalaTion (pick one, comment out the rest)

Attributes

val CENTRAL_MERIDIAN: Int
val CSV: String

File-name extension for CSV data files

File-name extension for CSV data files

Attributes

val DATA_DIR: String

File system path for input/output data directory Use 'SCALATION_HOME' environment variable or else BASE directory "."

File system path for input/output data directory Use 'SCALATION_HOME' environment variable or else BASE directory "."

Attributes

val DAY: Double

The number of hours in one day

The number of hours in one day

Attributes

val EPSILON: Double

Smallest double such that 1.0 + EPSILON != 1.0, slightly above 2^-53. Also, known as the "machine epsilon".

Smallest double such that 1.0 + EPSILON != 1.0, slightly above 2^-53. Also, known as the "machine epsilon".

Attributes

See also
val EQUATOR: Int
val HOUR: Double

The number of minutes in one hour

The number of minutes in one hour

Attributes

val JSON: String

File-name extension for JSON data files

File-name extension for JSON data files

Attributes

val LOG_DIR: String

File system path for log (log/file output) directory Use 'SCALATION_HOME' environment variable or else BASE directory "."

File system path for log (log/file output) directory Use 'SCALATION_HOME' environment variable or else BASE directory "."

Attributes

val MAX_INTEGER: Int

Largest positive 32-bit integer value (2147483647 = 2^31-1)

Largest positive 32-bit integer value (2147483647 = 2^31-1)

Attributes

val MAX_VALUE: Double

Largest positive finite value of type double, 2^1023

Largest positive finite value of type double, 2^1023

Attributes

val MINUTE: Double

The number of seconds in one minute

The number of seconds in one minute

Attributes

val MIN_INTEGER: Int

The most negative 32-bit integer value (-2147483648 = -2^31)

The most negative 32-bit integer value (-2147483648 = -2^31)

Attributes

val MIN_NORMAL: Double

Smallest positive normal value of type double, 2^-1022 (retains full precision). Also, the smallest double such that 1.0 / 'SAFE_MIN' does not overflow.

Smallest positive normal value of type double, 2^-1022 (retains full precision). Also, the smallest double such that 1.0 / 'SAFE_MIN' does not overflow.

Attributes

val MS_PER_SEC: Double

The number of millisecond (10-3) per second

The number of millisecond (10-3) per second

Attributes

val NEGATIVE_INFINITY: Double

Special value representing negative infinity: 1111111111110...0 Ex: -1.0 / 0.0

Special value representing negative infinity: 1111111111110...0 Ex: -1.0 / 0.0

Attributes

See also
val NO_DOUBLE: Double

Indicators of missing/illegal values per datatype

Indicators of missing/illegal values per datatype

Attributes

val NO_INT: Int
val NO_LONG: Long
val NO_STRING: String
val NS_PER_MS: Double

The number of nanoseconds (10-9) per millisecond

The number of nanoseconds (10-9) per millisecond

Attributes

val POSITIVE_INFINITY: Double

Special value representing positive infinity: 0111111111110...0 Ex: 1.0 / 0.0

Special value representing positive infinity: 0111111111110...0 Ex: 1.0 / 0.0

Attributes

See also
val SECOND: Double

The number of units in one second Use 1.0 to make SECOND the base unit, 1.0 / 60.0 to make MINUTE the base unit, etc.

The number of units in one second Use 1.0 to make SECOND the base unit, 1.0 / 60.0 to make MINUTE the base unit, etc.

Attributes

See also

TimeNum for alternative definitions

val SEP: String

The file path separation character: '/' for Linux/Mac, '' for Windows Use either 'SEP' or '⁄' for portability, i.e., do not use '/' or ''.

The file path separation character: '/' for Linux/Mac, '' for Windows Use either 'SEP' or '⁄' for portability, i.e., do not use '/' or ''.

Attributes

val SER: String

File-name extension for serialized tables FIX: investigate using more efficient serialization, e.g.,

File-name extension for serialized tables FIX: investigate using more efficient serialization, e.g.,

Attributes

See also

github.com/EsotericSoftware/kryo

val SP: Char

The token/element separation character (',' for CSV)

The token/element separation character (',' for CSV)

Attributes

val SRC_DIR: String

File system path for src (source code) directory Use 'SCALATION_HOME' environment variable or else BASE directory "."

File system path for src (source code) directory Use 'SCALATION_HOME' environment variable or else BASE directory "."

Attributes

val SRC_SCALA_DIR: String
val STORE_DIR: String

File system path for database storage directory Use 'SCALATION_HOME' environment variable or else BASE directory "."

File system path for database storage directory Use 'SCALATION_HOME' environment variable or else BASE directory "."

Attributes

val TOL: Double

Default tolerance should be much larger than the "machine epsilon". Application dependent => redefine as needed per application.

Default tolerance should be much larger than the "machine epsilon". Application dependent => redefine as needed per application.

Attributes

val WEEK: Double

The number of days in one week

The number of days in one week

Attributes

val _2Pi: Double

The number 2π (needed in common calculations)

The number 2π (needed in common calculations)

Attributes

val _2byPi: Double

The number 2/π (needed in common calculations)

The number 2/π (needed in common calculations)

Attributes

val log2: Double

The value of log 2

The value of log 2

Attributes

val regexD: Regex
val regexL: Regex
val sqrt_2Pi: Double

The number srqt 2π (needed in common calculations)

The number srqt 2π (needed in common calculations)

Attributes

val sqrt_2byPi: Double

The number srqt 2/π (needed in common calculations)

The number srqt 2/π (needed in common calculations)

Attributes

val ⁄: String

Extensions

Extensions

extension (p: Property)
def +++(q: Property): Property

The +++ extension method concatenates properties and renames to avoid ambiguity.

The +++ extension method concatenates properties and renames to avoid ambiguity.

Attributes

extension (s: Instant)
def <<=(t: Instant): Boolean

Add the <<= operator as an extension method to java.time.Instant.

Add the <<= operator as an extension method to java.time.Instant.

Attributes

extension (x: Boolean)
infix inline def and(y: Boolean): Boolean

Extend Boolean to include an and, or, not, xor. Note: they all have the same precedence.

Extend Boolean to include an and, or, not, xor. Note: they all have the same precedence.

Attributes

infix inline def not: Boolean

Extend Boolean to include an and, or, not, xor. Note: they all have the same precedence.

Extend Boolean to include an and, or, not, xor. Note: they all have the same precedence.

Attributes

infix inline def or(y: Boolean): Boolean

Extend Boolean to include an and, or, not, xor. Note: they all have the same precedence.

Extend Boolean to include an and, or, not, xor. Note: they all have the same precedence.

Attributes

infix inline def xor(y: Boolean): Boolean

Extend Boolean to include an and, or, not, xor. Note: they all have the same precedence.

Extend Boolean to include an and, or, not, xor. Note: they all have the same precedence.

Attributes

extension [T](x: Set[T])
inline def ⊂(y: Set[T]): Boolean

Return whether set x is a proper subset of set y.

Return whether set x is a proper subset of set y.

Value parameters

y

the other set

Attributes

inline def ⊄(y: Set[T]): Boolean

Return whether set x is not a proper subset of set y.

Return whether set x is not a proper subset of set y.

Value parameters

y

the other set

Attributes

inline def ⊆(y: Set[T]): Boolean

Return whether set x is a subset of set y.

Return whether set x is a subset of set y.

Value parameters

y

the other set

Attributes

inline def ⊈(y: Set[T]): Boolean

Return whether set x is not a subset of set y.

Return whether set x is not a subset of set y.

Value parameters

y

the other set

Attributes

extension (x: Int)
def =~(y: Int): Boolean

Extend Int to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Extend Int to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Attributes

infix def in(r: (Int, Int)): Boolean

Extend Int to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Extend Int to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Attributes

infix def out(r: (Int, Int)): Boolean

Extend Int to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Extend Int to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Attributes

def ~^(y: Int): Int

Extend Int to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Extend Int to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Attributes

extension (x: Long)
def =~(y: Long): Boolean

Extend Long to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Extend Long to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Attributes

infix def in(r: (Long, Long)): Boolean

Extend Long to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Extend Long to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Attributes

infix def out(r: (Long, Long)): Boolean

Extend Long to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Extend Long to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Attributes

def ~^(y: Long): Long

Extend Long to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Extend Long to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Attributes

extension (x: Double)
def =~(y: Double): Boolean

Extend Double to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Extend Double to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Attributes

infix def in(r: (Double, Double)): Boolean

Extend Double to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Extend Double to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Attributes

infix def out(r: (Double, Double)): Boolean

Extend Double to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Extend Double to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Attributes

def ~^(y: Double): Double

Extend Double to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Extend Double to include an exponentiation operator (~^), nearly equal (=~) and in/out.

Attributes

extension (x: String)
def *(y: String): String

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Attributes

def *(y: Int): String

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Attributes

def -(y: String): String

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Attributes

def /(y: String): String

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Attributes

def /(y: Int): String

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Attributes

def =~(y: String): Boolean

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Attributes

infix def in(r: (String, String)): Boolean

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Attributes

def mkDouble: Double

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Attributes

def mkInt: Int

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Attributes

def mkLong: Long

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Attributes

infix def out(r: (String, String)): Boolean

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Attributes

def unary_-: String

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Attributes

def ~^(y: String): String

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Extend String to include an exponentiation operator (~^), nearly equal (=~) and in/out, as well operators for numeric types. Use '.mkDouble' instead of '.toDouble'.

Attributes

extension (x: ValueType)
def <(y: ValueType): Boolean

The < extension method determines whether x < y.

The < extension method determines whether x < y.

Attributes

def <=(y: ValueType): Boolean

The <= extension method determines whether x <= y.

The <= extension method determines whether x <= y.

Attributes

def >(y: ValueType): Boolean

The > extension method determines whether x > y.

The > extension method determines whether x > y.

Attributes

def >=(y: ValueType): Boolean

The >= extension method determines whether x >= y.

The >= extension method determines whether x >= y.

Attributes

def toDouble: Double

The toDouble extension method converts a ValueType to a Double.

The toDouble extension method converts a ValueType to a Double.

Attributes

def toInt: Int

The toInt extension method converts a ValueType to an Int.

The toInt extension method converts a ValueType to an Int.

Attributes

def toLong: Long

The toLong extension method converts a ValueType to an Long.

The toLong extension method converts a ValueType to an Long.

Attributes

Generated with