HelpSource/Classes/BinaryOpUGen.schelp

   1 class:: BinaryOpUGen
   2 summary:: Apply a binary operation to the values of an input UGen
   3 related:: Classes/UnaryOpUGen, Classes/BinaryOpFunction, Classes/Pbinop, Overviews/Operators
   4 categories:: UGens>Algebraic
   5
   6 description::
   7 BinaryOpUGens are created as the result of a binary operator applied to a link::Classes/UGen::.
   8 code::
   9 (SinOsc.ar(200) * ClipNoise.ar).dump;
  10 (SinOsc.ar(200).thresh(0.5)).dump;
  11 ::
  12 The use of the binary operators code::*:: and code::thresh:: above each instantiate a BinaryOpUGen. The operators themselves  (which are methods) are not to be confused with the resulting BinaryOpUGen (which is an object). The unary and binary operators are defined in link::Classes/UGen::'s superclass link::Classes/AbstractFunction::, which creates the
  13 BinaryOpUGen as a result of the operation.
  14
  15 When operating on UGens instead of numbers, what results is not a result of the calculation, but a structure that represents that calculation. For the immediate operations on numbers, see for example link::Classes/SimpleNumber::.
  16
  17 See link::Overviews/Operators:: for an overview of common operators.
  18
  19 classmethods::
  20 private:: new1
  21
  22 method::new
  23 return a new instance that applies the operator code::selector:: to the UGens code::a:: and code::b:: normally, this is implicitly called when applying an operator to a link::Classes/UGen::.
  24 argument:: selector
  25 The selector symbol for the binary operator
  26 argument:: a
  27 left operand
  28 argument:: b
  29 right operand
  30 returns:: A new instance of BinaryOpUGen
  31
  32 instancemethods::
  33 private:: init, optimizeGraph, constantFolding
  34
  35 examples::
  36
  37 code::
  38 a = WhiteNoise.ar; // a WhiteNoise
  39 b = a + 2; // a BinaryOpUGen.
  40 b.operator; // +
  41
  42 // sound example
  43 (
  44 {
  45         var a = LFSaw.ar(300);
  46         var b = LFSaw.ar(329.1);
  47         a % b * 0.1
  48 }.play;
  49 )
  50 ::
  51
  52 subsection::The comparison operators
  53
  54 The operators code:: >, >=, <, <= :: are particularly useful for triggering. They should not be confused with their use in conditionals. Compare:
  55
  56 code::
  57 if(1 > 0) { "1 is greater than 0".postln }; // > returns a boolean
  58 ::
  59
  60 with
  61
  62 code::
  63 // trigger an envelope
  64 (
  65 {
  66     var trig;
  67     trig = SinOsc.ar(1) > 0.1;
  68     EnvGen.kr(Env.perc, trig, doneAction: 0) * SinOsc.ar(440,0,0.1)
  69 }.play
  70 ) // > outputs 0 or 1
  71 ::
  72
  73 See link::Overviews/Operators:: or the implementation of these in link::Classes/AbstractFunction:: for more detail.
  74
  75 Since the equality operator ( code::==:: ) is used to distinguish objects including UGens, it cannot be used to create a BinaryOpUGen by application. Instead, to get a trigger value each time two signals are the same (instead of just finding out whether two UGens are the same), one can instantiate a BinaryOpUGen directly:
  76
  77 code::
  78 (
  79 {
  80     var a = SinOsc.ar(1).round(0.1);
  81     var b = SinOsc.ar(1.2).round(0.1);
  82     BinaryOpUGen('==', a, b) * 0.1
  83 }.play;
  84 )
  85 ::
  86