HelpSource/Classes/AbstractFunction.schelp

   1 class::AbstractFunction
   2 summary::An object which responds to a set of messages that represent mathematical functions
   3 categories::Core>Kernel
   4 related::Classes/UGen,Classes/Pattern,Classes/Function,Overviews/Operators
   5
   6 description::
   7
   8 An AbstractFunction is an object which responds to a set of messages that represent
   9 mathematical functions. Subclasses override a smaller set of messages to respond
  10 to the mathematical functions. The intent is to provide a mechanism for functions
  11 that do not calculate values directly but instead compose structures for calculating.
  12
  13 Function, Pattern, Stream and UGen are subclasses of AbstractFunction.
  14 For example, if you multiply two UGens together the receiver responds by answering a new
  15 instance of class BinaryOpUGen which has the two operands as inputs.
  16
  17 For an overview of common operators, see link::Overviews/Operators::.
  18 To see which classes implements a specific method, see that method in the generated link::Overviews/Methods:: overview.
  19
  20 instanceMethods::
  21
  22 subsection::Unary Messages
  23
  24 All of the following messages send the message composeUnaryOp to the receiver with the
  25 unary message selector as an argument.
  26 See link::Classes/UnaryOpFunction::.
  27
  28 method::neg
  29 method::reciprocal
  30 method::bitNot
  31 method::abs
  32 method::asFloat
  33 method::asInt
  34 method::ceil
  35 method::floor
  36 method::frac
  37 method::sign
  38 method::squared
  39 method::cubed
  40 method::sqrt
  41 method::exp
  42 method::midicps
  43 method::cpsmidi
  44 method::midiratio
  45 method::ratiomidi
  46 method::ampdb
  47 method::dbamp
  48 method::octcps
  49 method::cpsoct
  50 method::log
  51 method::log2
  52 method::log10
  53 method::sin
  54 method::cos
  55 method::tan
  56 method::asin
  57 method::acos
  58 method::atan
  59 method::sinh
  60 method::cosh
  61 method::tanh
  62 method::rand
  63 method::rand2
  64 method::linrand
  65 method::bilinrand
  66 method::sum3rand
  67 method::distort
  68 method::softclip
  69 method::coin
  70 method::even
  71 method::odd
  72 method::isPositive
  73 method::isNegative,
  74 method::isStrictlyPositive
  75 method::rho
  76 method::theta
  77
  78 subsection::Binary Messages
  79
  80 All of the following messages send the message composeBinaryOp to the receiver with the
  81 binary message selector and the second operand as arguments.
  82 See: link::Classes/BinaryOpFunction::.
  83
  84 method::+
  85 method::-
  86 method::*
  87 method::/
  88 method::div
  89 method::%
  90 method::**
  91 method::min
  92 method::max
  93 method::<
  94 method::<=
  95 method::>
  96 method::>=
  97 method::&
  98 method::|
  99 method::lcm
 100 method::gcd
 101 method::round
 102 method::trunc
 103 method::atan2
 104 method::hypot
 105 method::hypotApx
 106 method::>>
 107 method::+>>
 108 method::fill
 109 method::ring1
 110 method::ring2
 111 method::ring3
 112 method::ring4
 113 method::difsqr
 114 method::sumsqr
 115 method::sqrdif
 116 method::absdif
 117 method::amclip
 118 method::scaleneg
 119 method::clip2
 120 method::excess
 121 method::<!
 122 method::rrand
 123 method::exprand
 124 method::rotate
 125 method::dist
 126 method::bitAnd
 127 method::bitOr
 128 method::bitXor
 129 method::bitHammingDistance
 130 method::@
 131
 132 subsection:: Messages with more arguments
 133
 134 All of the following messages send the message code::composeNAryOp:: to the receiver with the
 135 binary message selector and the other operands as arguments.
 136 See link::Classes/NAryOpFunction::.
 137
 138 method::clip
 139 method::wrap
 140 method::fold
 141 method::blend
 142 method::linlin
 143 method::linexp
 144 method::explin
 145 method::expexp
 146
 147 subsection:: other
 148
 149 method::applyTo
 150
 151 Interface that allows us to combine selectors (Symbols) and Functions. Sends valueArray(args) to this.
 152 discussion::
 153 code::
 154 // example:
 155
 156 f = [{ |a, b| a * b * 100.rand }, { |a, b| sin(a) * sin(b) }, '*', '/'];
 157 f.choose.postcs.applyTo(3, 4);
 158
 159 // this is used in SequenceableCollection reduce:
 160 (1..10).reduce('+');
 161 (1..10).reduce({ |a, b| a * b * 1.0.rand });
 162 ::
 163
 164 method::asUGenInput
 165
 166 returns:: the result of sending the value(for) message to this.
 167 discussion::
 168 code::
 169 // example:
 170 (
 171 var f, g, product;
 172 f = { SinOsc.ar(400) };
 173 g = { LFPulse.kr(8)  };
 174 product = f * g * 0.1;
 175 { Pan2.ar(product, SinOsc.kr(0.3)) }.play;
 176 )
 177 ::
 178
 179 method::sampled
 180 Sample a function.
 181 discussion::
 182 code::
 183 //sample a function
 184 f = { |x| sin(3*x)*cos(8*x) }
 185 f.plotGraph2(from:0,to:2);
 186 f.sampled(10,0,2).plotGraph2(from:0,to:2);
 187 f.sampled(80,0,2).plotGraph2(from:0,to:2);
 188
 189 //on complicated functions a sampled function is less cpy heavy.
 190 f = { |x| 60.collect{ 2**((x-rrand(0.0,1.0))) }.sum/60 };
 191 f.plotGraph2(from:0,to:1);
 192 g = f.sampled(200);
 193 g.plotGraph2(from:0,to:1);
 194 { 200.collect{ f.(rand(0.0,1.0)) } }.bench;
 195 { 200.collect{ g.(rand(0.0,1.0)) } }.bench;
 196 ::
 197
 198 subsection::Function Composition
 199
 200 When unary, binary or n-ary operators are applied to an abstract function, it returns an object that represents
 201 this operation, without evaluating the function: link::Classes/UnaryOpFunction::, link::Classes/BinaryOpFunction::, link::Classes/NAryOpFunction::.
 202 Note that different subclasses like link::Classes/Pattern:: or link::Classes/UGen:: have their own composition scheme analogous to the one of AbstractFunction itself. For more about functions, see link::Classes/Function::.
 203
 204 examples::
 205
 206 code::
 207 // examples
 208
 209 a = { 1.0.rand } + 8;
 210 a.value;
 211
 212
 213 y = { 8 } + { 1.0.rand };
 214 y.value;
 215 ::
 216
 217 code::
 218 // arguments are passed into both functions
 219
 220 y = { |x=0| x } + { 1.0.rand };
 221 y.value(10);
 222
 223
 224 y = { |x=0| x * 3 } + { |x=0| x + 1.0.rand };
 225 y.value(10);
 226
 227 y.postcs;
 228
 229 y = { |x=0| x * 3 } + { |x=0| x + 1.0.rand } * { |x=0| [50, 100].choose + x } + 1.0;
 230 y.value(10);
 231 ::
 232
 233 code::
 234 // environments can be used as a lookup with valueEnvir:
 235
 236 (
 237 Environment.use {
 238         ~y = 10;
 239         ~x = 2;
 240         ~z = { |x=8| x } + { |y=0| y + 1.0.rand };
 241         ~z.valueEnvir;
 242 }
 243 )
 244 ::
 245
 246 code::
 247 // n-ary operators:
 248
 249 a = blend({ 3.0.rand }, { 1000.rand }, { |frac| frac });
 250 a.value(0.5);
 251
 252 a.value((0, 0.06..1)); // creates a range of values..
 253 ::
 254