Value Members

1.  final def !=(arg0: Any): Boolean

   Definition Classes

   Any

2.  final def ##: Int

   Definition Classes

   Any

3.  def ++(that: GE[A]): GE[A]

   Concatenates another signal to this (finite) signal.

4.  def +:(elem: GE[A]): GE[A]

   Prepends a single frame.

5.  def :+(elem: GE[A]): GE[A]

   Appends a single frame.

6.  final def ==(arg0: Any): Boolean

   Definition Classes

   Any

7.  def abs(implicit num: Num[A]): GE[A]
8.  def acos(implicit w: Widen[A, Double]): D
9.  def ampDb(implicit w: Widen[A, Double]): D

   Converts from a linear value (or amplitude) to decimals

10.  def appended(elem: GE[A]): GE[A]

    Appends a single frame.

11.  final def asInstanceOf[T0]: T0

    Definition Classes

    Any

12.  def asin(implicit w: Widen[A, Double]): D
13.  def atan(implicit w: Widen[A, Double]): D
14.  def ceil(implicit ev: =:=[GE[A], D]): D
15.  def concat(that: GE[A]): GE[A]

    Concatenates another signal to this (finite) signal.

16.  def cos(implicit w: Widen[A, Double]): D
17.  def cosh(implicit w: Widen[A, Double]): D
18.  def cpsMidi(implicit w: Widen[A, Double]): D

    Converts from frequency in Hertz (or cycles-per-second) to MIDI note number.

19.  def cpsOct(implicit w: Widen[A, Double]): D
20.  def cubed(implicit num: Num[A]): GE[A]
21.  def dbAmp(implicit w: Widen[A, Double]): D

    Converts from decimals to a linear value (or amplitude)

22.  def differentiate(implicit num: Num[A]): GE[A]
23.  def distinct(implicit eq: Eq[A]): GE[A]

    Filters elements to return only distinct values (removes duplicate values)

24.  def drop[L](length: GE[L])(implicit arg0: NumInt[L]): GE[A]

    Drops the first length elements of this signal.

25.  def dropRight[L](length: GE[L])(implicit arg0: NumInt[L]): GE[A]

    Drops the last length elements of this signal.

26.  def dropWhile(p: GE[Boolean]): GE[A]
27.  def elastic(n: GE[Int] = 1): GE[A]

    Inserts a number of buffering blocks to avoid signal deadlock in diamond shape topologies.

    Inserts a number of buffering blocks to avoid signal deadlock in diamond shape topologies.

    See also

    de.sciss.fscape.graph.BufferMemory

28.  def exp(implicit w: Widen[A, Double]): D
29.  def filter(p: GE[Boolean]): GE[A]
30.  def filterNot(p: GE[Boolean]): GE[A]
31.  def floor(implicit ev: =:=[GE[A], D]): D
32.  def frac(implicit ev: =:=[GE[A], D]): D
33.  def getClass(): Class[_ <: AnyVal]

    Definition Classes

    AnyVal → Any

34.  def head: GE[A]

    Outputs the first element of this signal, then terminates.

35.  def indices: L

    Outputs a monotonous sequence from zero to the signal length minus one.

36.  def init: GE[A]
37.  def isDefinedAt[L](index: GE[L])(implicit w: Widen[L, Long]): GE[Boolean]
38.  def isEmpty: B
39.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

40.  def isNaN(implicit ev: =:=[GE[A], D]): B

    Tests the input signal for NaNs (not-a-number).

    Tests the input signal for NaNs (not-a-number). For instance, taking the logarithm of a negative number produces a NaN. Useful to detect and replace those special values.

41.  def last: GE[A]

    Outputs the last element of this (finite) signal, then terminates.

42.  def length: L

    Outputs a signal value, the length of the input signal.

43.  def log(implicit w: Widen[A, Double]): D

    Natural logarithm

44.  def log10(implicit w: Widen[A, Double]): D

    Base-10 logarithm

45.  def log2(implicit w: Widen[A, Double]): D

    Base-2 logarithm

46.  def maximum(implicit ord: Ord[A]): GE[A]

    Returns the maximum value cross all elements (or an empty stream if the input is empty)

47.  def midiCps(implicit w: Widen[A, Double]): D

    Converts from MIDI note number to frequency in Hertz (or cycles-per-second)

48.  def midiRatio(implicit w: Widen[A, Double]): D
49.  def minimum(implicit ord: Ord[A]): GE[A]

    Returns the minimum value cross all elements (or an empty stream if the input is empty)

50.  def nextPowerOfTwo(implicit num: NumInt[A]): GE[A]
51.  def nonEmpty: GE[Boolean]
52.  def octCps(implicit w: Widen[A, Double]): D
53.  def out(index: Int): GE[A]

    Creates a proxy that represents a specific output channel of the element.

    Creates a proxy that represents a specific output channel of the element.

    index

    channel-index, zero-based. Indices which are greater than or equal to the number of outputs are wrapped around.

    returns

    a monophonic element that represents the given channel of the receiver

54.  def prepended(elem: GE[A]): GE[A]

    Prepends a single frame.

55.  def product(implicit num: Num[A]): GE[A]
56.  def ratioMidi(implicit w: Widen[A, Double]): D
57.  def reciprocal(implicit w: Widen[A, Double]): D

    The reciprocal is one divided by the input signal.

58.  def signum(implicit num: Num[A]): GE[A]
59.  def sin(implicit w: Widen[A, Double]): D
60.  def sinh(implicit w: Widen[A, Double]): D
61.  def size: L

    Outputs a signal value, the length of the input signal.

    Outputs a signal value, the length of the input signal. Same as length.

62.  def slice[L](from: GE[L], until: GE[L])(implicit arg0: NumInt[L]): GE[A]
63.  def splitAt[L](n: GE[L])(implicit arg0: NumInt[L]): (GE[A], GE[A])
64.  def sqrt(implicit w: Widen[A, Double]): D
65.  def squared(implicit num: Num[A]): GE[A]
66.  def sum(implicit num: Num[A]): GE[A]
67.  def tail: GE[A]
68.  def take[B](length: GE[B])(implicit arg0: NumInt[B]): GE[A]

    Takes at most length elements of this signal, then terminates.

69.  def takeRight[L](length: GE[L])(implicit arg0: NumInt[L]): GE[A]

    Takes at most the last length elements of this (finite) signal.

70.  def takeWhile(p: GE[Boolean]): GE[A]
71.  def tan(implicit w: Widen[A, Double]): D
72.  def tanh(implicit w: Widen[A, Double]): D
73.  def toDouble(implicit to: ScalarToNum[A]): D
74.  def toInt(implicit to: ScalarToNum[A]): I
75.  def toLong(implicit to: ScalarToNum[A]): L
76.  def toString(): String

    Definition Classes

    Any

77.  def unary_!(implicit num: NumBool[A]): GE[A]
78.  def unary_-(implicit num: Num[A]): GE[A]
79.  def unary_~(implicit num: NumInt[A]): GE[A]
80.  def unzip: (GE[A], GE[A])
81.  def zip(that: GE[A]): GE[A]