Cycling '74 Wiki - User contributions [en]

bucket

2013-04-30T06:05:54Z

Gtaylor@rtqe.net: /* People who looked at/used this object also looked at.... */

==[//www.cycling74.com/docs/max6/dynamic/c74_docs.html#bucket bucket online refpage]==

==Using the {{maxword|name=bucket}} object==

The {{maxword|name=bucket}} object implements a [//en.wikipedia.org/wiki/Bucket_brigade bucket brigade] device (in the electronics world, this is sometimes referred to as [//en.wikipedia.org/wiki/Bucket-brigade_device a discrete time-analogue delay line]). As the examples below suggest, it's useful for single-sample delay lines, calculating averages, computing velocity and acceleration, and permutating lists by rotating them.

=={{maxword|name=bucket}} Tutorials==

In the Max tutorial on abstractions, you can find a classic example of why the {{maxword|name=bucket}} object is so useful - [//www.cycling74.com/docs/max6/dynamic/c74_docs.html#basicchapter15 this Max tutorial] demonstrates its use as a single sample delay for number values useful for constructing drawing commands.

=={{maxword|name=bucket}} Tips and Workarounds==

===Velocity and Acceleration===

Lots of people use the bucket object for shifting data in series, it's computationally useful for calculating first and second derivatives for streams of data. The terms "first and second derivative" are math-speak for keeping track of:

* the rate that things are changing (that's what velocity (the first derivative) is - the rate of change in a value over time.

* the ''rate of the rate'' that things are changing - that's what acceleration (the second derivative) is.

[[File:Bucket-in-action.png]]

Here's a patch that does that:

<maxpat>
----------begin_max5_patcher----------
863.3oc4XFrbaBCDF9r8SgJmZmwICRf.bu0mgbrISGLHaqDP3QHbcZl7tWoE
vA2ZrAFC8Pu.dEBs69oesR32lOyZU1AVtE5qnuilM6s4ylAMYZXVk8LqzvCQ
Ig4P2rhxRSYBk0hxmoXGTP6psLjLTwPYqQM+cz1PwF1ihOmyhxDwnXljuOTw
2y9xih5QIgKzOsP.CEopQQQJWjvTfewUMtKTEskK17CIKRUF2d1d2au.4rz2
bC6EXt4pMPOU8R7XHDyV87cjk09bclPIBSYvi9ljGlX8giyJT0d1tt+xMq.6
6saLB47eAi.lbr4cRVtlP5bLSbRXRg.y1L.n5KnmLuz6ymatr3FNGbj6q4xb
0HfcW+flXGiuH1CFOrO..pc0JlzpmYrS.AR0xYPJbkX2RB612DlbzwRcuUL4
OXhvUIrSfw4Ubkih50crx.0haDGHqUZIf0fTXoEIJddBOt+TpZ4HojOXLXgc
BZgSjgSiblRGR53tzw2QONubzS5tjqds70nsQKCplbLUs7oqXBOpXpkRV0wn
i6okrlF3px1rQO38cQJApG4srd04EViZednh6.TO6RtoVCUkqcTCgCtYZH6i
0AmJwff8ScN7W63oiWY1YwF4pXqpNtK9RZDreeqii6Ys5gWjtElDKKDuXxND
8rjw45jg.qd7cuHY7FaxL3kTs.lOcmV31WwR81Y1NvocJKHhaAImkHODJxQO
nO+05dgEpOlz5Bo0IYg2V3rpH5ElBQF318XO3Vf+k3CYP7gL.9byKzLHsS89
mcQ637en1ohOcR639OT6.wC70R+wmJC4jo8SYVdVgLpd3pJLf9HqhY4Jt.Nr
Ui9XNIbiNskGGyDM2CNlma1VFPx4+nmtFNlON4pwio9NhLIwiSWvC9J3IkGu
KSukQ0TjqVNQ0I.Ivbqo0GN5lk..qtJPCltIX6tDO9SV7zI931uIXGGOyTJl
BkMplfAqwXB1uqqXlnIXsmvWKbNoOWkmdAN.AWB+MUd5u4q1ZD3IoK3bxnYm
p+LrxONvV+zR1dpElBa64goGsFAR61AkhS+TJTJsgRgZ6MlJktrUky.UJk6q
Gta2dlLuZHg.QepmmyjFSuEfIWTZBGlwRx1yq6ObBCqPo9rMJ8AaJjkGL4Pf
m0biede9u0DMhQJ
-----------end_max5_patcher-----------
</maxpat>

===Running Averages===

I also tend to use the object quite a bit in situations where I desire a running average over some finite set of events (if you want a running average for an stream or unspecified set of values, you'd use the {{maxword|name=mean}} object). Here's an example that calculates the average of the last 8 floating point input values:

<maxpat>
----------begin_max5_patcher----------
498.3ocuV1sajBBEG+Z8ofvkabm.9AZ6c84nYyFFkYKsJZTrc11z28UO3z1Y
CyHocJwnjywCG9wePN9RX.da6dw.FcM5VTPvKgAAfqYGAK1A3F99xZ9.DFtc
TWKz3HyqTiMR0jM7N56NMQAdIKd635x6jp+76dQo1Lhz7zMjHTbbFz71SzuV
5irxLlau+m4GFxx1lFgBx.FO650vv4GQNNA.dsxOwJ+zU4mUbB7MYQ+2NgId
L11LicolYJwSS46P1zh8lT8CDYCMNy5TNdw4tVkdP9LvIMdymUInWQmaRuBj
Bx4jhc0sbsU83MRmgRwafdfuoWxqufpRGu7AztiurJQEWXIJwzvHaxVSirJO
odQddtFML1702yDutfvRf8LYqumAGcBMIwKZx1wxGDZTwYO7yIUoXcUgvbea
RzYtsIWT2jKnq3Zo5+qP.XO6+XMbncru7.TKeIidm6JwfVp3ZYq5CwjeTL2I
qpDpOdXbkbfusV.vSrtV5JMLGng5MZRbflLuQSpCzj3MZlWEnqPS5Qw7cSSr
CzD6MZRbflDuQSpCzj5MZxbflLuQCyAZXdilbGnI2azPbflOy4MlxV7ttGE8
CKoD.YpH+8s8ylrHvTpLlPsabu3Q4g3geaAy6mpNqmJMO1aJQtufMUfbZbdM
7efczjOq
-----------end_max5_patcher-----------
</maxpat>

===A Bucket for Symbols===

The {{maxword|name=bucket}} object is a little unusual in that you don't need to worry about using arguments to the object in order to have it work with floating point values. In fact, {{maxword|name=bucket}} is ''so'' useful that people often ask whether or not there's a Max object that is similar but will work with symbols or lists. While there isn't a specific object, here's a Max patch that does exactly that (and it also helpfully outputs stuff in standard right-to-left order, too):

<maxpat>
----------begin_max5_patcher----------
778.3oc2X10bhBCEF9Z7WACWy5jOfjvd296Xmc1A0Ta5ffCDacam9eeIm.pc
KsDEw05zYTOGfj22mdxW7xDufYEakUA9e2+m9dduLwyCRYR30D6ErJc67rzJ
31BVIqpRWJCBsWSK2pg72UrorMY9lUp7LoFdBRSx0kxJYtNUqJx+cobt11q7
D9z3PeBYJJzG07g+u12REazsMEtsoR0yuWku78MSLzLTh42XwAMjZAnxhYO7
MJtUm2UjqySWIgK8iRUZV6Urcp9Oqk1lOHXWKYdnJ0yvEv0cmI6qSlX9HbfL
TeeoTdRPjJL9lDMPHRoG.QnI+PHhtZg3SEmBBYLKBGXcHiCOqK0gjjqUDVj+
4UgtSCbryzP7UkFePAkHhCETb9vpnDTfdDjEknOaTIgciMpjyvf4E3ANyVTh
6PL9la8AF2Ze9.wHiwcGiQWqXr2sp3LOhEQtyC5+adjKepVHuCGOm4WJWdRk
U1o2wwtruCRuKSfiguhPVl9AX7j18V3WDTRPnAhxDg6nDcihR6jTX9vPIWfb
Fk3ja5pRgXXnTvntiR5ULJ09Y9yL+0IMwcxkn9m3CYWdtc00tAC+D4xrz7ku
6aWXEbOAYp7+8MD.Nwj+s.rpdc04s8bih8w65oExJsJGJwN3dLSB4u2u2qVr
PBWG0jYkZw5BUttQCbDeJlUeZMdcaSXFfYRE2Dsu2TUoyxj.95t.3XbAoGWX
F+eTtPjLUPoTLcuKpSMxtf1mKnGmKDbxNIG9lnQv.lCHdf351A7iy.LRjQxB
X32AAig7SFA4yStTxmhN+xmGAqJbQjO97KeAheojO2A0Sv8H+yXsrKECly+c
vr+iodvtL1xbr9KkdntnG1ESODWp9MmO8Z5+W39zSGKoBueQ3vnhHbGQQw1Q
rzcQiwL8tL5.P.9311yd+viSrupg2D03NLZTcmS0RniycMyd13GFm0Qj0cbh
vc2Y2.a550OJKqZTHXr585+PQoIjEBgpbaHrC9fR4ip16mBYRKq25ttde6aJ
sa6dqfELwzOuN4u.mi5K2B
-----------end_max5_patcher-----------
</maxpat>

===Arbitrary List Rotation ===

One way to think of the {{maxword|name=bucket}} object is a as an object that adds new input values and rotates the list by one position. While you can rotate a list forward or backward using the ''r2l'' and ''l2r'' messages to the {{maxword|name=bucket}} object, performing arbitrary list rotations can be done using the {{maxword|name=zl}} object and specifying the '''rot''' option:

[[File:Bucket-in-action-2.png]]

<maxpat>
----------begin_max5_patcher----------
1116.3oc2Y1zbaqBEFds8uBtZtK80iPf9HcWW1scamNYP1DGZk.O.xIoc5+8
q.jh+H1wXEEZFOYhrEBc3bdz6AyA86oShJEORUQfOA9FXxjeOcxDaSlFlzc9
jnZxiKpHJa2hVHpqobczL20zzG011+xcfmDMfGHbMPK.RglnolljfJlRCJeB
TKjTf9dBGH3TvZghoYB9LPixzLE7qJysADk+ftPOG7UZMstjJM2h1YPFekwP
zMTNf2XtnB7.qpBTQIanfUj0p+o2ypXb5BQC25d3tFuSv0bRM05xeVxHU8cu
0bLdEUaiRXWiqkTUavRL94sxVuxQJDFNOdFHAgMeD2c.78slRzn6sUbusH5E
22F.6ZGTl4dQ4Hm4JLejsqoL9qh8Kq+BSl2aK1Ra.zRp+qnO.tStpzNdyiMM
7moSMGl44iUGMiFFl1OfS5Z00j9o0TWzFwLxFPTIguJ54H7XXovgEKjSs3MA
dJnfNFTPQOacYaXnoxaobRYk8VFBdpoJEYE8EpdEUC9W3EhsjihM3ovlOrJM
2bDaOBu4hXENZ.73TyBXxWzl7S4SZimZlJn8KptrU.guDzFfqaz1L91t2ToG
EU2qjlgw34o85ojBaVVxkkkgvWeoYoNoCLsXm7rKDKIich1GJ.gd6.BdMCH7
HnfhupAzaWAkby0LfPucETRwUMfFAET90LfRFAET1UMfFAED58EPaHxm4yGJ
zkWXV3XBJevnC9pIe89sps50k2RzZIqrQS29MUGC6fnAUUMTwc8M229tluRv
WcbbtW2T2KjZO5WO2PG4ZLdaI7jpWFQGqWcSn0CuC5xFlh0aC20sRp9OtT8E
8gV5+hxSzfR.68UaYEUybZLezVYtZcSrmbgZqznQrT1TLHd2+9KVTKNta+Ub
0y51dDXwkAmAUWaaNmVvu.c.7U0AdLubRd+rJG77e2XAEMd4.x1ZvE0.X767
S3yl.f1YmKxSGxbqvwT+6j8ayB9atoN2XwABieC5+3QTyzsyrnQgImbpSyzl
9HYPtoGFjlIeDoxZxheBX6+2ERnhQT0zuPuNwS1MC.OYiHdJaV7SpFTLJ+da
wqJZN0+9fKX1vw0d+.r89ru1gCdgJ1A2z99LTIZjK5Cit4ylA1N7KoJMiae2
C6zoz85y8rkKo7c2+ykLkYsXKO8Jy80cLiT9Y7FyF.FH24fg539S1d976Mcx
NGcfgiNPOoSVvnS54nSb3nSrmzIMXzAeFuwrueAhNGLTmlN3fQGz4nSQ3nSg
mzAEL5jbN5jGN5j6IcRBFcfmiNYgiNYdRGXvny47Fyd8EJ5f7jNgwc74YEDG
rGV93NgKOGOBKMslsbsfw0psU4lZV.drcuuvaOa63Ldq.vC+GGLZ5yjlv3fI
0fd4OgqxCX5GJsOzmeUIObOs7QKCGZoGtpXIqWugJUc1z5Js07+CgzbZ1L6o
Lt6TaA6QRpYG7c829pBhHx1Rt0s0a2Hc07+XgY6EZGm+L8+wpYGFn
-----------end_max5_patcher-----------
</maxpat>

==Third-Party Max externals similar to the {{maxword|name=bucket}} object==

[//www.maxobjects.com/?request=bucket Maxobjects.com listing for the bucket object]

==People who looked at/used this object also looked at....==

The [http://www.cycling74.com/docs/max6/dynamic/c74_docs.html#zl zl] object (in its '''zl rot''' form). Useful for performing rotations of lists.

The [http://www.cycling74.com/docs/max6/dynamic/c74_docs.html#cycle cycle] object

==Errors or Clarifications==

(please list things that you believe to be errors or omissions from the existing refpage)

[[Category:Max Refpage extensions ( symbol, A - F)]]
[[Category:Refpage extensions]]

bucket

2013-04-30T06:05:07Z

Gtaylor@rtqe.net: /* {{maxword|name=bucket}} Tips and Workarounds */

==[//www.cycling74.com/docs/max6/dynamic/c74_docs.html#bucket bucket online refpage]==

==Using the {{maxword|name=bucket}} object==

The {{maxword|name=bucket}} object implements a [//en.wikipedia.org/wiki/Bucket_brigade bucket brigade] device (in the electronics world, this is sometimes referred to as [//en.wikipedia.org/wiki/Bucket-brigade_device a discrete time-analogue delay line]). As the examples below suggest, it's useful for single-sample delay lines, calculating averages, computing velocity and acceleration, and permutating lists by rotating them.

=={{maxword|name=bucket}} Tutorials==

In the Max tutorial on abstractions, you can find a classic example of why the {{maxword|name=bucket}} object is so useful - [//www.cycling74.com/docs/max6/dynamic/c74_docs.html#basicchapter15 this Max tutorial] demonstrates its use as a single sample delay for number values useful for constructing drawing commands.

=={{maxword|name=bucket}} Tips and Workarounds==

===Velocity and Acceleration===

Lots of people use the bucket object for shifting data in series, it's computationally useful for calculating first and second derivatives for streams of data. The terms "first and second derivative" are math-speak for keeping track of:

* the rate that things are changing (that's what velocity (the first derivative) is - the rate of change in a value over time.

* the ''rate of the rate'' that things are changing - that's what acceleration (the second derivative) is.

[[File:Bucket-in-action.png]]

Here's a patch that does that:

<maxpat>
----------begin_max5_patcher----------
863.3oc4XFrbaBCDF9r8SgJmZmwICRf.bu0mgbrISGLHaqDP3QHbcZl7tWoE
vA2ZrAFC8Pu.dEBs69oesR32lOyZU1AVtE5qnuilM6s4ylAMYZXVk8LqzvCQ
Ig4P2rhxRSYBk0hxmoXGTP6psLjLTwPYqQM+cz1PwF1ihOmyhxDwnXljuOTw
2y9xih5QIgKzOsP.CEopQQQJWjvTfewUMtKTEskK17CIKRUF2d1d2au.4rz2
bC6EXt4pMPOU8R7XHDyV87cjk09bclPIBSYvi9ljGlX8giyJT0d1tt+xMq.6
6saLB47eAi.lbr4cRVtlP5bLSbRXRg.y1L.n5KnmLuz6ymatr3FNGbj6q4xb
0HfcW+flXGiuH1CFOrO..pc0JlzpmYrS.AR0xYPJbkX2RB612DlbzwRcuUL4
OXhvUIrSfw4Ubkih50crx.0haDGHqUZIf0fTXoEIJddBOt+TpZ4HojOXLXgc
BZgSjgSiblRGR53tzw2QONubzS5tjqds70nsQKCplbLUs7oqXBOpXpkRV0wn
i6okrlF3px1rQO38cQJApG4srd04EViZednh6.TO6RtoVCUkqcTCgCtYZH6i
0AmJwff8ScN7W63oiWY1YwF4pXqpNtK9RZDreeqii6Ys5gWjtElDKKDuXxND
8rjw45jg.qd7cuHY7FaxL3kTs.lOcmV31WwR81Y1NvocJKHhaAImkHODJxQO
nO+05dgEpOlz5Bo0IYg2V3rpH5ElBQF318XO3Vf+k3CYP7gL.9byKzLHsS89
mcQ637en1ohOcR639OT6.wC70R+wmJC4jo8SYVdVgLpd3pJLf9HqhY4Jt.Nr
Ui9XNIbiNskGGyDM2CNlma1VFPx4+nmtFNlON4pwio9NhLIwiSWvC9J3IkGu
KSukQ0TjqVNQ0I.Ivbqo0GN5lk..qtJPCltIX6tDO9SV7zI931uIXGGOyTJl
BkMplfAqwXB1uqqXlnIXsmvWKbNoOWkmdAN.AWB+MUd5u4q1ZD3IoK3bxnYm
p+LrxONvV+zR1dpElBa64goGsFAR61AkhS+TJTJsgRgZ6MlJktrUky.UJk6q
Gta2dlLuZHg.QepmmyjFSuEfIWTZBGlwRx1yq6ObBCqPo9rMJ8AaJjkGL4Pf
m0biede9u0DMhQJ
-----------end_max5_patcher-----------
</maxpat>

===Running Averages===

I also tend to use the object quite a bit in situations where I desire a running average over some finite set of events (if you want a running average for an stream or unspecified set of values, you'd use the {{maxword|name=mean}} object). Here's an example that calculates the average of the last 8 floating point input values:

<maxpat>
----------begin_max5_patcher----------
498.3ocuV1sajBBEG+Z8ofvkabm.9AZ6c84nYyFFkYKsJZTrc11z28UO3z1Y
CyHocJwnjywCG9wePN9RX.da6dw.FcM5VTPvKgAAfqYGAK1A3F99xZ9.DFtc
TWKz3HyqTiMR0jM7N56NMQAdIKd635x6jp+76dQo1Lhz7zMjHTbbFz71SzuV
5irxLlau+m4GFxx1lFgBx.FO650vv4GQNNA.dsxOwJ+zU4mUbB7MYQ+2NgId
L11LicolYJwSS46P1zh8lT8CDYCMNy5TNdw4tVkdP9LvIMdymUInWQmaRuBj
Bx4jhc0sbsU83MRmgRwafdfuoWxqufpRGu7AztiurJQEWXIJwzvHaxVSirJO
odQddtFML1702yDutfvRf8LYqumAGcBMIwKZx1wxGDZTwYO7yIUoXcUgvbea
RzYtsIWT2jKnq3Zo5+qP.XO6+XMbncru7.TKeIidm6JwfVp3ZYq5CwjeTL2I
qpDpOdXbkbfusV.vSrtV5JMLGng5MZRbflLuQSpCzj3MZlWEnqPS5Qw7cSSr
CzD6MZRbflDuQSpCzj5MZxbflLuQCyAZXdilbGnI2azPbflOy4MlxV7ttGE8
CKoD.YpH+8s8ylrHvTpLlPsabu3Q4g3geaAy6mpNqmJMO1aJQtufMUfbZbdM
7efczjOq
-----------end_max5_patcher-----------
</maxpat>

===A Bucket for Symbols===

The {{maxword|name=bucket}} object is a little unusual in that you don't need to worry about using arguments to the object in order to have it work with floating point values. In fact, {{maxword|name=bucket}} is ''so'' useful that people often ask whether or not there's a Max object that is similar but will work with symbols or lists. While there isn't a specific object, here's a Max patch that does exactly that (and it also helpfully outputs stuff in standard right-to-left order, too):

<maxpat>
----------begin_max5_patcher----------
778.3oc2X10bhBCEF9Z7WACWy5jOfjvd296Xmc1A0Ta5ffCDacam9eeIm.pc
KsDEw05zYTOGfj22mdxW7xDufYEakUA9e2+m9dduLwyCRYR30D6ErJc67rzJ
31BVIqpRWJCBsWSK2pg72UrorMY9lUp7LoFdBRSx0kxJYtNUqJx+cobt11q7
D9z3PeBYJJzG07g+u12REazsMEtsoR0yuWku78MSLzLTh42XwAMjZAnxhYO7
MJtUm2UjqySWIgK8iRUZV6Urcp9Oqk1lOHXWKYdnJ0yvEv0cmI6qSlX9HbfL
TeeoTdRPjJL9lDMPHRoG.QnI+PHhtZg3SEmBBYLKBGXcHiCOqK0gjjqUDVj+
4UgtSCbryzP7UkFePAkHhCETb9vpnDTfdDjEknOaTIgciMpjyvf4E3ANyVTh
6PL9la8AF2Ze9.wHiwcGiQWqXr2sp3LOhEQtyC5+adjKepVHuCGOm4WJWdRk
U1o2wwtruCRuKSfiguhPVl9AX7j18V3WDTRPnAhxDg6nDcihR6jTX9vPIWfb
Fk3ja5pRgXXnTvntiR5ULJ09Y9yL+0IMwcxkn9m3CYWdtc00tAC+D4xrz7ku
6aWXEbOAYp7+8MD.Nwj+s.rpdc04s8bih8w65oExJsJGJwN3dLSB4u2u2qVr
PBWG0jYkZw5BUttQCbDeJlUeZMdcaSXFfYRE2Dsu2TUoyxj.95t.3XbAoGWX
F+eTtPjLUPoTLcuKpSMxtf1mKnGmKDbxNIG9lnQv.lCHdf351A7iy.LRjQxB
X32AAig7SFA4yStTxmhN+xmGAqJbQjO97KeAheojO2A0Sv8H+yXsrKECly+c
vr+iodvtL1xbr9KkdntnG1ESODWp9MmO8Z5+W39zSGKoBueQ3vnhHbGQQw1Q
rzcQiwL8tL5.P.9311yd+viSrupg2D03NLZTcmS0RniycMyd13GFm0Qj0cbh
vc2Y2.a550OJKqZTHXr585+PQoIjEBgpbaHrC9fR4ip16mBYRKq25ttde6aJ
sa6dqfELwzOuN4u.mi5K2B
-----------end_max5_patcher-----------
</maxpat>

===Arbitrary List Rotation ===

One way to think of the {{maxword|name=bucket}} object is a as an object that adds new input values and rotates the list by one position. While you can rotate a list forward or backward using the ''r2l'' and ''l2r'' messages to the {{maxword|name=bucket}} object, performing arbitrary list rotations can be done using the {{maxword|name=zl}} object and specifying the '''rot''' option:

[[File:Bucket-in-action-2.png]]

<maxpat>
----------begin_max5_patcher----------
1116.3oc2Y1zbaqBEFds8uBtZtK80iPf9HcWW1scamNYP1DGZk.O.xIoc5+8
q.jh+H1wXEEZFOYhrEBc3bdz6AyA86oShJEORUQfOA9FXxjeOcxDaSlFlzc9
jnZxiKpHJa2hVHpqobczL20zzG011+xcfmDMfGHbMPK.RglnolljfJlRCJeB
TKjTf9dBGH3TvZghoYB9LPixzLE7qJysADk+ftPOG7UZMstjJM2h1YPFekwP
zMTNf2XtnB7.qpBTQIanfUj0p+o2ypXb5BQC25d3tFuSv0bRM05xeVxHU8cu
0bLdEUaiRXWiqkTUavRL94sxVuxQJDFNOdFHAgMeD2c.78slRzn6sUbusH5E
22F.6ZGTl4dQ4Hm4JLejsqoL9qh8Kq+BSl2aK1Ra.zRp+qnO.tStpzNdyiMM
7moSMGl44iUGMiFFl1OfS5Z00j9o0TWzFwLxFPTIguJ54H7XXovgEKjSs3MA
dJnfNFTPQOacYaXnoxaobRYk8VFBdpoJEYE8EpdEUC9W3EhsjihM3ovlOrJM
2bDaOBu4hXENZ.73TyBXxWzl7S4SZimZlJn8KptrU.guDzFfqaz1L91t2ToG
EU2qjlgw34o85ojBaVVxkkkgvWeoYoNoCLsXm7rKDKIich1GJ.gd6.BdMCH7
HnfhupAzaWAkby0LfPucETRwUMfFAET90LfRFAET1UMfFAED58EPaHxm4yGJ
zkWXV3XBJevnC9pIe89sps50k2RzZIqrQS29MUGC6fnAUUMTwc8M229tluRv
WcbbtW2T2KjZO5WO2PG4ZLdaI7jpWFQGqWcSn0CuC5xFlh0aC20sRp9OtT8E
8gV5+hxSzfR.68UaYEUybZLezVYtZcSrmbgZqznQrT1TLHd2+9KVTKNta+Ub
0y51dDXwkAmAUWaaNmVvu.c.7U0AdLubRd+rJG77e2XAEMd4.x1ZvE0.X767
S3yl.f1YmKxSGxbqvwT+6j8ayB9atoN2XwABieC5+3QTyzsyrnQgImbpSyzl
9HYPtoGFjlIeDoxZxheBX6+2ERnhQT0zuPuNwS1MC.OYiHdJaV7SpFTLJ+da
wqJZN0+9fKX1vw0d+.r89ru1gCdgJ1A2z99LTIZjK5Cit4ylA1N7KoJMiae2
C6zoz85y8rkKo7c2+ykLkYsXKO8Jy80cLiT9Y7FyF.FH24fg539S1d976Mcx
NGcfgiNPOoSVvnS54nSb3nSrmzIMXzAeFuwrueAhNGLTmlN3fQGz4nSQ3nSg
mzAEL5jbN5jGN5j6IcRBFcfmiNYgiNYdRGXvny47Fyd8EJ5f7jNgwc74YEDG
rGV93NgKOGOBKMslsbsfw0psU4lZV.drcuuvaOa63Ldq.vC+GGLZ5yjlv3fI
0fd4OgqxCX5GJsOzmeUIObOs7QKCGZoGtpXIqWugJUc1z5Js07+CgzbZ1L6o
Lt6TaA6QRpYG7c829pBhHx1Rt0s0a2Hc07+XgY6EZGm+L8+wpYGFn
-----------end_max5_patcher-----------
</maxpat>

==Third-Party Max externals similar to the {{maxword|name=bucket}} object==

[//www.maxobjects.com/?request=bucket Maxobjects.com listing for the bucket object]

==People who looked at/used this object also looked at....==

The [http://www.cycling74.com/docs/max6/dynamic/c74_docs.html#zl zl] object (in its '''zl rot''' form). Useful for performing rotations of lists where the list offset is an odd number greater than 1.

The [http://www.cycling74.com/docs/max6/dynamic/c74_docs.html#cycle cycle] object

==Errors or Clarifications==

(please list things that you believe to be errors or omissions from the existing refpage)

[[Category:Max Refpage extensions ( symbol, A - F)]]
[[Category:Refpage extensions]]

File:Bucket-in-action-2.png

2013-04-30T06:04:35Z

Gtaylor@rtqe.net:

bucket

2013-04-30T05:46:11Z

Gtaylor@rtqe.net: /* {{maxword|name=bucket}} Tips and Workarounds */

==[//www.cycling74.com/docs/max6/dynamic/c74_docs.html#bucket bucket online refpage]==

==Using the {{maxword|name=bucket}} object==

The {{maxword|name=bucket}} object implements a [//en.wikipedia.org/wiki/Bucket_brigade bucket brigade] device (in the electronics world, this is sometimes referred to as [//en.wikipedia.org/wiki/Bucket-brigade_device a discrete time-analogue delay line]). As the examples below suggest, it's useful for single-sample delay lines, calculating averages, computing velocity and acceleration, and permutating lists by rotating them.

=={{maxword|name=bucket}} Tutorials==

In the Max tutorial on abstractions, you can find a classic example of why the {{maxword|name=bucket}} object is so useful - [//www.cycling74.com/docs/max6/dynamic/c74_docs.html#basicchapter15 this Max tutorial] demonstrates its use as a single sample delay for number values useful for constructing drawing commands.

=={{maxword|name=bucket}} Tips and Workarounds==

===Velocity and Acceleration===

Lots of people use the bucket object for shifting data in series, it's computationally useful for calculating first and second derivatives for streams of data. The terms "first and second derivative" are math-speak for keeping track of:

* the rate that things are changing (that's what velocity (the first derivative) is - the rate of change in a value over time.

* the ''rate of the rate'' that things are changing - that's what acceleration (the second derivative) is.

[[File:Bucket-in-action.png]]

Here's a patch that does that:

<maxpat>
----------begin_max5_patcher----------
863.3oc4XFrbaBCDF9r8SgJmZmwICRf.bu0mgbrISGLHaqDP3QHbcZl7tWoE
vA2ZrAFC8Pu.dEBs69oesR32lOyZU1AVtE5qnuilM6s4ylAMYZXVk8LqzvCQ
Ig4P2rhxRSYBk0hxmoXGTP6psLjLTwPYqQM+cz1PwF1ihOmyhxDwnXljuOTw
2y9xih5QIgKzOsP.CEopQQQJWjvTfewUMtKTEskK17CIKRUF2d1d2au.4rz2
bC6EXt4pMPOU8R7XHDyV87cjk09bclPIBSYvi9ljGlX8giyJT0d1tt+xMq.6
6saLB47eAi.lbr4cRVtlP5bLSbRXRg.y1L.n5KnmLuz6ymatr3FNGbj6q4xb
0HfcW+flXGiuH1CFOrO..pc0JlzpmYrS.AR0xYPJbkX2RB612DlbzwRcuUL4
OXhvUIrSfw4Ubkih50crx.0haDGHqUZIf0fTXoEIJddBOt+TpZ4HojOXLXgc
BZgSjgSiblRGR53tzw2QONubzS5tjqds70nsQKCplbLUs7oqXBOpXpkRV0wn
i6okrlF3px1rQO38cQJApG4srd04EViZednh6.TO6RtoVCUkqcTCgCtYZH6i
0AmJwff8ScN7W63oiWY1YwF4pXqpNtK9RZDreeqii6Ys5gWjtElDKKDuXxND
8rjw45jg.qd7cuHY7FaxL3kTs.lOcmV31WwR81Y1NvocJKHhaAImkHODJxQO
nO+05dgEpOlz5Bo0IYg2V3rpH5ElBQF318XO3Vf+k3CYP7gL.9byKzLHsS89
mcQ637en1ohOcR639OT6.wC70R+wmJC4jo8SYVdVgLpd3pJLf9HqhY4Jt.Nr
Ui9XNIbiNskGGyDM2CNlma1VFPx4+nmtFNlON4pwio9NhLIwiSWvC9J3IkGu
KSukQ0TjqVNQ0I.Ivbqo0GN5lk..qtJPCltIX6tDO9SV7zI931uIXGGOyTJl
BkMplfAqwXB1uqqXlnIXsmvWKbNoOWkmdAN.AWB+MUd5u4q1ZD3IoK3bxnYm
p+LrxONvV+zR1dpElBa64goGsFAR61AkhS+TJTJsgRgZ6MlJktrUky.UJk6q
Gta2dlLuZHg.QepmmyjFSuEfIWTZBGlwRx1yq6ObBCqPo9rMJ8AaJjkGL4Pf
m0biede9u0DMhQJ
-----------end_max5_patcher-----------
</maxpat>

===Running Averages===

I also tend to use the object quite a bit in situations where I desire a running average over some finite set of events (if you want a running average for an stream or unspecified set of values, you'd use the {{maxword|name=mean}} object). Here's an example that calculates the average of the last 8 floating point input values:

<maxpat>
----------begin_max5_patcher----------
498.3ocuV1sajBBEG+Z8ofvkabm.9AZ6c84nYyFFkYKsJZTrc11z28UO3z1Y
CyHocJwnjywCG9wePN9RX.da6dw.FcM5VTPvKgAAfqYGAK1A3F99xZ9.DFtc
TWKz3HyqTiMR0jM7N56NMQAdIKd635x6jp+76dQo1Lhz7zMjHTbbFz71SzuV
5irxLlau+m4GFxx1lFgBx.FO650vv4GQNNA.dsxOwJ+zU4mUbB7MYQ+2NgId
L11LicolYJwSS46P1zh8lT8CDYCMNy5TNdw4tVkdP9LvIMdymUInWQmaRuBj
Bx4jhc0sbsU83MRmgRwafdfuoWxqufpRGu7AztiurJQEWXIJwzvHaxVSirJO
odQddtFML1702yDutfvRf8LYqumAGcBMIwKZx1wxGDZTwYO7yIUoXcUgvbea
RzYtsIWT2jKnq3Zo5+qP.XO6+XMbncru7.TKeIidm6JwfVp3ZYq5CwjeTL2I
qpDpOdXbkbfusV.vSrtV5JMLGng5MZRbflLuQSpCzj3MZlWEnqPS5Qw7cSSr
CzD6MZRbflDuQSpCzj5MZxbflLuQCyAZXdilbGnI2azPbflOy4MlxV7ttGE8
CKoD.YpH+8s8ylrHvTpLlPsabu3Q4g3geaAy6mpNqmJMO1aJQtufMUfbZbdM
7efczjOq
-----------end_max5_patcher-----------
</maxpat>

===A Bucket for Symbols===

The {{maxword|name=bucket}} object is a little unusual in that you don't need to worry about using arguments to the object in order to have it work with floating point values. In fact, {{maxword|name=bucket}} is ''so'' useful that people often ask whether or not there's a Max object that is similar but will work with symbols or lists. While there isn't a specific object, here's a Max patch that does exactly that (and it also helpfully outputs stuff in standard right-to-left order, too):

<maxpat>
----------begin_max5_patcher----------
778.3oc2X10bhBCEF9Z7WACWy5jOfjvd296Xmc1A0Ta5ffCDacam9eeIm.pc
KsDEw05zYTOGfj22mdxW7xDufYEakUA9e2+m9dduLwyCRYR30D6ErJc67rzJ
31BVIqpRWJCBsWSK2pg72UrorMY9lUp7LoFdBRSx0kxJYtNUqJx+cobt11q7
D9z3PeBYJJzG07g+u12REazsMEtsoR0yuWku78MSLzLTh42XwAMjZAnxhYO7
MJtUm2UjqySWIgK8iRUZV6Urcp9Oqk1lOHXWKYdnJ0yvEv0cmI6qSlX9HbfL
TeeoTdRPjJL9lDMPHRoG.QnI+PHhtZg3SEmBBYLKBGXcHiCOqK0gjjqUDVj+
4UgtSCbryzP7UkFePAkHhCETb9vpnDTfdDjEknOaTIgciMpjyvf4E3ANyVTh
6PL9la8AF2Ze9.wHiwcGiQWqXr2sp3LOhEQtyC5+adjKepVHuCGOm4WJWdRk
U1o2wwtruCRuKSfiguhPVl9AX7j18V3WDTRPnAhxDg6nDcihR6jTX9vPIWfb
Fk3ja5pRgXXnTvntiR5ULJ09Y9yL+0IMwcxkn9m3CYWdtc00tAC+D4xrz7ku
6aWXEbOAYp7+8MD.Nwj+s.rpdc04s8bih8w65oExJsJGJwN3dLSB4u2u2qVr
PBWG0jYkZw5BUttQCbDeJlUeZMdcaSXFfYRE2Dsu2TUoyxj.95t.3XbAoGWX
F+eTtPjLUPoTLcuKpSMxtf1mKnGmKDbxNIG9lnQv.lCHdf351A7iy.LRjQxB
X32AAig7SFA4yStTxmhN+xmGAqJbQjO97KeAheojO2A0Sv8H+yXsrKECly+c
vr+iodvtL1xbr9KkdntnG1ESODWp9MmO8Z5+W39zSGKoBueQ3vnhHbGQQw1Q
rzcQiwL8tL5.P.9311yd+viSrupg2D03NLZTcmS0RniycMyd13GFm0Qj0cbh
vc2Y2.a550OJKqZTHXr585+PQoIjEBgpbaHrC9fR4ip16mBYRKq25ttde6aJ
sa6dqfELwzOuN4u.mi5K2B
-----------end_max5_patcher-----------
</maxpat>

==Third-Party Max externals similar to the {{maxword|name=bucket}} object==

[//www.maxobjects.com/?request=bucket Maxobjects.com listing for the bucket object]

==People who looked at/used this object also looked at....==

The [http://www.cycling74.com/docs/max6/dynamic/c74_docs.html#zl zl] object (in its '''zl rot''' form). Useful for performing rotations of lists where the list offset is an odd number greater than 1.

The [http://www.cycling74.com/docs/max6/dynamic/c74_docs.html#cycle cycle] object

==Errors or Clarifications==

(please list things that you believe to be errors or omissions from the existing refpage)

[[Category:Max Refpage extensions ( symbol, A - F)]]
[[Category:Refpage extensions]]

bucket

2013-04-30T05:42:35Z

Gtaylor@rtqe.net: /* People who looked at/used this object also looked at.... */

==[//www.cycling74.com/docs/max6/dynamic/c74_docs.html#bucket bucket online refpage]==

==Using the {{maxword|name=bucket}} object==

The {{maxword|name=bucket}} object implements a [//en.wikipedia.org/wiki/Bucket_brigade bucket brigade] device (in the electronics world, this is sometimes referred to as [//en.wikipedia.org/wiki/Bucket-brigade_device a discrete time-analogue delay line]). As the examples below suggest, it's useful for single-sample delay lines, calculating averages, computing velocity and acceleration, and permutating lists by rotating them.

=={{maxword|name=bucket}} Tutorials==

In the Max tutorial on abstractions, you can find a classic example of why the {{maxword|name=bucket}} object is so useful - [//www.cycling74.com/docs/max6/dynamic/c74_docs.html#basicchapter15 this Max tutorial] demonstrates its use as a single sample delay for number values useful for constructing drawing commands.

=={{maxword|name=bucket}} Tips and Workarounds==

Lots of people use the bucket object for shifting data in series, it's computationally useful for calculating first and second derivatives for streams of data. The terms "first and second derivative" are math-speak for keeping track of:

* the rate that things are changing (that's what velocity (the first derivative) is - the rate of change in a value over time.

* the ''rate of the rate'' that things are changing - that's what acceleration (the second derivative) is.

[[File:Bucket-in-action.png]]

Here's a patch that does that:

<maxpat>
----------begin_max5_patcher----------
863.3oc4XFrbaBCDF9r8SgJmZmwICRf.bu0mgbrISGLHaqDP3QHbcZl7tWoE
vA2ZrAFC8Pu.dEBs69oesR32lOyZU1AVtE5qnuilM6s4ylAMYZXVk8LqzvCQ
Ig4P2rhxRSYBk0hxmoXGTP6psLjLTwPYqQM+cz1PwF1ihOmyhxDwnXljuOTw
2y9xih5QIgKzOsP.CEopQQQJWjvTfewUMtKTEskK17CIKRUF2d1d2au.4rz2
bC6EXt4pMPOU8R7XHDyV87cjk09bclPIBSYvi9ljGlX8giyJT0d1tt+xMq.6
6saLB47eAi.lbr4cRVtlP5bLSbRXRg.y1L.n5KnmLuz6ymatr3FNGbj6q4xb
0HfcW+flXGiuH1CFOrO..pc0JlzpmYrS.AR0xYPJbkX2RB612DlbzwRcuUL4
OXhvUIrSfw4Ubkih50crx.0haDGHqUZIf0fTXoEIJddBOt+TpZ4HojOXLXgc
BZgSjgSiblRGR53tzw2QONubzS5tjqds70nsQKCplbLUs7oqXBOpXpkRV0wn
i6okrlF3px1rQO38cQJApG4srd04EViZednh6.TO6RtoVCUkqcTCgCtYZH6i
0AmJwff8ScN7W63oiWY1YwF4pXqpNtK9RZDreeqii6Ys5gWjtElDKKDuXxND
8rjw45jg.qd7cuHY7FaxL3kTs.lOcmV31WwR81Y1NvocJKHhaAImkHODJxQO
nO+05dgEpOlz5Bo0IYg2V3rpH5ElBQF318XO3Vf+k3CYP7gL.9byKzLHsS89
mcQ637en1ohOcR639OT6.wC70R+wmJC4jo8SYVdVgLpd3pJLf9HqhY4Jt.Nr
Ui9XNIbiNskGGyDM2CNlma1VFPx4+nmtFNlON4pwio9NhLIwiSWvC9J3IkGu
KSukQ0TjqVNQ0I.Ivbqo0GN5lk..qtJPCltIX6tDO9SV7zI931uIXGGOyTJl
BkMplfAqwXB1uqqXlnIXsmvWKbNoOWkmdAN.AWB+MUd5u4q1ZD3IoK3bxnYm
p+LrxONvV+zR1dpElBa64goGsFAR61AkhS+TJTJsgRgZ6MlJktrUky.UJk6q
Gta2dlLuZHg.QepmmyjFSuEfIWTZBGlwRx1yq6ObBCqPo9rMJ8AaJjkGL4Pf
m0biede9u0DMhQJ
-----------end_max5_patcher-----------
</maxpat>

I also tend to use the object quite a bit in situations where I desire a running average over some finite set of events (if you want a running average for an stream or unspecified set of values, you'd use the {{maxword|name=mean}} object). Here's an example that calculates the average of the last 8 floating point input values:

<maxpat>
----------begin_max5_patcher----------
498.3ocuV1sajBBEG+Z8ofvkabm.9AZ6c84nYyFFkYKsJZTrc11z28UO3z1Y
CyHocJwnjywCG9wePN9RX.da6dw.FcM5VTPvKgAAfqYGAK1A3F99xZ9.DFtc
TWKz3HyqTiMR0jM7N56NMQAdIKd635x6jp+76dQo1Lhz7zMjHTbbFz71SzuV
5irxLlau+m4GFxx1lFgBx.FO650vv4GQNNA.dsxOwJ+zU4mUbB7MYQ+2NgId
L11LicolYJwSS46P1zh8lT8CDYCMNy5TNdw4tVkdP9LvIMdymUInWQmaRuBj
Bx4jhc0sbsU83MRmgRwafdfuoWxqufpRGu7AztiurJQEWXIJwzvHaxVSirJO
odQddtFML1702yDutfvRf8LYqumAGcBMIwKZx1wxGDZTwYO7yIUoXcUgvbea
RzYtsIWT2jKnq3Zo5+qP.XO6+XMbncru7.TKeIidm6JwfVp3ZYq5CwjeTL2I
qpDpOdXbkbfusV.vSrtV5JMLGng5MZRbflLuQSpCzj3MZlWEnqPS5Qw7cSSr
CzD6MZRbflDuQSpCzj5MZxbflLuQCyAZXdilbGnI2azPbflOy4MlxV7ttGE8
CKoD.YpH+8s8ylrHvTpLlPsabu3Q4g3geaAy6mpNqmJMO1aJQtufMUfbZbdM
7efczjOq
-----------end_max5_patcher-----------
</maxpat>

The {{maxword|name=bucket}} object is a little unusual in that you don't need to worry about using arguments to the object in order to have it work with floating point values. In fact, {{maxword|name=bucket}} is ''so'' useful that people often ask whether or not there's a Max object that is similar but will work with symbols or lists. While there isn't a specific object, here's a Max patch that does exactly that (and it also helpfully outputs stuff in standard right-to-left order, too):

<maxpat>
----------begin_max5_patcher----------
778.3oc2X10bhBCEF9Z7WACWy5jOfjvd296Xmc1A0Ta5ffCDacam9eeIm.pc
KsDEw05zYTOGfj22mdxW7xDufYEakUA9e2+m9dduLwyCRYR30D6ErJc67rzJ
31BVIqpRWJCBsWSK2pg72UrorMY9lUp7LoFdBRSx0kxJYtNUqJx+cobt11q7
D9z3PeBYJJzG07g+u12REazsMEtsoR0yuWku78MSLzLTh42XwAMjZAnxhYO7
MJtUm2UjqySWIgK8iRUZV6Urcp9Oqk1lOHXWKYdnJ0yvEv0cmI6qSlX9HbfL
TeeoTdRPjJL9lDMPHRoG.QnI+PHhtZg3SEmBBYLKBGXcHiCOqK0gjjqUDVj+
4UgtSCbryzP7UkFePAkHhCETb9vpnDTfdDjEknOaTIgciMpjyvf4E3ANyVTh
6PL9la8AF2Ze9.wHiwcGiQWqXr2sp3LOhEQtyC5+adjKepVHuCGOm4WJWdRk
U1o2wwtruCRuKSfiguhPVl9AX7j18V3WDTRPnAhxDg6nDcihR6jTX9vPIWfb
Fk3ja5pRgXXnTvntiR5ULJ09Y9yL+0IMwcxkn9m3CYWdtc00tAC+D4xrz7ku
6aWXEbOAYp7+8MD.Nwj+s.rpdc04s8bih8w65oExJsJGJwN3dLSB4u2u2qVr
PBWG0jYkZw5BUttQCbDeJlUeZMdcaSXFfYRE2Dsu2TUoyxj.95t.3XbAoGWX
F+eTtPjLUPoTLcuKpSMxtf1mKnGmKDbxNIG9lnQv.lCHdf351A7iy.LRjQxB
X32AAig7SFA4yStTxmhN+xmGAqJbQjO97KeAheojO2A0Sv8H+yXsrKECly+c
vr+iodvtL1xbr9KkdntnG1ESODWp9MmO8Z5+W39zSGKoBueQ3vnhHbGQQw1Q
rzcQiwL8tL5.P.9311yd+viSrupg2D03NLZTcmS0RniycMyd13GFm0Qj0cbh
vc2Y2.a550OJKqZTHXr585+PQoIjEBgpbaHrC9fR4ip16mBYRKq25ttde6aJ
sa6dqfELwzOuN4u.mi5K2B
-----------end_max5_patcher-----------
</maxpat>

==Third-Party Max externals similar to the {{maxword|name=bucket}} object==

[//www.maxobjects.com/?request=bucket Maxobjects.com listing for the bucket object]

==People who looked at/used this object also looked at....==

The [http://www.cycling74.com/docs/max6/dynamic/c74_docs.html#zl zl] object (in its '''zl rot''' form). Useful for performing rotations of lists where the list offset is an odd number greater than 1.

The [http://www.cycling74.com/docs/max6/dynamic/c74_docs.html#cycle cycle] object

==Errors or Clarifications==

(please list things that you believe to be errors or omissions from the existing refpage)

[[Category:Max Refpage extensions ( symbol, A - F)]]
[[Category:Refpage extensions]]

bucket

2013-04-30T05:42:16Z

2013-03-27T18:14:44Z

Gtaylor@rtqe.net: /* {{maxword|name=mtof}} Tips and Workarounds */

==[//www.cycling74.com/docs/max6/dynamic/c74_docs.html#mtof mtof online refpage]==

==Using the {{maxword|name=mtof}} object==

=={{maxword|name=mtof}} Tutorials==

=={{maxword|name=mtof}} Tips and Workarounds==

Since frequency is exponential rather than linear, using a simple slider never gave me good results for doing things like setting filter cutoff frequencies.

The '''mtof''' object is perfect for this use. The ability to work with floating point values means that you can produce smooth filter cutoff values by sending the '''mtof'''object a floating point value between 0. and 127. for cutoff frequencies between 8.176 and 12541. Hz.

<maxpat>
----------begin_max5_patcher----------
656.3oc0VssaiBCD8YxWAhmoQXtkj8s86XUUjSvI0UD6HaCaZq59su1iwIjM
PKDEgz9.fYlQiOyYNdfOl4ErgehHC7+g+u7879XlmGXxXvq4cufC3SaKwRHr
.x6E3s+IHz5hUcfxJIJvWbiwiX01Wnr8qEjsJatiSSmuHKzOEsbdj9Ql6t+y
WxDuR4RUTiUZAro7Mu9zx.ioOmMybKbfnsjVSluGSYmQbMVvvGH83cr0SbdN
TIPUgRx6sfxtsfVDbN+BMhTDwZBCuoDvFpwmMEp2NRrabfjtmgKCBauxbsqj
iUlEkToFjNTHw0jh0XkRP2ToHWVIaXsFZyPLkUD9NmYm81vqhQUR0aVDlFda
.GzjuwmgT5xKkY79zhnN8S0ompqHnPitPkWEjiJ5JAxW3BU+c2qhsjy12Un1
HAYl6wH0bLxu0sWWyUQNorl4TIoagFpegFZEBjVKiAcFn1hi5UlgtUlk61xc
b1Ex4mBCS2xij9tU3E65M8p87e9wwJx5ccyIIC3vWRhgNxVMO6KIkzaIkrGN
oD9kqtKJSejVWHmmRHHRBSgUTNqEYjfV.ZhbXDTTys1LwfzYw4YszYqV7M5r
3aozzumR6ZPWzHo6yy41fY6eD75XYnX3.YVz3Ynj+aXndNrdPo+9vcRaYvY0
jzwO.C83NqdMa.PPO6m8u+ADTFF6WSQRdkXqKUMSQ7uTHEDohxfymshQ+Ude
z4XdgVTPXs6pETooQCkaTmspghlq2otQyxIEMQC.MQSBZFZmZZPS9.PS1jgl
zAhloQ2fF.ZRmLtIY.nAcmnwN9Ae7XMQHaRI.D8r3W4B3+nCgWoL6qvvw.Ao
l5h2ZAKzScU5QtUB6vwSKy0+Hqde9b1eAH1SDsC
-----------end_max5_patcher-----------
</maxpat>

==Third-Party Max externals similar to the {{maxword|name=mtof}} object==

[//www.maxobjects.com/?request=mtof Maxobjects.com listing for the mtof object]

==People who looked at/used this object also looked at....==

==Errors or Clarifications==

(please list things that you believe to be errors or omissions from the existing refpage)

[[Category:Max Refpage extensions (G - M)]]
[[Category:Refpage extensions]]

mtof

2013-03-27T18:11:54Z

Gtaylor@rtqe.net: /* {{maxword|name=mtof}} Tips and Workarounds */

Max Guitar Processor, Part 4

2013-02-06T23:26:10Z

Gtaylor@rtqe.net:

At this point, we have a pretty useful guitar processing "rack", but it could use a little spice. This spice will come from two additional processors: a looping delay unit, and a basic reverb system. Also, to help keep the output useful, we will drop a limiter on the back end of the entire rig.

[http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/GtrProc-4.maxpat.zip Download the patch used in this tutorial].

===Tutorials in this series:===

* [[Max_Guitar_Processor,_Part_1|Part 1]]
* [[Max_Guitar_Processor,_Part_2|Part 2]]
* [[Max_Guitar_Processor,_Part_3|Part 3]]
* [[Max_Guitar_Processor,_Part_4|Part 4]]
* [[Max_Guitar_Processor,_Part_5|Part 5]]

==Looping Delay==

The first processor we will add is an alternative version of the delay line – one that provides tap tempo, looping and sound-on-sound functionality. Unlike our previous delay module, this one will not provide modulation (for flanging and pitch shifting effects); rather it will be focused on capturing a loop, and allowing overdubs of additional sounds.

<img>http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/4-Tap_TempoB.jpg</img>

As with any delay line, the most important setting is the delay time. We use a standard floating-point number box for entry, but it is probably most convenient to use the "tap tempo" function that is implemented. By clicking on the tap tempo button four times, you generate a delay time that will match your taps.

The tap tempo function is provided by the taptempo abstraction at the top level of the patch. It counts four incoming bang messages, determines the three intervals between the taps, takes the average and uses that for the tempo calculation. Since it is assumed that we are tapping quarter notes, but want to use a four bar measure, the result is multiplied by four to give us a delay time value. This is an area where you might want to modify the function to meet your needs – if you really want to have the delay run at the rate you tapped, you can remove the [* 4] object at the end of the processing chain.

The basic delay design, as found in the loop_handler subpatcher, is very similar to the layout of the modulating delay. The few tweaks provided are there to support the looping functions. First, when the "Freeze" button is "on", the feedback is switched to 100% feedback. This gives us a standard looping function. The feedback loop has a lowpass filter in it, which will change the audio in the loop if it is not fully open. The "Input Active" button is very important – it determines if the input signal is sent into the delay path. If it is off, the only output of the delay line is whatever is currently playing – if the delay is "frozen", you will hear the loop, while with freeze off you will only hear the remaining contents of the loop line feedback. What is cool about this is that, when you freeze the delay line, you can still overlay audio parts onto the loop – giving you sound-on-sound overdubbing.

I've also implemented a click track that cycles at the same speed as the delay time. This way, if you want to work up some one-bar loops, you can hear the timing (in quarter note click) even before you begin recording. Most of these concepts are classic delay techniques, but this sort of looping processor is exactly why many people first get into Max/MSP. Even if you aren't into guitar processing per se, you may find this looping delay system can jump-start your Max experiments.

==Reverb==

What would an effects processing rig be without a reverb? As is typical for any processing rack, I've installed a reverb as the last effect in the system – this way, we will get consistant reverb from both our looped and our live guitar lines. To provide reverb, I've gone to a third-party external object: Nathan Wolek's gverb~. I happen to like the sound of it well enough, and I've wrapped it up in another abstraction so I can replace it in the future (if I decide to do that).

<img>http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/4-Reverb_HandlerB.jpg</img>

If you look into the subpatcher reverb_handler, you'll see that I expose the reverb time control to the top-level patch, but I also provide a reverb mix control that uses the pan2 abstraction found in Max's examples folder. This gives me a decent equal power pan – but why would I need to pan? In fact, I don't; but I can use them as equal power mixers as well. By using only one output of the panner, and reverse panning the live sound, I can get a decent mixing function will little effort. This may not be the most efficient processing stream, but it sure was easy to implement!

===And a Limiter at the end…===

Finally, to make sure everything stays under control, I've added a limiter to the end of the processing chain. I'm using the omx.peaklim~ object, which implements a good quality limiter. The parameters for this object are a little weird, so after some experimenting, I found a set that worked for me. These are loadbang'd into the object during startup, and never change. I also reconfigured the output section of the Presentation Mode to make everything fit a little better, but the functionality should all be familiar from previous weeks' articles.

<img>http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/4-Limiter_HandlerB.jpg</img>

==Conclusion==

This is the conclusion of new module additions, but far from the conclusion of this series. For my money, some of the most important information will be found in our next article, where we will cover preset management ('cuz I don't want to be mousing too much on-stage) and MIDI parameter controls (using my FCB-1010 foot controller). Get familiar with our new modules, and prepare for a big finale with our next Guitar Processing entry!

[[Max_Guitar_Processor,_Part_5|Click here to see the next tutorial]]

Max Guitar Processor, Part 3

2013-02-06T23:24:59Z

Gtaylor@rtqe.net:

In the last article, we added some basic tonal effects: distortion/overdrive and EQ/filtering. This time, we will expand our virtual effects rack to include both a phase shifter and a full-featured modulating digital delay. As we add these effects, you will begin to see why a DIY effects system can trump any commercial product.

[http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/GtrProc-3.maxpat.zip Download the patch used in this tutorial].

===Tutorials in this series:===

* [[Max_Guitar_Processor,_Part_1|Part 1]]
* [[Max_Guitar_Processor,_Part_2|Part 2]]
* [[Max_Guitar_Processor,_Part_3|Part 3]]
* [[Max_Guitar_Processor,_Part_4|Part 4]]
* [[Max_Guitar_Processor,_Part_5|Part 5]]

==Adding a phase shifter==

The first module I’ve added is a phase shifter. It’s a full-featured implementation, featuring a variable number of phase shift stages and a frequency spread to provide a more complicated sound. Since this is obviously a well-considered piece of work, I surely had to steal from someplace, right? Of course! Luckily, I have access to some of the Pluggo source patches, and I’ve always liked this particular phase shifter’s sound. So I opened up the patch and copied the whole thing! By placing it in a subpatcher (phasor_handler), I keep it out of my hair at the top level. About all that I added to the patch is some scaling of the inputs to help keep the control ranges sensible.

<img>http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/3-Phasor_HandlerB.jpg</img>

One of the interesting aspects of this patch is the use of the phaseshift~ object to provide the effect. Normally, a phase shift is almost imperceptible, but when the frequency is moving a classic phase shift sound is created. Stacking a few of these on top of each other (with the serial application of the onestage subpatcher) allows us to vary the depth of the effect by adding (or subtracting) phase shifting stages.

==The modulating delay==

The next module is a digital delay, complete with modulation, feedback (with filtering) and stereo enhancement. This is also the place where we go from mono processing to stereo, allowing each output to have a different (but related) delay time. The key to this is the “RHS Factor”, which determines the Right Hand Side’s delay time relative to the left side. Modest difference (like .98) will provide subtle depth, while more radical settings (like .5 or 1.5) will give rhythmic ping-pong echoes.

If we switch to the Patching Mode and open the delay_handler subpatcher, we see that most of the work is being done by a pair of tapin~/tapout~ objects and some scaling functions. Creating the modulation – which allows this module to perform flanging, chorusing and vibrato effects – is accomplished by varying the delay time. We use a cycle~ object to drive the change; but you need to note that the delay time is consistently maintained as a signal routing, rather than an event routing. This causes the delay time to change without interruption, giving us smooth delay time transitions that can be used to our advantage.

<img>http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/3-Delay_HandlerB.jpg</img>

==Dealing with the details==

As you can see in the patching view, we’ve continued our patching patterns by creating a master patch for each effect module, with controls maintained at the top-level patch. If you switch to the Presentation Mode, you will see that we’ve also maintained another pattern: using knobs (the dial object) for controls that are best set by ear, and number boxes for controls that may need precise settings. For most people, a screen full of number boxes is confusing and intimidating – and this becomes worse when you are using a patch or program onstage. By limiting the use of number boxes to those controls that will specifically need them, you can reduce the amount of stress experienced when working with a patch.

<img>http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/3-Patch_LayoutB.jpg</img>

Since the phase shifter and delay modules take up one full “rack space” in Presentation Mode, we also want to put another level meter at the end of the rack. However, since we now have split the sound into stereo, we need to use two meters instead. This gives us a quick visual to make sure that neither the phase shifter nor the delay unit settings are causing output distortion.

<img>http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/GTR-3-1.jpg</img>

==Conclusion==

At this point, we’ve created a credible guitar processor with the most common effects in place. In our next article, we will dive into less familiar territory by taking on looping and reverb. See you then!

[[Max_Guitar_Processor,_Part_4|Click here to see the next tutorial]]

Max Guitar Processor, Part 1

2013-02-06T23:24:25Z

Gtaylor@rtqe.net:

In this series of tutorials, I will be building a Max-based guitar processing "rig", and will give you the opportunity to look over my shoulder as I design and implement this system.

'''''Note:''''' ''You may also be interested in an earlier article which appears on the Cycling '74 website by Andrew Benson and Ben Bracken titled [http://cycling74.com/2008/03/12/expand-your-guitar-vol-1/ Expand Your Guitar], which covers the basics of connecting a guitar to a Max-based processing system, includes a few guitar-oriented effects patches.''

[http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/GtrProc-1.maxpat.zip Download the patch]

===Tutorials in this series===

* [[Max_Guitar_Processor,_Part_1|Part 1]]
* [[Max_Guitar_Processor,_Part_2|Part 2]]
* [[Max_Guitar_Processor,_Part_3|Part 3]]
* [[Max_Guitar_Processor,_Part_4|Part 4]]
* [[Max_Guitar_Processor,_Part_5|Part 5]]

==Designing the System==
The first thing I did was to plan the processing chain that I would create. I wanted a rather typical guitar rig, with the addition of a looping delay line. I decided on the following functional graph:

<img>http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/1-RigDesign.jpg</img>

I also made a few decisions about general program functionality. Since this will be a stand-alone program/patch, I wouldn't worry about limiting system usage; therefore I wouldn't wrap subpatches inside of poly~ objects (to reduce their CPU load when unused). Also, I decided to take full advantage of the Max 5 Presentation Mode layout, allowing me to code in a convenient way and worry about the performance layout in a separate step.

Since I am a dyed-in-the-wool tweaker, I wanted to structure the code in such a way that I could manipulate it easily - even during live performance. This means that I needed to create an easily-to-follow patch that was well-labeled, and I needed to encapsulate at a level conducive to on-the-fly changes.

Finally, in order to build this quickly, I decided to beg, borrow or steal as much of the programming as possible without resorting to the use of VST plug-ins (which would reduce tweak-ability). Throughout these articles, you will see me reuse older code, appropriate from other applications and use third-party objects whenever necessary. I also take full advantage of some design patterns I've developed that allow for quick coding of more complex patch routings.

==Input and Gain Handling==

Since this is a stand-alone patch, we need to control our own input and output. Let's start by creating an input section. If you open the patch [http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/GtrProc-1.maxpat.zip GtrProc-1.maxpat], you will see that I have discrete patch segments that correspond to the individual functions described in my processing graph. Place the patch into Presentation Mode, and you will see that these segments jump into a "rack style" package that is easy to follow during performance.

<img>http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/1-RackLayout.jpg</img>

Move back into Patching Mode, and look at the top-left section of the patch. It is labeled "Input", and includes several controls connected to an abstraction named "input_handler". Double-click on the input_handler subpatcher to see its contents.

<img>http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/1-InputHandler.png</img>

This subpatch is pretty simple: it contains a number of adstatus objects that allow my controls to display and alter the audio settings used at runtime. The function is similar to using the DSP Status window, but exposes only those items I considered important for realtime performance. Since I don't use the adstatus object very often, I don't know the functional arguments by heart. While I could have used the documentation to learn about the object, I decided to steal the functions from the help patch instead!

By viewing the help patch, I can learn about the function of an object. However, all help patches are also functional Max patches. In this case, I was able to unlock the adstatus.maxhelp patch, copy the functional objects that I needed, then paste them into my subpatcher. By connecting a few inlets and outlets, I'd created the small and efficient input setup handler that I needed.

In addition to setting the DSP Settings, I also want to control gain at this point. This is especially important with an instrument-driven patch, since different input hardware will provide vastly different levels. In my case, I may be using an IK Multimedia StealthPlug, a mixer with an audio interface, or even a direct connection into my Mac's audio input - so I want good control of my front-end gain. I did this by adding a *~ object to the input section, then routed the input into this control. By using a scale control, I'm able to change the normal range of the gain knob (0-127) into a range that goes from 0.0 (silent) to 2.0 (double-volume).

==Compression==

The next stage of the patch is a compressor. Since compression can have a very significant effect on the sound of the instrument, I wanted detailed control over its parameters. Therefore, I am using number boxes (rather than knobs) to control the values; this gives me precise control over the compressor's operation without having to guess at a knob's output value.

<img>http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/1-KompressorB.jpg</img>

Again, this section is mostly a set of controls connected to an abstraction named "comp_handler". Double-click on this subpatcher to view its contents. This is a very simple subpatch; I've just borrowed the komp subpatcher (found in examples/effects/kompressor/lib of the Max folder) without change. I set a one parameter (lookahead) directly with a loadbang, but mostly expose the functions directly to the main patcher. Since this subpatcher is so simple, why didn't I just use komp directly in my main patch?

In the future, I may want to develop my own compressor system, or I may choose to implement the omx-based compressor included with MSP. I may even break down and use a VST compressor. In any of these cases, I would want to change the compressor "engine" without having to disturb my main patcher. By placing the compressor in a subpatch, I can change the underlying compression engine without ever having to change the top-level patch or the user interface.

This is a "high detail" compressor, giving me the kind of control I want for a flexible rig. If you aren't that familiar with compression, though, it may seem a little intimidating. Here are a few settings that I've found useful with this processor:

<img>http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/1-table.jpg</img>

 (Sidebar) In each of the processing areas, you will see a small grey panel - it doesn't seem to do anything. However, when you switch into Presentation Mode, you should see these panels expand to become the background of the individual processing sections. This is an example of using the Presentation Mode's ability to change an object's geometry to keep my patching view clean, but give me an attractive user interface.

==Output Staging==

The final processing section for this tutorial controls the output. This section will be familiar to any Max/MSP programmer - it's the basis for audio output in almost any audio patch. The output of the compressor is sent to the two faders, which provide left/right volume control. The signal is then routed to an EZDAC~, which is also our DSP on/off control. If you have your guitar (or other instrument) plugged into the computer, you can check the settings on the input module, turn on the DSP, turn up the volume and hear your instrument through the patch.

<img>http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/1-OutputStuff.png</img>

However, it's not always convenient to test with an actual instrument. For example, some of this patch was done while I was waiting in an airport. The last thing the PSA wants to see is for me to pull out a guitar and start wailing. What I've done is to include a "test fixture" - some standard audio generating code - that I can use to test the patch as it is being built. You will notice that this section (labeled "test fixture") gives me the opportunity to load and play a file or to generate noise. This is a small bit of code I've copied from another patch of mine - I use it as a test fixture for almost every audio patch I write.

The output of this fixture is routed to a send~ object labeled "test". This audio is received in the input section, at the same point that my patch would see an instrument from the audio input. This way, I can test patches without having an instrument plugged in, helping me to be productive when the guitar isn't easily available.

==Conclusion==

We've created the basic I/O blocks for our performance patch. In the next article, we will expand it by adding a good-sounding distortion/overdrive system and a highly controllable filter/EQ. In the meantime, work with this basic patch, learn to understand the routing between the objects and explore the use of the compressor. Until next time - have fun!

[[Max_Guitar_Processor,_Part_2|Click here to see the next tutorial]]

Max Guitar Processor, Part 2

2013-02-06T23:23:35Z

Gtaylor@rtqe.net:

In the last article, we did a lot of setup - we got input/output handling in place, and added a compressor to the processing chain as an example of an “effect module”. In this article, we will continue adding effects, including a dual overdrive module and a three-stage EQ/Filter module. With these additions we will further explore Max 5’s user interface options, as well as taking a look at some of the “tweaks” that make Max/MSP functions a little more guitar-faithful.

[http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/GtrProc-2.maxpat.zip Download the patch used in this tutorial].

===Tutorials in this series:===

* [[Max_Guitar_Processor,_Part_1|Part 1]]
* [[Max_Guitar_Processor,_Part_2|Part 2]]
* [[Max_Guitar_Processor,_Part_3|Part 3]]
* [[Max_Guitar_Processor,_Part_4|Part 4]]
* [[Max_Guitar_Processor,_Part_5|Part 5]]

==Adding an Overdrive Section==

First up is an overdrive processor. I’ve found that the way to get the most variety with this sort of processor is to have two overdrive~ objects in series with a lowpass filter between them; the result is a controllable distortion/overdrive capable of some crazy variations. I have, again, encapsulated the overdrive functions in a subpatcher (in this case, called od_handler), which implements the dual overdrive~ setup, as well as a selector~ that provides the bypass functionality.

<img>http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/OD_HandlerB.jpg</img>

I’ve also added a level adjustment that allows us to tame the output levels post-overdrive~. This can be very handy, since some of the more extreme overdrive settings can cause high levels (both real and perceived). I’ve also connected a meter~ object to the output of the subpatcher, giving me a way to eyeball the output of the compressor-overdrive combination.

==Adding an EQ/Filter==

Next up is the creation of a EQ/Filter modules. This is going to use the cascade~ filter, which is a version of a biquad filter that takes lists of coefficients to create a complex filter curve. In order to control it with simplified controls, we will use a function of the filtergraph~ object that converts frequency/level combinations into biquad-type coefficients.

By now, you should be able to see the design pattern in use: I create a subpatcher with the “guts” of the effect module, then attach controls for all of the variable parameters. Open the “filter_handler” subpatcher to examine the DSP funtions used. Most of this subpatcher converts the incoming values into useful frequency and level values, then sending them into filtergraph~ objects. I could have just as easily used filtercoeff~ objects, but using the filtergraph~ lets me see the individual filter settings, helping me verify that the individual filter parameters are being set correctly. The coefficient outputs of the filtergraph~ objects are “pak’d” into a list of 15 floating point values (five for each filter), then prepended with the cascade message. This informs connected filter objects that more than one coefficient set will be used to create a complex filter.

<img>http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/Filter_HandlerB.jpg</img>

This list is now sent to a cascade~ object, which implements the equivalent of serial biquad filters that implement the cascaded filter settings. This could just as easily be implemented as several biquad~ objects, but using the single cascade~ object allows us to keep the signal count down.

An important addition to this subpatcher is filter clearing. Biquad filters are based on delay lines that can occasionally get overloaded. In these cases, the filter is “blown”, and will not produce any output. The easiest way to fix a blown filter is to send it a clear message, but the downside is that it resets all of the filter coefficients, but doesn’t update any of the user interface elements that control the filter. So, in this case, when we receive a message in the “clear filters” inlet, it not only sends a clear message to the cascade object, but also sends a bang to receivers of the “fil_clear” send object.

There is only one receiver of fil_clear: a receive object embedded in the subpatcher called “filter_clearer”. This simply resets all of the user interface elements to default values, providing visual feedback of the filter’s newly cleared state. It is important to implement a function like this whenever you are working with MSP filters, since blowing a filter is a common problem when experimenting with extreme filter settings.

==In Review==

Put the patch into Presentation Mode, and you will see that I’ve reordered the modules to maintain the row-column orientation of the signal flow. I’ve also added level meters at the end of each row. This is something that I’ve learned to do for performance patches - to place meters in strategic places, helping me to see “where” something is wrong when something goes wrong. As this patch develops, we will place a meter at the end of each row, combining useful debugging information with a cool, flashy display.

<img>http://1cyjknyddcx62agyb002-web-assets.s3.amazonaws.com/Screen-1.jpg</img>

I also decided to make the visual EQ/Filter display very large in Performance Mode. This helps me see the result of subtle changes, and gives a better visual indication in the heat of battle. If you want to create and add modules of your own, you might want to make this part of the patch a little smaller - but be careful, since the EQ module can have a pretty drastic effect on your sound, and you will want as much control as possible.

With the addition of the overdrive and EQ/Filter units, we have created tools to sculpt the sound of the guitar. Next, we will add a few more “effect-y” modules, including a smooth phaser and a modulating delay line. Until then, have fun with our new modules, and try to make some of your own using some of the techniques we’ve developed.

[[Max_Guitar_Processor,_Part_3|Click here to see the next tutorial]]

Max Guitar Processor, Part 2

2013-02-06T23:22:42Z

Gtaylor@rtqe.net:

Tutorials: A Max Guitar Processor

2013-02-06T21:13:38Z

Gtaylor@rtqe.net:

Take a look over [http://cycling74.com/author/ddgcycling74com/ Darwin Grosse's] shoulder as he builds a Max-based guitar processing patch that includes modules for compression, gain/overdrive, filtering/EQ, a phasor, a modulating digital delay, looping, reverb, and MIDI control.

* [[Max_Guitar_Processor,_Part_1|Max_Guitar_Processor, Part 1]]
* [[Max_Guitar_Processor,_Part_2|Max_Guitar_Processor, Part 2]]
* [[Max_Guitar_Processor,_Part_3|Max_Guitar_Processor, Part 3]]
* [[Max_Guitar_Processor,_Part_4|Max_Guitar_Processor, Part 4]]
* [[Max_Guitar_Processor,_Part_5|Max_Guitar_Processor, Part 5]]

[[Category:MaxTopics]]

Tutorials: A Max Guitar Processor

2013-02-06T21:13:09Z

Gtaylor@rtqe.net: Created page with "Have a look over [http://cycling74.com/author/ddgcycling74com/ Darwin Grosse's] shoulder as he builds a Max-based guitar processing patch that includes modules for compression..."

Have a look over [http://cycling74.com/author/ddgcycling74com/ Darwin Grosse's] shoulder as he builds a Max-based guitar processing patch that includes modules for compression, gain/overdrive, filtering/EQ, a phasor, a modulating digital delay, looping, reverb, and MIDI control.

* [[Max_Guitar_Processor,_Part_1|Max_Guitar_Processor, Part 1]]
* [[Max_Guitar_Processor,_Part_2|Max_Guitar_Processor, Part 2]]
* [[Max_Guitar_Processor,_Part_3|Max_Guitar_Processor, Part 3]]
* [[Max_Guitar_Processor,_Part_4|Max_Guitar_Processor, Part 4]]
* [[Max_Guitar_Processor,_Part_5|Max_Guitar_Processor, Part 5]]

[[Category:MaxTopics]]

Max Guitar Processor, Part 5

2013-02-06T19:44:04Z

2012-11-22T16:39:40Z

Gtaylor@rtqe.net: /* People and Places */

__NOTOC__
[[Category:Courses]]

Welcome to the Cycling '74 Wiki - a place where we will be working alongside you to shape and maintain a repository of useful information about Max, MSP, and Jitter. As a quick look around will suggest, it’s in process - pages and sections are appearing/under development, and being expanded. Since this Wiki is a work in progress, your help is going to be essential in terms of defining both the content and form for the Wiki. So consider this a call to action – what is it about Max, MSP or Jitter that you value and know about? The [[Editing_QuickStart|Editing QuickStart]] page will help you get started. Those who come after you will thank you as we thank you now. Onward!

== All About Max ==
Learn more about Max, MSP and Jitter.
<categorytree mode=pages hideroot=on>Max</categorytree>

== Max and Technology ==
Using specific technologies within the Max environment
<categorytree mode=pages hideroot=on>MaxAnd</categorytree>

== Max Interfaces ==
Using Max with the rest of the world
<categorytree mode=pages hideroot=on>MaxWith</categorytree>

== Topics and Techniques ==
Learning Max-specific techniques and strategies
<categorytree mode=pages hideroot=on>MaxTopics</categorytree>

== People and Places ==
Max in the real world - workshops/courses, events, and resources
<categorytree mode=pages hideroot=on>PeoplePlaces</categorytree>
[//cycling74.com/schools-that-teach-max/ Schools that teach Max]

== Do you want to write an article? ==
Here is some information that can help.

*[[Editing QuickStart]]
*[[Using Categories On This Site]]
*[//meta.wikimedia.org/wiki/Help:Contents#For_editors The MediaWiki Editor's Guide]
*[//meta.wikimedia.org/wiki/Help:Contents The MediaWiki User's Guide]

Main Page

2012-11-22T15:23:10Z

Gtaylor@rtqe.net:

__NOTOC__
[[Category:Courses]]

Welcome to the Cycling '74 Wiki - a place where we will be working alongside you to shape and maintain a repository of useful information about Max, MSP, and Jitter. As a quick look around will suggest, it’s in process - pages and sections are appearing/under development, and being expanded. Since this Wiki is a work in progress, your help is going to be essential in terms of defining both the content and form for the Wiki. So consider this a call to action – what is it about Max, MSP or Jitter that you value and know about? The [[Editing_QuickStart|Editing QuickStart]] page will help you get started. Those who come after you will thank you as we thank you now. Onward!

== All About Max ==
Learn more about Max, MSP and Jitter.
<categorytree mode=pages hideroot=on>Max</categorytree>

== Max and Technology ==
Using specific technologies within the Max environment
<categorytree mode=pages hideroot=on>MaxAnd</categorytree>

== Max Interfaces ==
Using Max with the rest of the world
<categorytree mode=pages hideroot=on>MaxWith</categorytree>

== Topics and Techniques ==
Learning Max-specific techniques and strategies
<categorytree mode=pages hideroot=on>MaxTopics</categorytree>

== People and Places ==
Max in the real world - workshops/courses, events, and resources
<categorytree mode=pages hideroot=on>PeoplePlaces</categorytree>
*[//cycling74.com/schools-that-teach-max/ Schools that teach Max]

== Do you want to write an article? ==
Here is some information that can help.

*[[Editing QuickStart]]
*[[Using Categories On This Site]]
*[//meta.wikimedia.org/wiki/Help:Contents#For_editors The MediaWiki Editor's Guide]
*[//meta.wikimedia.org/wiki/Help:Contents The MediaWiki User's Guide]

Main Page

2012-11-22T15:21:16Z

Gtaylor@rtqe.net:

__NOTOC__
[[Category:Courses]]

Welcome to the Cycling '74 Wiki - a place where we will be working alongside you to shape and maintain a repository of useful information about Max, MSP, and Jitter. As a quick look around will suggest, it’s in process - pages and sections are appearing/under development, and being expanded. Since this Wiki is a work in progress, your help is going to be essential in terms of defining both the content and form for the Wiki. So consider this a call to action – what is it about Max, MSP or Jitter that you value and know about? The Editing QuickStart page will help you get started. Those who come after you will thank you as we thank you now. Onward!

== All About Max ==
Learn more about Max, MSP and Jitter.
<categorytree mode=pages hideroot=on>Max</categorytree>

== Max and Technology ==
Using specific technologies within the Max environment
<categorytree mode=pages hideroot=on>MaxAnd</categorytree>

== Max Interfaces ==
Using Max with the rest of the world
<categorytree mode=pages hideroot=on>MaxWith</categorytree>

== Topics and Techniques ==
Learning Max-specific techniques and strategies
<categorytree mode=pages hideroot=on>MaxTopics</categorytree>

== People and Places ==
Max in the real world - workshops/courses, events, and resources
<categorytree mode=pages hideroot=on>PeoplePlaces</categorytree>
*[//cycling74.com/schools-that-teach-max/ Schools that teach Max]

== Do you want to write an article? ==
Here is some information that can help.

*[[Editing QuickStart]]
*[[Using Categories On This Site]]
*[//meta.wikimedia.org/wiki/Help:Contents#For_editors The MediaWiki Editor's Guide]
*[//meta.wikimedia.org/wiki/Help:Contents The MediaWiki User's Guide]