Opcode Quick Reference

Orchestra Syntax:Header

0dbfs= iarg
0dbfs

A4= iarg

kr= iarg

ksmps= iarg

nchnls= iarg

nchnls_i= iarg

sr= iarg

Orchestra Syntax:Block Statements

endin

endop

instri, j, ...

opcodename, outtypes, intypes

Orchestra Syntax:Macros

$NAME

#defineNAME # replacement text #
#define NAME(a' b' c') # replacement text #

#ifdefNAME
....
#else
....
#end

#ifndefNAME
....
#else
....
#end

#include"filename"
#includestr "filename"

#undefNAME

Signal Generators:Additive Synthesis/Resynthesis

ares =adsyn(kamod, kfmod, ksmod, ifilcod)

ares =adsynt(kamp, kcps, iwfn, ifreqfn, iampfn, icnt [, iphs])

ar =adsynt2(kamp, kcps, iwfn, ifreqfn, iampfn, icnt [, iphs])

ares =hsboscil(kamp, ktone, kbrite, ibasfreq, iwfn, ioctfn \
    [, ioctcnt] [, iphs])

Signal Generators:Basic Oscillators

kres =lfo(kamp, kcps [, itype])
ares = lfo(kamp, kcps [, itype])

ares =oscbnk(kcps, kamd, kfmd, kpmd, iovrlap, iseed, kl1minf, kl1maxf, \
    kl2minf, kl2maxf, ilfomode, keqminf, keqmaxf, keqminl, keqmaxl, \
    keqminq, keqmaxq, ieqmode, kfn [, il1fn] [, il2fn] [, ieqffn] \
    [, ieqlfn] [, ieqqfn] [, itabl] [, ioutfn])

ares =oscil(xamp, xcps [, ifn, iphs])
kres = oscil(kamp, kcps [, ifn, iphs])

ares =oscil3(xamp, xcps [, ifn, iphs])
kres = oscil3(kamp, kcps [, ifn, iphs])

ares =oscili(xamp, xcps[, ifn, iphs])
kres = oscili(kamp, kcps[, ifn, iphs])

ares =oscilikt(xamp, xcps, kfn [, iphs] [, istor])
kres = oscilikt(kamp, kcps, kfn [, iphs] [, istor])

ares =osciliktp(kcps, kfn, kphs [, istor])

ares =oscilikts(xamp, xcps, kfn, async, kphs [, istor])

ares =osciln(kamp, ifrq, ifn, itimes)

ares =oscils(iamp, icps, iphs [, iflg])

ares =poscil(aamp, acps [, ifn, iphs])
ares = poscil(aamp, kcps [, ifn, iphs])
ares = poscil(kamp, acps [, ifn, iphs])
ares = poscil(kamp, kcps [, ifn, iphs])
ires = poscil(kamp, kcps [, ifn, iphs])
kres = poscil(kamp, kcps [, ifn, iphs])

ares =poscil3(aamp, acps [, ifn, iphs])
ares = poscil3(aamp, kcps [, ifn, iphs])
ares = poscil3(kamp, acps [, ifn, iphs])
ares = poscil3(kamp, kcps [, ifn, iphs])
ires = poscil3(kamp, kcps [, ifn, iphs])
kres = poscil3(kamp, kcps [, ifn, iphs])

kout =vibr(kAverageAmp, kAverageFreq, ifn)

kout =vibrato(kAverageAmp, kAverageFreq, kRandAmountAmp, kRandAmountFreq, \
    kAmpMinRate, kAmpMaxRate, kcpsMinRate, kcpsMaxRate, ifn [, iphs])

Signal Generators:Dynamic Spectrum Oscillators

ares =buzz(xamp, xcps, knh, ifn [, iphs])

ares =gbuzz(xamp, xcps, knh, klh, kmul, ifn [, iphs])

ares =mpulse(kamp, kintvl [, ioffset])

aout [, asyncout] =squinewave(acps, aClip, aSkew, asyncin [, iMinSweep] [, iphase])
aout [, asyncout] = squinewave(acps, aClip, aSkew [, ksyncin] [, iMinSweep] [, iphase])

ares =vco(xamp, xcps, iwave, kpw [, ifn] [, imaxd] [, ileak] [, inyx] \
    [, iphs] [, iskip])

ares =vco2(kamp, kcps [, imode] [, kpw] [, kphs] [, inyx])

kfn =vco2ft(kcps, iwave [, inyx])

ifn =vco2ift(icps, iwave [, inyx])

ifn =vco2init(iwave [, ibasfn] [, ipmul] [, iminsiz] [, imaxsiz] [, isrcft])

Signal Generators:FM Synthesis

a1, a2 =crossfm(xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2])
a1, a2 = crossfmi(xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2])
a1, a2 = crosspm(xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2])
a1, a2 = crosspmi(xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2])
a1, a2 = crossfmpm(xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2])
a1, a2 = crossfmpmi(xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2])

ares =fmb3(kamp, kfreq, kc1, kc2, kvdepth, kvrate[, ifn1, ifn2, ifn3, \
    ifn4, ivfn])

ares =fmbell(kamp, kfreq, kc1, kc2, kvdepth, kvrate[, ifn1, ifn2, ifn3, \
    ifn4, ivfn, isus])

ares =fmmetal(kamp, kfreq, kc1, kc2, kvdepth, kvrate, ifn1, ifn2, ifn3, \
    ifn4, ivfn)

ares =fmpercfl(kamp, kfreq, kc1, kc2, kvdepth, kvrate[, ifn1, ifn2, \
    ifn3, ifn4, ivfn])

ares =fmrhode(kamp, kfreq, kc1, kc2, kvdepth, kvrate, ifn1, ifn2, \
    ifn3, ifn4, ivfn)

ares =fmvoice(kamp, kfreq, kvowel, ktilt, kvibamt, kvibrate[, ifn1, \
    ifn2, ifn3, ifn4, ivibfn])

ares =fmwurlie(kamp, kfreq, kc1, kc2, kvdepth, kvrate, ifn1, ifn2, ifn3, \
    ifn4, ivfn)

ares =foscil(xamp, kcps, xcar, xmod, kndx [, ifn , iphs])

ares =foscili(xamp, kcps, xcar, xmod, kndx [, ifn, iphs])

Signal Generators:Granular Synthesis

asig =diskgrain(Sfname, kamp, kfreq, kpitch, kgrsize, kprate, \
    ifun, iolaps [,imaxgrsize , ioffset])

ares =fof(xamp, xfund, xform, koct, kband, kris, kdur, kdec, iolaps, \
    ifna, ifnb, itotdur [, iphs] [, ifmode] [, iskip])

ares =fof2(xamp, xfund, xform, koct, kband, kris, kdur, kdec, iolaps, \
    ifna, ifnb, itotdur, kphs, kgliss [, iskip])

ares =fog(xamp, xdens, xtrans, aspd, koct, kband, kris, kdur, kdec, \
    iolaps, ifna, ifnb, itotdur [, iphs] [, itmode] [, iskip])

ares =grain(xamp, xpitch, xdens, kampoff, kpitchoff, kgdur, igfn, \
    iwfn, imgdur [, igrnd])

ares =grain2(kcps, kfmd, kgdur, iovrlp, kfn, iwfn [, irpow] \
    [, iseed] [, imode])

ares =grain3(kcps, kphs, kfmd, kpmd, kgdur, kdens, imaxovr, kfn, iwfn, \
    kfrpow, kprpow [, iseed] [, imode])

ares =granule(xamp, ivoice, iratio, imode, ithd, ifn, ipshift, igskip, \
    igskip_os, ilength, kgap, igap_os, kgsize, igsize_os, iatt, idec \
    [, iseed] [, ipitch1] [, ipitch2] [, ipitch3] [, ipitch4] [, ifnenv])

a1 [, a2, a3, a4, a5, a6, a7, a8] =partikkel(agrainfreq, \
    kdistribution, idisttab, async, kenv2amt, ienv2tab, ienv_attack, \
    ienv_decay, ksustain_amount, ka_d_ratio, kduration, kamp, igainmasks, \
    kwavfreq, ksweepshape, iwavfreqstarttab, iwavfreqendtab, awavfm, \
    ifmamptab, kfmenv, icosine, ktraincps, knumpartials, kchroma, \
    ichannelmasks, krandommask, kwaveform1, kwaveform2, kwaveform3, \
    kwaveform4, iwaveamptab, asamplepos1, asamplepos2, asamplepos3, \
    asamplepos4, kwavekey1, kwavekey2, kwavekey3, kwavekey4, imax_grains \
    [, iopcode_id, ipanlaws])

kindex =partikkelget(kparameterindex, iopcode_id)

partikkelset(kparameterindex, kmaskindex, iopcode_id)

async [,aphase] =partikkelsync(iopcode_id)

ares [, ac] =sndwarp(xamp, xtimewarp, xresample, ifn1, ibeg, iwsize, \
    irandw, ioverlap, ifn2, itimemode)

ar1, ar2 [,ac1] [, ac2] =sndwarpst(xamp, xtimewarp, xresample, ifn1, \
    ibeg, iwsize, irandw, ioverlap, ifn2, itimemode)

asig =syncgrain(kamp, kfreq, kpitch, kgrsize, kprate, ifun1, ifun2, iolaps)

asig =syncloop(kamp, kfreq, kpitch, kgrsize, kprate, klstart, \
    klend, ifun1, ifun2, iolaps[,istart, iskip])

ar =vosim(kamp, kFund, kForm, kDecay, kPulseCount, kPulseFactor, ifn [, iskip])

Signal Generators:Hyper Vectorial Synthesis

hvs1(kx, inumParms, inumPointsX, iOutTab, iPositionsTab, iSnapTab [, iConfigTab])

hvs2(kx, ky, inumParms, inumPointsX, inumPointsY, iOutTab, iPositionsTab, \
    iSnapTab [, iConfigTab])

hvs3(kx, ky, kz, inumParms, inumPointsX, inumPointsY, inumPointsZ, iOutTab, \
    iPositionsTab, iSnapTab [, iConfigTab])

Signal Generators:Linear and Exponential Generators

ky =bpf(kx, kx1, ky1, kx2, ..., kxn, kyn)
iy = bpf(ix, ix1, iy1, ix2, ..., ixn, iyn)
kys[] = bpf(kxs[], kx1, ky1, kx2, ..., kxn, kyn)
iys[] = bpf(ixs[], ix1, iy1, ix2, ..., ixn, iyn)
ky = bpf(kx, kxs[], kys[])
iy = bpf(ix, ixs[], iys[])
ay = bpf(ax, kx1, ky1, kx2, ..., kxn, kyn)
ay = bpf(ax, kxs[], kys[])
ky, kw = bpf(kx, kxs[], kys[], kws[])

ky =bpfcos(kx, kx1, ky1, kx2, ..., kxn, kyn)
kys[] = bpfcos(kxs[], kx1, ky1, kx2, ..., kxn, kyn)
ky = bpfcos(kx, kxs[], kys[])
ky = bpfcos(kx, ixs[], iys[])
ky, kz = bpfcos(kx, kxs[], kys[], kzs[])
ky, kz = bpfcos(kx, ixs[], iys[], izs[])

ares =cosseg(ia, idur1, ib [, idur2] [, ic] [...])
kres = cosseg(ia, idur1, ib [, idur2] [, ic] [...])

ares =cossegb(ia, itim1, ib [, itim2] [, ic] [...])
kres = cossegb(ia, itim1, ib [, itim2] [, ic] [...])

ares =cossegr(ia, idur1, ib [, idur2] [, ic] [...], irel, iz)
kres = cossegr(ia, idur1, ib [, idur2] [, ic] [...], irel, iz)

kout =expcurve(kindex, ksteepness)

ares =expon(ia, idur, ib)
kres = expon(ia, idur, ib)

ares =expseg(ia, idur1, ib [, idur2] [, ic] [...])
kres = expseg(ia, idur1, ib [, idur2] [, ic] [...])

ares =expsega(ia, idur1, ib [, idur2] [, ic] [...])

ares =expsegb(ia, itim1, ib [, itim2] [, ic] [...])
kres = expsegb(ia, itim1, ib [, itim2] [, ic] [...])

ares =expsegba(ia, itim1, ib [, itim2] [, ic] [...])

ares =expsegr(ia, idur1, ib [, idur2] [, ic] [...], irel, iz)
kres = expsegr(ia, idur1, ib [, idur2] [, ic] [...], irel, iz)

kout =gainslider(kindex)

ky =lincos(kx, ky0, ky1 [, kx0, kx1 ])
iy = lincos(ix, iy0, iy1 [, ix0, ix1 ])

ares =line(ia, idur, ib)
kres = line(ia, idur, ib)

ky =linlin(kx, ky0, ky1 [, kx0, kx1 ])
iy = linlin(ix, iy0, iy1 [, ix0, ix1 ])
kys[] = linlin(kxs[], ky0, ky1 [, kx0, kx1 ])
iys[] = linlin(ixs[], ky0, ky1, [ kx0, kx1 ])
kC[] = linlin(kx, kA[], kB[] [, kx0, kx1 ])

ares =linseg(ia, idur1, ib [, idur2] [, ic] [...])
kres = linseg(ia, idur1, ib [, idur2] [, ic] [...])

ares =linsegb(ia, itim1, ib [, itim2] [, ic] [...])
kres = linsegb(ia, itim1, ib [, itim2] [, ic] [...])

ares =linsegr(ia, idur1, ib [, idur2] [, ic] [...], irel, iz)
kres = linsegr(ia, idur1, ib [, idur2] [, ic] [...], irel, iz)

kout =logcurve(kindex, ksteepness)

ksig =loopseg(kfreq, ktrig, iphase, kvalue0, ktime0 [, kvalue1] [, ktime1] \
    [, kvalue2] [, ktime2][...])

ksig =loopsegp(kphase, kvalue0, kdur0, kvalue1 \
    [, kdur1, ... , kdurN-1, kvalueN])

ksig =looptseg(kfreq, ktrig, iphase, kvalue0, ktype0, ktime0, [, kvalue1] \
    [,ktype1] [, ktime1] [, kvalue2] [,ktype2] [, ktime2] [...] \
    [, kvalueN] [,ktypeN] [, ktimeN])

ksig =loopxseg(kfreq, ktrig, iphase, kvalue0, ktime0 [, kvalue1] [, ktime1] \
    [, kvalue2] [, ktime2] [...])

ksig =lpshold(kfreq, ktrig, iphase, kvalue0, ktime0 [, kvalue1] [, ktime1] \
    [, kvalue2] [, ktime2] [...])

ksig =lpsholdp(kphase, kvalue0, ktime0 [, kvalue1] [, ktime1] \
    [, kvalue2] [, ktime2] [...])

kscl =scale(kinput, kmax, kmin[, kimax, kimin])

kscl =scale2(kinput, kmin, kmax[, kimin, kimax][ihtime])

ares =transeg(ia, idur, itype, ib [, idur2] [, itype] [, ic] ...)
kres = transeg(ia, idur, itype, ib [, idur2] [, itype] [, ic] ...)

ares =transegb(ia, itim, itype, ib [, itim2] [, itype] [, ic] ...)
kres = transegb(ia, itim, itype, ib [, itim2] [, itype] [, ic] ...)

ares =transegr(ia, idur, itype, ib [, idur2] [, itype] [, ic] ...)
kres = transegr(ia, idur, itype, ib [, idur2] [, itype] [, ic] ...)

ares =trigexpseg(kTrig, ia, idur1, ib [, idur2] [, ic] [...])
kres = trigexpseg(kTrig, ia, idur1, ib [, idur2] [, ic] [...])

ares =triglinseg(kTrig, ia, idur1, ib [, idur2] [, ic] [...])
kres = triglinseg(kTrig, ia, idur1, ib [, idur2] [, ic] [...])

kout =xyscale(kx, ky, k00, k10, k01, k11)

Signal Generators:Envelope Generators

ares =adsr(iatt, idec, islev, irel [, idel])
kres = adsr(iatt, idec, islev, irel [, idel])

ares =envlpx(xamp, irise, idur, idec, ifn, iatss, iatdec [, ixmod])
kres = envlpx(kamp, irise, idur, idec, ifn, iatss, iatdec [, ixmod])

ares =envlpxr(xamp, irise, idec, ifn, iatss, iatdec [, ixmod] [,irind])
kres = envlpxr(kamp, irise, idec, ifn, iatss, iatdec [, ixmod] [,irind])

ares =gtadsr(asig, katt, kdec, ksus, krel, kgate)
xres = gtadsr(kamp, katt, kdec, ksus, krel, kgate)

ares =linen(xamp, irise, idur, idec)
kres = linen(kamp, irise, idur, idec)

ares =linenr(xamp, irise, idec, iatdec)
kres = linenr(kamp, irise, idec, iatdec)

ares =madsr(iatt, idec, islev, irel [, idel] [, ireltim])
kres = madsr(iatt, idec, islev, irel [, idel] [, ireltim])

ares =mxadsr(iatt, idec, islev, irel [, idel] [, ireltim])
kres = mxadsr(iatt, idec, islev, irel [, idel] [, ireltim])

ares =xadsr(iatt, idec, islev, irel [, idel])
kres = xadsr(iatt, idec, islev, irel [, idel])

Signal Generators:Models and Emulations

ares =bamboo(kamp, idettack [, inum] [, idamp] [, imaxshake] [, ifreq] \
    [, ifreq1] [, ifreq2])

ares =barmodel(kbcL, kbcR, iK, ib, kscan, iT30, ipos, ivel, iwid)

ares =cabasa(iamp, idettack [, inum] [, idamp] [, imaxshake])

ares =crunch(iamp, idettack [, inum] [, idamp] [, imaxshake])

ares =dripwater(kamp, idettack [, inum] [, idamp] [, imaxshake] [, ifreq] \
    [, ifreq1] [, ifreq2])

kfl =fareylen(kfn)

ifl =fareyleni(ifn)

ares =gendy(kamp, kampdist, kdurdist, kadpar, kddpar, kminfreq, kmaxfreq, \
    kampscl, kdurscl [, initcps] [, knum])
kres = gendy(kamp, kampdist, kdurdist, kadpar, kddpar, kminfreq, kmaxfreq, \
    kampscl, kdurscl [, initcps] [, knum])

ares =gendyc(kamp, kampdist, kdurdist, kadpar, kddpar, kminfreq, kmaxfreq, \
    kampscl, kdurscl [, initcps] [, knum])
kres = gendyc(kamp, kampdist, kdurdist, kadpar, kddpar, kminfreq, kmaxfreq, \
    kampscl, kdurscl [, initcps] [, knum])

ares =gendyx(kamp, kampdist, kdurdist, kadpar, kddpar, kminfreq, kmaxfreq, \
    kampscl, kdurscl, kcurveup, kcurvedown [, initcps] [, knum])
kres = gendyx(kamp, kampdist, kdurdist, kadpar, kddpar, kminfreq, kmaxfreq, \
    kampscl, kdurscl, kcurveup, kcurvedown [, initcps] [, knum])

ares =gogobel(kamp, kfreq, ihrd, ipos, imp, kvibf, kvamp, ivfn)

ares =guiro(kamp, idettack [, inum] [, idamp] [, imaxshake] [, ifreq] [, ifreq1])

ax, ay, az =lorenz(ksv, krv, kbv, kh, ix, iy, iz, iskip [, iskipinit])

kiter, koutrig =mandel( ktrig, kx, ky, kmaxIter)

ares =mandol(kamp, kfreq, kpluck, kdetune, kgain, ksize \
    [, ifn] [, iminfreq])

ares =marimba(kamp, kfreq, ihrd, ipos, imp, kvibf, kvamp, ivibfn, idec \
    [, idoubles] [, itriples])

ares =moog(kamp, kfreq, kfiltq, kfiltrate, kvibf, kvamp, iafn, iwfn, ivfn)

ax, ay, az =planet(kmass1, kmass2, ksep, ix, iy, iz, ivx, ivy, ivz, idelta \
    [, ifriction] [, iskip])

ares =prepiano(ifreq, iNS, iD, iK, iT30, iB, kbcl, kbcr, imass, ihvfreq, \
    iinit, ipos, ivel, isfreq, isspread[, irattles, irubbers])
al, ar = prepiano(ifreq, iNS, iD, iK, iT30, iB, kbcl, kbcr, imass, ihvfreq, \
    iinit, ipos, ivel, isfreq, isspread[, irattles, irubbers])

ares =sandpaper(iamp, idettack [, inum] [, idamp] [, imaxshake])

ares =sekere(iamp, idettack [, inum] [, idamp] [, imaxshake])

ares =shaker(kamp, kfreq, kbeans, kdamp, ktimes [, idecay])

ares =sleighbells(kamp, idettack [, inum] [, idamp] [, imaxshake] [, ifreq] \
    [, ifreq1] [, ifreq2])

ares =stix(iamp, idettack [, inum] [, idamp] [, imaxshake])

ares =tambourine(kamp, idettack [, inum] [, idamp] [, imaxshake] [, ifreq] \
    [, ifreq1] [, ifreq2])

ares =vibes(kamp, kfreq, ihrd, ipos, imp, kvibf, kvamp, ivibfn, idec)

ares =voice(kamp, kfreq, kphoneme, kform, kvibf, kvamp, ifn, ivfn)

Signal Generators:Phasors

aexp,aph =ephasor(kfreq, kR)

ares =phasor(xcps [, iphs])
kres = phasor(kcps [, iphs])

ares =phasorbnk(xcps, kndx, icnt [, iphs])
kres = phasorbnk(kcps, kndx, icnt [, iphs])

aphase, asyncout =syncphasor(xcps, asyncin, [, iphs])

aindex =trigphasor(xtrig, xrate, kstart, kend [, kresetPos])
kindex = trigphasor(xtrig, xrate, kstart, kend [, kresetPos])

Signal Generators:Random (Noise) Generators

ares =betarand(krange, kalpha, kbeta)
ires = betarand(krange, kalpha, kbeta)
kres = betarand(krange, kalpha, kbeta)

ares =bexprnd(krange)
ires = bexprnd(krange)
kres = bexprnd(krange)

ares =cauchy(kalpha)
ires = cauchy(kalpha)
kres = cauchy(kalpha)

ares =cauchyi(klambda, xamp, xcps)
ires = cauchyi(klambda, xamp, xcps)
kres = cauchyi(klambda, xamp, xcps)

aout =cuserrnd(kmin, kmax, ktableNum)
iout = cuserrnd(imin, imax, itableNum)
kout = cuserrnd(kmin, kmax, ktableNum)

aout =duserrnd(ktableNum)
iout = duserrnd(itableNum)
kout = duserrnd(ktableNum)

ares =dust(kamp, kdensity)
kres = dust(kamp, kdensity)

ares =dust2(kamp, kdensity)
kres = dust2(kamp, kdensity)

ares =exprand(klambda)
ires = exprand(klambda)
kres = exprand(klambda)

ares =exprandi(klambda, xamp, xcps)
ires = exprandi(klambda, xamp, xcps)
kres = exprandi(klambda, xamp, xcps)

ares =fractalnoise(kamp, kbeta)

ares =gauss(krange)
ires = gauss(irange)
kres = gauss(krange)
ares = gauss(kmean, ksdev)
ires = gauss(imean, isdev)
kres = gauss(kmean, ksdev)

ares =gaussi(krange, xamp, xcps)
ires = gaussi(krange, xamp, xcps)
kres = gaussi(krange, xamp, xcps)

ares =gausstrig(kamp, kcps, kdev [, imode] [, ifrst1])
kres = gausstrig(kamp, kcps, kdev [, imode] [, ifrst1])

ians =getseed()
kans = getseed()

kout =jitter(kamp, kcpsMin, kcpsMax)

kout =jitter2(ktotamp, kamp1, kcps1, kamp2, kcps2, kamp3, kcps3[ , iopt])

ares =jspline(xamp, kcpsMin, kcpsMax)
kres = jspline(kamp, kcpsMin, kcpsMax)

knum =lfsr(ilen, iprob [, iseed])

ares =linrand(krange)
ires = linrand(krange)
kres = linrand(krange)

ares =noise(xamp, kbeta)

ares =pcauchy(kalpha)
ires = pcauchy(kalpha)
kres = pcauchy(kalpha)

ares =pinker()

ares =pinkish(xin [, imethod] [, inumbands] [, iseed] [, iskip])

ares =poisson(klambda)
ires = poisson(klambda)
kres = poisson(klambda)

ares =rand(xamp [, iseed] [, isel] [, ioffset])
kres = rand(xamp [, iseed] [, isel] [, ioffset])

ares =randc(xamp, xcps [, iseed] [, isize] [, ioffset])
kres = randc(kamp, kcps [, iseed] [, isize] [, ioffset])

ares =randh(xamp, xcps [, iseed] [, isize] [, ioffset])
kres = randh(kamp, kcps [, iseed] [, isize] [, ioffset])

ares =randi(xamp, xcps [, iseed] [, isize] [, ioffset])
kres = randi(kamp, kcps [, iseed] [, isize] [, ioffset])

ares =random(kmin, kmax)
ires = random(imin, imax)
kres = random(kmin, kmax)

ares =randomh(kmin, kmax, xcps [,imode] [,ifirstval])
kres = randomh(kmin, kmax, kcps [,imode] [,ifirstval])

ares =randomi(kmin, kmax, xcps [,imode] [,ifirstval])
kres = randomi(kmin, kmax, kcps [,imode] [,ifirstval])

ax =rnd31(kscl, krpow [, iseed])
ix = rnd31(iscl, irpow [, iseed])
kx = rnd31(kscl, krpow [, iseed])

rndseed(ival)

ares =rspline(xrangeMin, xrangeMax, kcpsMin, kcpsMax)
kres = rspline(krangeMin, krangeMax, kcpsMin, kcpsMax)

seed(ival)

kout =trandom(ktrig, kmin, kmax)

ares =trirand(krange)
ires = trirand(krange)
kres = trirand(krange)

ares =unirand(krange)
ires = unirand(krange)
kres = unirand(krange)

ax =urandom([imin, imax])
ix = urandom([imin, imax])
kx = urandom([imin, imax])

aout =urd(ktableNum)
iout = urd(itableNum)
kout = urd(ktableNum)

ares =weibull(ksigma, ktau)
ires = weibull(ksigma, ktau)
kres = weibull(ksigma, ktau)

Signal Generators:Sample Playback

a1 =bbcutm(asource, ibps, isubdiv, ibarlength, iphrasebars, inumrepeats \
    [, istutterspeed] [, istutterchance] [, ienvchoice ])

a1,a2 =bbcuts(asource1, asource2, ibps, isubdiv, ibarlength, iphrasebars, \
    inumrepeats [, istutterspeed] [, istutterchance] [, ienvchoice])

asig1[, asig2] =flooper(kamp, kpitch, istart, idur, ifad, ifn)

asig1[,asig2] =flooper2(kamp, kpitch, kloopstart, kloopend, kcrossfade, ifn \
    [, istart, imode, ifenv, iskip])

ar1 [,ar2] =loscil(xamp, kcps, ifn [, ibas] [, imod1] [, ibeg1] [, iend1] \
    [, imod2] [, ibeg2] [, iend2])
aph, ar1 [,ar2] = loscilphs(xamp, kcps, ifn [, ibas] [, imod1] [, ibeg1] \
    [, iend1] [, imod2] [, ibeg2] [, iend2])

ar1 [,ar2] =loscil3(xamp, kcps, ifn [, ibas] [, imod1] [, ibeg1] [, iend1] \
    [, imod2] [, ibeg2] [, iend2])
aph, ar1 [,ar2] = loscil3phs(xamp, kcps, ifn [, ibas] [, imod1] [, ibeg1] \
    [, iend1] [, imod2] [, ibeg2] [, iend2])

ar1 [, ar2, ar3, ar4, ar5, ar6, ar7, ar8, ar9, ar10, ar11, ar12, ar13, ar14, \
ar15, ar16] =loscilx(xamp, kcps, ifn \
    [, iwsize, ibas, istrt, imod, ibeg, iend])
ar[] = loscilx(xamp, kcps, ifn \
    [, iwsize, ibas, istrt, imod, ibeg, iend])

ares =lphasor(xtrns [, ilps] [, ilpe] [, imode] [, istrt] [, istor])

ares =lposcil(kamp, kfreqratio, kloop, kend, ifn [, iphs])

ares =lposcil3(kamp, kfreqratio, kloop, kend, ifn [, iphs])

ar =lposcila(aamp, kfreqratio, kloop, kend, ift [,iphs])

ar1, ar2 =lposcilsa(aamp, kfreqratio, kloop, kend, ift [,iphs])

ar1, ar2 =lposcilsa2(aamp, kfreqratio, kloop, kend, ift [,iphs])

sfilist(ifilhandle [, Sprintprefix])

ar1, ar2 =sfinstr(ivel, inotenum, xamp, xfreq, instrnum, ifilhandle \
    [, iflag] [, ioffset])

ar1, ar2 =sfinstr3(ivel, inotenum, xamp, xfreq, instrnum, ifilhandle \
    [, iflag] [, ioffset])

ares =sfinstr3m(ivel, inotenum, xamp, xfreq, instrnum, ifilhandle \
    [, iflag] [, ioffset])

ares =sfinstrm(ivel, inotenum, xamp, xfreq, instrnum, ifilhandle \
    [, iflag] [, ioffset])

ir =sfload("filename")

ar1, ar2 =sflooper(ivel, inotenum, kamp, kpitch, ipreindex, kloopstart, \
    kloopend, kcrossfade [, istart, imode, ifenv, iskip, iflag])

sfpassign(istartindex, ifilhandle[, imsgs])

ar1, ar2 =sfplay(ivel, inotenum, xamp, xfreq, ipreindex [, iflag] \
    [, ioffset] [, ienv])

ar1, ar2 =sfplay3(ivel, inotenum, xamp, xfreq, ipreindex [, iflag] \
    [, ioffset] [, ienv])

ares =sfplay3m(ivel, inotenum, xamp, xfreq, ipreindex [, iflag] \
    [, ioffset] [, ienv])

ares =sfplaym(ivel, inotenum, xamp, xfreq, ipreindex [, iflag] \
    [, ioffset] [, ienv])

sfplist(ifilhandle)

ir =sfpreset(iprog, ibank, ifilhandle, ipreindex)

asig, krec =sndloop(ain, kpitch, ktrig, idur, ifad)

ares =waveset(ain, krep [, ilen])

Signal Generators:Scanned Synthesis

scanhammer(isrc, idst, ipos, imult)

kpos, kvel =scanmap(iscan, kamp, kvamp [, iwhich])

ares =scans(kamp, kfreq, ifn, id [, iorder])

scansmap(kpos, kvel, iscan, kamp, kvamp [, iwhich])

aout =scantable(kamp, kpch, ipos, imass, istiff, idamp, ivel)

scanu(init, irate, ifndisplace, ifnmass, ifnmatrix, ifncentr, ifndamp, \
    kmass, kmtrxstiff, kcentr, kdamp, ileft, iright, kpos, kdisplace, \
    ain, idisp, id)

scanu2(init, irate, ifndisplace,ifnmass, ifnmatrix, ifncentr, ifndamp, \
    kmass, kmtrxstiff, kcentr, kdamp, ileft, iright, kpos, kdisplace, \
    ain, idisp, id)

Signal Generators:Table Access

kres =oscil1(idel, kamp, idur [, ifn])

kres =oscil1i(idel, kamp, idur [, ifn])

kr =tab(kndx, ifn[, ixmode])
ar = tab(xndx, ifn[, ixmode])

ir =tab_i(indx, ifn[, ixmode])

ares =table(andx, ifn [, ixmode] [, ixoff] [, iwrap])
ires = table(indx, ifn [, ixmode] [, ixoff] [, iwrap])
kres = table(kndx, ifn [, ixmode] [, ixoff] [, iwrap])

ares =table3(andx, ifn [, ixmode] [, ixoff] [, iwrap])
ires = table3(indx, ifn [, ixmode] [, ixoff] [, iwrap])
kres = table3(kndx, ifn [, ixmode] [, ixoff] [, iwrap])

ares =tablei(andx, ifn [, ixmode] [, ixoff] [, iwrap])
ires = tablei(indx, ifn [, ixmode] [, ixoff] [, iwrap])
kres = tablei(kndx, ifn [, ixmode] [, ixoff] [, iwrap])

tabw(ksig, kndx, ifn [,ixmode])
tabw(asig, andx, ifn [,ixmode])

tabw_i(isig, indx, ifn [,ixmode])

Signal Generators:Wave Terrain Synthesis

aout =sterrain(kamp, kcps, kx, ky, krx, kry, krot, ktab0, ktab1, km1, km2, \
    kn1, kn2, kn3, ka, kb, kperiod)

aout =wterrain(kamp, kpch, k_xcenter, k_ycenter, k_xradius, k_yradius, \
    itabx, itaby)

aout =wterrain2(kamp, kcps, kx, ky, krx, kry, krot, ktab0, ktab1, \
    kcurve, kcurveparam)

Signal Generators:Waveguide Physical Modeling

ares =pluck(kamp, kcps, icps, ifn, imeth [, iparm1] [, iparm2])

ares =repluck(iplk, kamp, icps, kpick, krefl, axcite)

ares =streson(asig, kfr, kfdbgain)

ares =wgbow(kamp, kfreq, kpres, krat, kvibf, kvamp [, ifn] [, iminfreq])

ares =wgbowedbar(kamp, kfreq, kpos, kbowpres, kgain [, iconst] [, itvel] \
    [, ibowpos] [, ilow])

ares =wgbrass(kamp, kfreq, ktens, iatt, kvibf, kvamp [, ifn] [, iminfreq])

ares =wgclar(kamp, kfreq, kstiff, iatt, idetk, kngain, kvibf, kvamp \
    [, ifn] [, iminfreq])

ares =wgflute(kamp, kfreq, kjet, iatt, idetk, kngain, kvibf, kvamp [, ifn] \
    [, iminfreq] [, ijetrf] [, iendrf])

ares =wgpluck(icps, iamp, kpick, iplk, idamp, ifilt, axcite)

ares =wgpluck2(iplk, kamp, icps, kpick, krefl)

Signal I/O:File I/O

dumpk(ksig, ifilname, iformat, iprd)

dumpk2(ksig1, ksig2, ifilname, iformat, iprd)

dumpk3(ksig1, ksig2, ksig3, ifilname, iformat, iprd)

dumpk4(ksig1, ksig2, ksig3, ksig4, ifilname, iformat, iprd)

ficlose(ihandle)
ficlose(Sfilename)

fin(ifilename, iskipframes, iformat, ain1 [, ain2] [, ain3] [,...])
fin(ifilename, iskipframes, iformat, arr[])

fini(ifilename, iskipframes, iformat, in1 [, in2] [, in3] [, ...])

fink(ifilename, iskipframes, iformat, kin1 [, kin2] [, kin3] [,...])

ihandle =fiopen(ifilename, imode)

fout(ifilename, iformat, aout1 [, aout2, aout3,...,aoutN])
fout(ifilename, iformat, array[])

fouti(ihandle, iformat, iflag, iout1 [, iout2, iout3,....,ioutN])

foutir(ihandle, iformat, iflag, iout1 [, iout2, iout3,....,ioutN])

foutk(ifilename, iformat, kout1 [, kout2, kout3,....,koutN])

fprintks("filename", "string", [, kval1] [, kval2] [...])

fprints("filename", "string" [, ival1] [, ival2] [...])

Sres, kline =readf(ifilname)

Sres, iline =readfi(ifilname)

kres =readk(ifilname, iformat, iprd)

kr1, kr2 =readk2(ifilname, iformat, iprd)

kr1, kr2, kr3 =readk3(ifilname, iformat, iprd)

kr1, kr2, kr3, kr4 =readk4(ifilname, iformat, iprd)

Signal I/O:Signal Input

ar1 [, ar2 [, ar3 [, ... arN]]] =diskin(ifilcod[, kpitch[, iskiptim \
    [, iwraparound[, iformat[, iskipinit]]]]])

a1[, a2[, ... aN]] =diskin2(ifilcod[, kpitch[, iskiptim \
    [, iwrap[, iformat[, iwsize[, ibufsize[, iskipinit]]]]]]])
ar1[] = diskin2(ifilcod[, kpitch[, iskiptim \
    [, iwrap[, iformat[, iwsize[, ibufsize[, iskipinit]]]]]]])

ar1 =in()
aarray = in()

ar1, ar2, ar3, ar4, ar5, ar6, ar7, ar8, ar9, ar10, ar11, ar12, ar13, ar14, \
ar15, ar16, ar17, ar18, ar19, ar20, ar21, ar22, ar23, ar24, ar25, ar26, \
ar27, ar28, ar29, ar30, ar31, ar32 =in32()

ain1[, ...] =inch(kchan1[,...])

ar1, ar2, ar3, ar4, ar5, ar6 =inh()

ar1, ar2, ar3, ar4, ar5, ar6, ar7, ar8 =ino()

ar1, ar2, ar3, a4 =inq()

inrg(kstart, ain1 [,ain2, ain3, ..., ainN])

ar1, ar2 =ins()

ivalue =invalue("channel name")
kvalue = invalue("channel name")
Sname = invalue("channel name")

ar1, ar2, ar3, ar4, ar5, ar6, ar7, ar8, ar9, ar10, ar11, ar12, \
ar13, ar14, ar15, ar16 =inx()

inz(ksig1)

ar1, ar2 =mp3in(ifilcod[, iskptim, iformat, iskipinit, ibufsize])
ar1 = mp3in(ifilcod[, iskptim, iformat, iskipinit, ibufsize])

ar1[, ar2[, ar3[, ... a24]]] =soundin(ifilcod [, iskptim] [, iformat] \
    [, iskipinit] [, ibufsize])

Signal I/O:Signal Output

mdelay(kstatus, kchan, kd1, kd2, kdelay)

aout1 [,aout2 ... aoutX] =monitor()
aarra = monitor()

out(asig1[, asig2,....])
out(aarray)

out32(asig1, asig2, asig3, asig4, asig5, asig6, asig7, asig8, asig10, \
    asig11, asig12, asig13, asig14, asig15, asig16, asig17, asig18, \
    asig19, asig20, asig21, asig22, asig23, asig24, asig25, asig26, \
    asig27, asig28, asig29, asig30, asig31, asig32)

outall(asig)

outc(asig1 [, asig2] [...])

outch(kchan1, asig1 [, kchan2] [, asig2] [...])

outh(asig1, asig2, asig3, asig4, asig5, asig6)

outo(asig1, asig2, asig3, asig4, asig5, asig6, asig7, asig8)

outq(asig1, asig2, asig3, asig4)

outq1(asig)

outq2(asig)

outq3(asig)

outq4(asig)

outrg(kstart, aout1 [,aout2, aout3, ..., aoutN])

outs(asig1, asig2)

outs1(asig)

outs2(asig)

outvalue("channel name", ivalue)
outvalue("channel name", kvalue)
outvalue("channel name", "string")

outx(asig1, asig2, asig3, asig4, asig5, asig6, asig7, asig8, \
    asig9, asig10, asig11, asig12, asig13, asig14, asig15, asig16)

outz(ksig1)

soundout(asig1, ifilcod [, iformat])

soundouts(asigl, asigr, ifilcod [, iformat])

Signal I/O:Software Bus

kval =chani(kchan)
aval = chani(kchan)

chano(kval, kchan)
chano(aval, kchan)

chn_k(Sname, imode[, itype, idflt, imin, ima, ix, iy, iwidth, iheight, Sattributes])
chn_a(Sname, imode)
chn_S(Sname, imode)
chn_S(Sname, Smode)
chn_array(Sname, imode, Stype, iSizes[])

chnclear(Sname1[, Sname2,...])

gival =chnexport(Sname, imode[, itype, idflt, imin, imax])
gkval = chnexport(Sname, imode[, itype, idflt, imin, imax])
gaval = chnexport(Sname, imode)
gSval = chnexport(Sname, imode)

ival =chnget(Sname)
kval = chnget(Sname)
aval = chnget(Sname)
Sval = chnget(Sname)
Sval = chngetks(Sname)
ival[] = chngeti(Sname[])
kval[] = chngetk(Sname[])
aval[] = chngeta(Sname[])
Sval[] = chngets(Sname[])

chnmix(aval, Sname)

itype, imode, ictltype, idflt, imin, imax =chnparams(Sname)

chnset(ival, Sname)
chnset(kval, Sname)
chnset(aval, Sname)
chnset(Sval, Sname)
chnsetks(Sval, Sname)
chnseti(ival[], []Sname)
chnsetk(kval[], []Sname)
chnseta(aval[], []Sname)
chnsets(Sval[], []Sname)

oversample(ifactor [,icvt_in, icvt_out])

setksmps(iksmps)

undersample(ifactor [,icvt_in, icvt_out])

xinarg1 [, [**xin**](opcodes/xin.md)arg2] ... [[**xin**](opcodes/xin.md)argN] [**xin**](opcodes/xin.md)

xout([**xout**](opcodes/xout.md)arg1 [, [**xout**](opcodes/xout.md)arg2] ... [, [**xout**](opcodes/xout.md)argN])

Signal I/O:Printing and Display

dispfft(xsig, iprd, iwsiz [, iwtyp] [, idbout] [, iwtflg] [,imin] [,imax])

display(xsig, iprd [, inprds] [, iwtflg])

flashtxt( iwhich, String)

print(iarg [, iarg1] [, iarg2] [...])

printf_i(Sfmt, itrig, [iarg1[, iarg2[, ... ]]])
printf(Sfmt, ktrig, [xarg1[, xarg2[, ... ]]])

printk(itime, kval [, ispace] [, inamed])

printk2(kvar [, inumspaces] [, inamed])

printks("string", itime [, xval1] [, xval2] [...])

printks2("string", kval)

println("string", [, xval1] [, xval2] [...])

prints("string" [, xval1] [, xval2] [...])

printsk("string", [, xval1] [, xval2] [...])

Signal I/O:Soundfile Queries

ir =filebit(ifilcod [, iallowraw])

ir =filelen(ifilcod, [iallowraw])

ir =filenchnls(ifilcod [, iallowraw])

ir =filepeak(ifilcod [, ichnl])

ir =filesr(ifilcod [, iallowraw])

ir =filevalid(ifilcod)
kr = filevalid(ifilcod)

ir =mp3len(ifilcod)

Signal Modifiers:Amplitude Modifiers

ares =balance(asig, acomp [, ihp] [, iskip])

ares =balance2(asig, acomp [, ihp] [, iskip])

ares =clip(asig, imeth, ilimit [, iarg])

ar =compress(aasig, acsig, kthresh, kloknee, khiknee, kratio, katt, krel, ilook)

ar =compress2(aasig, acsig, kthresh, kloknee, khiknee, kratio, katt, krel, ilook)

ares =dam(asig, kthreshold, icomp1, icomp2, irtime, iftime)

ares =gain(asig, krms [, ihp] [, iskip])

Signal Modifiers:Convolution and Morphing

ar1 [, ar2] [, ar3] [, ar4] =convolve(ain, ifilcod [, ichannel])

ares =cross2(ain1, ain2, isize, ioverlap, iwin, kbias)

ares =dconv(asig, isize, ifn)

a1[, a2[, a3[, ... a8]]] =ftconv(ain, ift, iplen[, iskipsamples \
    [, iirlen[, iskipinit]]])

ftmorf(kftndx, iftfn, iresfn)

ares =liveconv(ain, ift, iplen, kupdate, kclear)

ar1 [, ar2 [, ar3 [, ar4]]] =pconvolve(ain, ifilcod [, ipartitionsize [, ichannel]])

ares =tvconv(asig1, asig2, xfreez1, xfreez2, iparts, ifils)

Signal Modifiers:Delay

ares =delay(asig, idlt [, iskip])

ares =delay1(asig [, iskip])

kr =delayk(ksig, idel[, imode])
kr = vdel_k(ksig, kdel, imdel[, imode])

ares =delayr(idlt [, iskip])

delayw(asig)

ares =deltap(kdlt)

ares =deltap3(xdlt)

ares =deltapi(xdlt)

ares =deltapn(xnumsamps)

aout =deltapx(adel, iwsize)

deltapxw(ain, adel, iwsize)

ares =multitap(asig [, itime1, igain1] [, itime2, igain2] [...])

ares =vdelay(asig, adel, imaxdel [, iskip])

ares =vdelay3(asig, adel, imaxdel [, iskip])

aout =vdelayx(ain, adl, imd, iws [, ist])

aout1, aout2, aout3, aout4 =vdelayxq(ain1, ain2, ain3, ain4, adl, imd, iws [, ist])

aout1, aout2 =vdelayxs(ain1, ain2, adl, imd, iws [, ist])

aout =vdelayxw(ain, adl, imd, iws [, ist])

aout1, aout2, aout3, aout4 =vdelayxwq(ain1, ain2, ain3, ain4, adl, \
    imd, iws [, ist])

aout1, aout2 =vdelayxws(ain1, ain2, adl, imd, iws [, ist])

Signal Modifiers:Panning and Spatialization

ao1, ao2 =bformdec1(isetup, aw, ax, ay, az [, ar, as, at, au, av \
    [, abk, al, am, an, ao, ap, aq]])
ao1, ao2, ao3, ao4 = bformdec1(isetup, aw, ax, ay, az [, ar, as, at, au, av \
    [, abk, al, am, an, ao, ap, aq]])
ao1, ao2, ao3, ao4, ao5 = bformdec1(isetup, aw, ax, ay, az [, ar, as, at, au, av \
    [, abk, al, am, an, ao, ap, aq]])
ao1, ao2, ao3, ao4, ao5, ao6, ao7, ao8 = bformdec1(isetup, aw, ax, ay, az \
    [, ar, as, at, au, av [, abk, al, am, an, ao, ap, aq]])
aout[] = bformdec1(isetup, abform[])

aout[] =bformdec2(isetup, abform[], [idecoder, idistance, ifreq, imix, \
    ifilel, ifiler])

aw, ax, ay, az =bformenc1(asig, kalpha, kbeta)
aw, ax, ay, az, ar, as, at, au, av = bformenc1(asig, kalpha, kbeta)
aw, ax, ay, az, ar, as, at, au, av, ak, al, am, an, ao, ap, aq = bformenc1(\
    asig, kalpha, kbeta)
aarray[] = bformenc1(asig, kalpha, kbeta)

aleft, aright, irt60low, irt60high, imfp =hrtfearly(asrc, ksrcx, ksrcy, ksrcz, \
    klstnrx, klstnry, klstnrz, ifilel, ifiler, idefroom [,ifade, isr, iorder, \
    ithreed, kheadrot, iroomx, iroomy, iroomz, iwallhigh, iwalllow, \
    iwallgain1, iwallgain2, iwallgain3, ifloorhigh, ifloorlow, ifloorgain1, \
    ifloorgain2, ifloorgain3, iceilinghigh, iceilinglow, iceilinggain1, \
    iceilinggain2, iceilinggain3])

aleft, aright =hrtfer(asig, kaz, kelev, "HRTFcompact")

aleft, aright =hrtfmove(asrc, kAz, kElev, ifilel, ifiler [, imode, ifade, isr])

aleft, aright =hrtfmove2(asrc, kAz, kElev, ifilel, ifiler [,ioverlap, iradius, isr])

aleft, aright, idel =hrtfreverb(asrc, ilowrt60, ihighrt60, ifilel, ifiler \
    [,isr, imfp, iorder])

aleft, aright =hrtfstat(asrc, iAz, iElev, ifilel, ifiler [,iradius, isr])

a1, a2 =locsend()
a1, a2, a3, a4 = locsend()

a1, a2 =locsig(asig, kdegree, kdistance, kreverbsend)
a1, a2, a3, a4 = locsig(asig, kdegree, kdistance, kreverbsend)

aleft,aright =ms2st(am, as, kwidth)

a1, a2, a3, a4 =pan(asig, kx, ky, ifn [, imode] [, ioffset])

a1, a2 =pan2(asig, xp [, imode])

a1, a2, a3, a4 =space(asig, ifn, ktime, kreverbsend, kx, ky)

aW, aX, aY, aZ =spat3d(ain, kX, kY, kZ, idist, ift, imode, imdel, iovr [, istor])

aW, aX, aY, aZ =spat3di(ain, iX, iY, iZ, idist, ift, imode [, istor])

spat3dt(ioutft, iX, iY, iZ, idist, ift, imode, irlen [, iftnocl])

k1 =spdist(ifn, ktime, kx, ky)

a1, a2, a3, a4 =spsend()

am,as =st2ms(aleft,aright)

ar1[, ar2...] =vbap(asig, kazim [,kelev] [, kspread] [, ilayout])
array[] = vbap(asig, kazim [,kelev] [, kspread] [, ilayout])

ar1, ..., ar16 =vbap16(asig, kazim [, kelev] [, kspread])

ar1, ..., ar16 =vbap16move(asig, idur, ispread, ifldnum, ifld1 [, ifld2] [...])

ar1, ar2, ar3, ar4 =vbap4(asig, kazim [, kelev] [, kspread])

ar1, ar2, ar3, ar4 =vbap4move(asig, idur, ispread, ifldnum, ifld1 [, ifld2] [...])

ar1, ..., ar8 =vbap8(asig, kazim [, kelev] [, kspread])

ar1, ..., ar8 =vbap8move(asig, idur, ispread, ifldnum, ifld1 [, ifld2] [...])

k1[, k2...] =vbapg(kazim [,kelev] [, kspread] [, ilayout])
karray[] = vbapg(kazim [,kelev] [, kspread] [, ilayout])

kr1[, kr2...] =vbapgmove(idur, ispread, ifldnum, ifld1 [, ifld2] [...])
karray[] = vbapgmove(idur, ispread, ifldnum, ifld1 [, ifld2] [...])

vbaplsinit(idim, ilsnum [, idir1] [, idir2] [...] [, idir32])
vbaplsinit(idim, ilsnum, ilsarray)

ar1[, ar2...] =vbapmove(asig, idur, ispread, ifldnum, ifld1 [, ifld2] [...])
aarray[] = vbapmove(asig, idur, ispread, ifldnum, ifld1 [, ifld2] [...])

vbapz(inumchnls, istartndx, asig, kazim [, kelev] [, kspread])

vbapzmove(inumchnls, istartndx, asig, idur, ispread, ifldnum, ifld1, ifld2, [...])

Signal Modifiers:Reverberation

ares =alpass(asig, xrvt, ilpt [, iskip] [, insmps])

a1, a2 =babo(asig, ksrcx, ksrcy, ksrcz, irx, iry, irz [, idiff] [, ifno])
a1, a2 = babo2(asig, ksrcx, ksrcy, ksrcz, irx, iry, irz [, idiff] [, ifno])

ares =comb(asig, krvt, ilpt [, iskip] [, insmps])

ares =combinv(asig, krvt, ilpt [, iskip] [, insmps])

aoutL, aoutR =freeverb(ainL, ainR, kRoomSize, kHFDamp[, iSRate[, iSkip]])

ares =nestedap(asig, imode, imaxdel, idel1, igain1 [, idel2] [, igain2] \
    [, idel3] [, igain3] [, istor])

ares =nreverb(asig, ktime, khdif [, iskip] [,inumCombs] [, ifnCombs] \
    [, inumAlpas] [, ifnAlpas])

a1[, a2, ...] =platerev(itabexcite. itabouts, kbndry, iaspect, istiff, idecay, \
    iloss, aexcite1[, aexcite2, ...])

ares =reverb(asig, krvt [, iskip])

ares =reverb2(asig, ktime, khdif [, iskip] [,inumCombs] [, ifnCombs] \
    [, inumAlpas] [, ifnAlpas])

aoutL, aoutR =reverbsc(ainL, ainR, kfblvl, kfco[, israte[, ipitchm[, iskip]]])

ares =valpass(asig, krvt, xlpt, imaxlpt [, iskip] [, insmps])

ares =vcomb(asig, krvt, xlpt, imaxlpt [, iskip] [, insmps])

Signal Modifiers:Sample Level Operators

S(x) (control-rate or init-rate arg)

a(x) (control-r[**a**](opcodes/opa.md)te [**a**](opcodes/opa.md)rgs only)

denorm(a1[, a2[, a3[, ... ]]])

ares =diff(asig [, iskip])
kres = diff(ksig [, iskip])

kres =downsamp(asig [, iwlen])

ares =fold(asig, kincr)

i(x) (control-rate or [**i**](opcodes/opi.md)n[**i**](opcodes/opi.md)t-rate arg)
i(karray,index1, ...) (k-array with indices)

ares =integ(asig [, iskip])
kres = integ(ksig [, iskip])

ares =interp(ksig [, iskip] [, imode] [, ivalue])

k(x) (i-rate args only)
k(x) (a-rate args only)

ares =ntrpol(asig1, asig2, kpoint [, imin] [, imax])
ires = ntrpol(isig1, isig2, ipoint [, imin] [, imax])
kres = ntrpol(ksig1, ksig2, kpoint [, imin] [, imax])

ares =samphold(asig, agate [, ival] [, ivstor])
kres = samphold(ksig, kgate [, ival] [, ivstor])

ares =upsamp(ksig)

kval =vaget(kndx, avar)

vaset(kval, kndx, avar)

Signal Modifiers:Signal Limiters

ares =limit(asig, klow, khigh)
ires = limit(isig, ilow, ihigh)
kres = limit(ksig, klow, khigh)
ires[] = limit(isig[], ilow, ihigh)
kres[] = limit(ksig[], klow, khigh)
    )

ares =mirror(asig, klow, khigh)
ires = mirror(isig, ilow, ihigh)
kres = mirror(ksig, klow, khigh)

ares =wrap(asig, klow, khigh)
ires = wrap(isig, ilow, ihigh)
kres = wrap(ksig, klow, khigh)

Signal Modifiers:Special Effects

ar =distort(asig, kdist, ifn[, ihp, istor])

ares =distort1(asig, kpregain, kpostgain, kshape1, kshape2[, imode])

ashifted =doppler(asource, ksourceposition, kmicposition [, isoundspeed, \
    ifiltercutoff])

ares =flanger(asig, adel, kfeedback [, imaxd])

ares =harmon(asig, kestfrq, kmaxvar, kgenfreq1, kgenfreq2, imode, iminfrq, iprd)

ares =harmon2(asig, koct, kfrq1, kfrq2, icpsmode, ilowest[, ipolarity])
ares = harmon3(asig, koct, kfrq1, kfrq2, kfrq3, icpsmode, ilowest[, ipolarity])
ares = harmon4(asig, koct, kfrq1, kfrq2, kfrq3, kfrq4, icpsmode, ilowest \
    [, ipolarity])

ares =phaser1(asig, kfreq, kord, kfeedback [, iskip])

ares =phaser2(asig, kfreq, kq, kord, kmode, ksep, kfeedback)

Signal Modifiers:Standard Filters

asig =K35_hpf(ain, xcf, xQ [, inlp, isaturation, istor])

asig =K35_lpf(ain, xcf, xQ [, inlp, isaturation, istor])

ares =atone(asig, khp [, iskip])

ares =atonex(asig, khp [, inumlayer] [, iskip])
ares = atonex(asig, ahp [, inumlayer] [, iskip])

ares =biquad(asig, kb0, kb1, kb2, ka0, ka1, ka2 [, iskip])

ares =biquada(asig, ab0, ab1, ab2, aa0, aa1, aa2 [, iskip])

ares =butbp(asig, kfreq, kband [, iskip])

ares =butbr(asig, kfreq, kband [, iskip])

ares =buthp(asig, kfreq [, iskip])
ares = buthp(asig, afreq [, iskip])

ares =butlp(asig, kfreq [, iskip])
ares = butlp(asig, afreq [, iskip])

ares =butterbp(asig, xfreq, xband [, iskip])

ares =butterbr(asig, xfreq, xband [, iskip])

ares =butterhp(asig, kfreq [, iskip])
ares = butterhp(asig, afreq [, iskip])

ares =butterlp(asig, kfreq [, iskip])
ares = butterlp(asig, afreq [, iskip])

ares =clfilt(asig, kfreq, itype, inpol [, ikind] [, ipbr] [, isba] [, iskip])

asig =diode_ladder(ain, xcf, xk [, inlp, isaturation, istor])

ares =median(asig, ksize, imaxsize [, iskip])

kres =mediank(kin, ksize, imaxsize [, iskip])

aout =mode(ain, xfreq, xQ [, iskip])

ares =tone(asig, khp [, iskip])

ares =tonex(asig, khp [, inumlayer] [, iskip])
ares = tonex(asig, ahp [, inumlayer] [, iskip])

asig =zdf_1pole(ain, xcf [, kmode, istor])

alp, ahp =zdf_1pole_mode(ain, xcf [, istor])

asig =zdf_2pole(ain, xcf, xQ [, kmode, istor])

alp, abp, ahp =zdf_2pole_mode(ain, xcf, Q [, istor])

asig =zdf_ladder(ain, xcf, xQ [, istor])

Signal Modifiers:Standard Filters:Resonant

ares =areson(asig, kcf, kbw [, iscl] [, iskip])
ares = areson(asig, acf, kbw [, iscl] [, iskip])
ares = areson(asig, kcf, abw [, iscl] [, iskip])
ares = areson(asig, acf, abw [, iscl] [, iskip])

asig =bob(ain, xcf, xres, xsat [, iosamps, istor])

ares =bqrez(asig, xfco, xres [, imode] [, iskip])

ares =lowpass2(asig, kcf, kq [, iskip])

ares =lowres(asig, xcutoff, xresonance [, iskip])

ares =lowresx(asig, xcutoff, xresonance [, inumlayer] [, iskip])

ares =lpf18(asig, xfco, xres, xdist [, iskip])

asig =moogladder(ain, kcf, kres[, istor])
asig = moogladder(ain, acf, kres[, istor])
asig = moogladder(ain, kcf, ares[, istor])
asig = moogladder(ain, acf, ares[, istor])

asig =moogladder2(ain, kcf, kres[, istor])
asig = moogladder2(ain, acf, kres[, istor])
asig = moogladder2(ain, kcf, ares[, istor])
asig = moogladder2(ain, acf, ares[, istor])

ares =moogvcf(asig, xfco, xres [,iscale, iskip])

ares =moogvcf2(asig, xfco, xres [,iscale, iskip])

asig =mvchpf(ain, xcf[, istor])

asig =mvclpf1(ain, xcf, xres[,istor])

asig =mvclpf2(ain, xcf, xres[, istor])

asig =mvclpf3(ain, xcf, xres[, istor])

asig1, asig2, asig3, asig4 =mvclpf4(ain, xcf, xres[, istor])

ares =reson(asig, xcf, xbw [, iscl] [, iskip])

ares =resonr(asig, xcf, xbw [, iscl] [, iskip])

ares =resonx(asig, xcf, xbw [, inumlayer] [, iscl] [, iskip])

ares =resony(asig, kbf, kbw, inum, ksep [, isepmode] [, iscl] [, iskip])

ares =resonz(asig, xcf, xbw [, iscl] [, iskip])

ares =rezzy(asig, xfco, xres [, imode, iskip])

asig =skf(asig, xcf, xK[, ihp, istor])

asig =spf(alp,ahp,abp, xcf, xR[, istor])

ahp, alp, abp, abr =statevar(ain, xcf, xq [, iosamps, istor])

alow, ahigh, aband =svfilter(asig, kcf, kq [, iscl] [, iskip])

ahp,alp,abp,abr =svn(asig, xcf, xQ, kdrive[, ifn,inm,imx, istor])

ares =tbvcf(asig, xfco, xres, kdist, kasym [, iskip])

asig =vclpf(ain, xcf, xres[, istor])

ares =vlowres(asig, kfco, kres, iord, ksep)

Signal Modifiers:Standard Filters:Control

kres =aresonk(ksig, kcf, kbw [, iscl] [, iskip])

kres =atonek(ksig, khp [, iskip])

aout =lag(ain, k[**lag**](opcodes/lag.md)time [, initialvalue])
kout = lag(kin, klagtime [, initialvalue])

aout =lagud(ain, klagup, klagdown [, initialvalue])
kout = lagud(kin, klagup, klagdown [, initialvalue])

kres =lineto(ksig, ktime)

kres =port(ksig, ihtim [, isig])

kres =portk(ksig, khtim [, isig])

kres =resonk(ksig, kcf, kbw [, iscl] [, iskip])

kres =resonxk(ksig, kcf, kbw[, inumlayer, iscl, istor])

kres =tlineto(ksig, ktime, ktrig)

kres =tonek(ksig, khp [, iskip])

aout =trighold(ain, kdur)
kout = trighold(kin, kdur)

Signal Modifiers:Specialized Filters

ares =dcblock(ain [, igain])

ares =dcblock2(ain [, iorder] [, iskip])

asig =eqfil(ain, kcf, kbw, kgain[, istor])

ares =exciter(asig, kfreq, kceil, kharmonics, kblend)

ares =filter2(asig, ibcoefs, iacoefs, ib0, ib1, ..., ibM, ia1, ia2, ..., iaN)
kres = filter2(ksig, ibcoefs, iacoefs, ib0, ib1, ..., ibM, ia1, ia2, ..., iaN)

am, af =fmanal(are, aim)

asig =fofilter(ain, xcf, xris, xdec[, istor])

aout =gtf(ain, kfreq, idecay[, iorder, iphase])

ar1, ar2 =hilbert(asig)

ar1, ar2 =hilbert2(asig, ifftsize, ihopsize)

aout =mvmfilter(ain, xfreq, xTau [, iskip])

ares =nlfilt(ain, ka, kb, kd, kC, kL)

ares =nlfilt2(ain, ka, kb, kd, kC, kL)

ares =pareq(asig, kc, kv, kq [, imode] [, iskip])

ar =rbjeq(asig, kfco, klvl, kQ, kS[, imode])

ares =zfilter2(asig, kdamp, kfreq, iM, iN, ib0, ib1, ..., ibM, ia1,ia2, ..., iaN)

Signal Modifiers:Waveguides

ares =wguide1(asig, xfreq, kcutoff, kfeedback)

ares =wguide2(asig, xfreq1, xfreq2, kcutoff1, kcutoff2, kfeedback1, kfeedback2)

Signal Modifiers:Waveshaping

aout =chebyshevpoly(ain, k0 [, k1 [, k2 [...]]])

aout =pdclip(ain, kWidth, kCenter [, ibipolar [, ifullscale]])

aout =pdhalf(ain, kShapeAmount [, ibipolar [, ifullscale]])

aout =pdhalfy(ain, kShapeAmount [, ibipolar [, ifullscale]])

aout =powershape(ain, kShapeAmount [, ifullscale])

Signal Modifiers:Phase Shaping

avp =vps(aph,kd,kv)

Signal Modifiers:Comparators and Accumulators

aout =cmp(a1, S_operator, a2)
aout = cmp(a1, S_operator, kb)
kOut[] = cmp(kA[], S_operator, kb)
kOut[] = cmp(kA[], S_operator, kB[])
kOut[] = cmp(k1, S_operator1, kIn[], S_operator2, k2)

amax= [**max**](opcodes/max.md)(ain1, ain2 [, ain3] [, ain4] [...])
kmax = max(kin1, kin2 [, kin3] [, kin4] [...])
imax = max(iin1, iin2 [, iin3] [, iin4] [...])

knumkout =max_k(asig, ktrig, itype)

amax =maxabs(ain1, ain2 [, ain3] [, ain4] [...])
kmax = maxabs(kin1, kin2 [, kin3] [, kin4] [...])

maxabsaccum(aAccumulator, aInput)

maxaccum(aAccumulator, aInput)

amin= [**min**](opcodes/min.md)(ain1, ain2 [, ain3] [, ain4] [...])
kmin = min(kin1, kin2 [, kin3] [, kin4] [...])
imin = min(iin1, iin2 [, iin3] [, iin4] [...])

amin =minabs(ain1, ain2 [, ain3] [, ain4] [...])
kmin = minabs(kin1, kin2 [, kin3] [, kin4] [...])

minabsaccum(aAccumulator, aInput)

minaccum(aAccumulator, aInput)

Instrument Control:Clock Control

clockoff(inum)

clockon(inum)

Instrument Control:Conditional Values

(a!=b ? v1 : v2)

(a>b ? v1 : v2)

(a>=b ? v1 : v2)

(a<b ? v1 : v2)

(a<=b ? v1 : v2)

(a==b ? v1 : v2)

Instrument Control:Compilation

ires =compilecsd(Sfilename)

ires =compileorc(Sfilename)

ires =compilestr(Sorch)

ires =evalstr(Scode)
kres = evalstr(Scode, ktrig)

return(ival)

Instrument Control:Duration Control

ihold()

turnoff()
turnoff(inst)
turnoff(knst)

turnoff2(kinsno, kmode, krelease)
turnoff2_i(insno, imode, irelease)

turnoff3(kinsno)

turnon(insnum [, itime])

Instrument Control:Invocation

event("scorechar", kinsnum, kdelay, kdur, [, kp4] [, kp5] [, ...])
event("scorechar", "insname", kdelay, kdur, [, kp4] [, kp5] [, ...])

event_i("scorechar", iinsnum, idelay, idur, [, ip4] [, ip5] [, ...])
event_i("scorechar", "insname", idelay, idur, [, ip4] [, ip5] [, ...])

mute(insnum [, iswitch])
mute("insname" [, iswitch])

iHandle =nstance(insnum, iwhen, idur [, ip4] [, ip5] [...])
iHandle = nstance("insname", iwhen, idur [, ip4] [, ip5] [...])

readscore(Sin)

remove(insnum)

schedkwhen(ktrigger, kmintim, kmaxnum, kinsnum, kwhen, kdur )
    [, ip4] [, ip5] [...])
schedkwhen(ktrigger, kmintim, kmaxnum, "insname", kwhen, kdur \
    [, ip4] [, ip5] [...])

schedkwhennamed(ktrigger, kmintim, kmaxnum, "name", kwhen, kdur \
    [, ip4] [, ip5] [...])

schedule(insnum, iwhen, idur [, ip4] [, ip5] [...])
schedule("insname", iwhen, idur [, ip4] [, ip5] [...])
schedule(iPar[])

schedulek(knsnum, kwhen, kdur [, kp4] [, kp5] [...])
schedulek("insname", kwhen, kdur [, kp4] [, kp5] [...])
schedulek(kPar[])

schedwhen(ktrigger, kinsnum, kwhen, kdur [, ip4] [, ip5] [...])
schedwhen(ktrigger, "insname", kwhen, kdur [, ip4] [, ip5] [...])

scoreline(Sin, ktrig)

scoreline_i(Sin)

Instrument Control:Program Flow Control

cggoto(condition, label)

cigoto(condition, label)

ckgoto(condition, label)

cngoto(condition, label)

else

elseifxa R xb then

endif

goto(label)

ifia R ib igoto label
if ka R kb kgoto label
if xa R xb goto label
if xa R xb then

igoto(label)

kgoto(label)

loop_ge(indx, idecr, imin, label)
loop_ge(kndx, kdecr, kmin, label)

loop_gt(indx, idecr, imin, label)
loop_gt(kndx, kdecr, kmin, label)

loop_le(indx, incr, imax, label)
loop_le(kndx, kncr, kmax, label)

loop_lt(indx, incr, imax, label)
loop_lt(kndx, kncr, kmax, label)

tigoto(label)

timout(istrt, idur, label)

untilcondition do
... od

whilecondition do
... od

Instrument Control:Realtime Performance Control

ir =active(insnum [,iopt [,inorel]])
ir = active(Sinsname [,iopt [,inorel]])
kres = active(kinsnum [,iopt [,inorel]])

ktot[,kcpu1, kcpu2,...] =cpumeter(ifreq)

cpuprc(insnum, ipercent)
cpuprc(Sinsname, ipercent)

exitnow([ivalue])

maxalloc(insnum, icount)
maxalloc(Sinsname, icount)

prealloc(insnum, icount)
prealloc("insname", icount)

Instrument Control:Initialization and Reinitialization

ares+=xarg
ires += iarg
kres += karg
table [ kval] += karg

ares=xarg
ires = iarg
kres = karg
ires, ... = iarg, ...
kres, ... = karg, ...
table [ kval] = karg

ares =init(iarg)
ires = init(iarg)
kres = init(iarg)
ares, ... = init(iarg, ...)
ires, ... = init(iarg, ...)
kres, ... = init(iarg, ...)
tab = init(isize[, ival])

insno =nstrnum("name")

Sname =nstrstr(insno)
Sname = nstrstr(knsno)

p(x)

ivar1, ... =passign([istart][, iend])
iarray = passign([istart][, iend])
karray = passign([istart][, iend])

pset(icon1 [, icon2] [...])

reinit(label)

rigoto(label)

rireturn()

ir =tival()

Instrument Control:Sensing and Control

kres =button(knum)

ktrig =changed(kvar1 [, kvar2,..., kvarN])

ktrig =changed2(kvar1 [, kvar2,..., kvarN])
ktrig = changed2(karr[])
ktrig = changed2(aarr[])

kres =checkbox(knum)

icnt =cntCreate([imax, imin, inc])

kval =cntCycles(icnt)

kval =cntDelete(icnt)

ival =cntDelete_i(icnt)

kval =cntRead(icnt)

cntReset(icnt)

kmax, kmin, kinc =cntState(icnt)

kres =control(knum)

kval =count(icnt)

ival =count_i(icnt)

ares =follow(asig, idt)

ares =follow2(asig, katt, krel)

Svalue =getcfg(iopt)

kres =joystick(kdevice, ktab)

ktrig =metro( kfreq [, initphase])

ktrig =metro2( kfreq, kswing [, iamp, initphase])

ktrig =metrobpm( kfreq [, initphase] [, kgate])

ksig =miditempo()

icount =pcount()

kres =peak(asig)
kres = peak(ksig)

ivalue =pindex(ipfieldIndex)

koct, kamp =pitch(asig, iupdte, ilo, ihi, idbthresh [, ifrqs] [, iconf] \
    [, istrt] [, iocts] [, iq] [, inptls] [, irolloff] [, iskip])

kcps, krms =pitchamdf(asig, imincps, imaxcps [, icps] [, imedi] \
    [, idowns] [, iexcps] [, irmsmedi])

acps, alock =plltrack(asig, kd [, kloopf, kloopq, klf, khf, kthresh])

kcps, kamp =ptrack(asig, ihopsize[,ipeaks])

ival =readscratch([index])

rewindscore()

kres =rms(asig [, ihp] [, iskip])

kres [, kkeydown] =sensekey()

ktrig_out =seqtime(ktime_unit, kstart, kloop, kinitndx, kfn_times)

ktrig_out =seqtime2(ktrig_in, ktime_unit, kstart, kloop, kinitndx, kfn_times)

kres =sequ(irhythm[], iinstr[], idata[], kbpm, klen [, kmode] [, kstep] \
    [, kreset] [, kverbose])
kres = sequ(irhythm[], iinstr[], idata[][], kbpm, klen [, kmode] [, kstep] \
    [, kreset] [, kverbose])

setctrl(inum, ival, itype)

setscorepos(ipos)

splitrig(ktrig, kndx, imaxtics, ifn, kout1 [,kout2,...,koutN])

ktemp =tempest(kin, iprd, imindur, imemdur, ihp, ithresh, ihtim, ixfdbak, \
    istartempo, ifn [, idisprd] [, itweek])

tempo(k[**tempo**](opcodes/tempo.md), istar[**tempo**](opcodes/tempo.md))

kres =tempoval()

ktrig =timedseq(ktimpnt, ifn, kp1 [,kp2, kp3, ...,kpN])

kout =trigger(ksig, kthreshold, kmode)

trigseq(ktrig_in, kstart, kloop, kinitndx, kfn_values, kout1 [, kout2] [...])

ares =vactrol(asig [iup, idown])

writescratch(ival [index])

kx, ky =xyin(iprd, ixmin, ixmax, iymin, iymax [, ixinit] [, iyinit])

Instrument Control:Stacks

xval1, [xval2, ... , xval31] =pop()
ival1, [ival2, ... , ival31] = pop()

fsig =pop_f()

push(xval1, [xval2, ... , xval31])
push(ival1, [ival2, ... , ival31])

push_f(fsig)

stack(iStackSize)

Instrument Control:Subinstrument Control

a1, [...] [, a8] =subinstr(instrnum [, p4] [, p5] [...])
a1, [...] [, a8] = subinstr("insname" [, p4] [, p5] [...])

subinstrinit(instrnum [, p4] [, p5] [...])
subinstrinit("insname" [, p4] [, p5] [...])

Instrument Control:Time Reading

ir[, inano] =date()
kr[, knano] = date()

Sir =dates([ itime])

ires =elapsedcycles()
kres = elapsedcycles()

ires =elapsedtime()
kres = elapsedtime()

kres =eventcycles()

kres =eventtime()

ir =readclock(inum)

ires =rtclock()
kres = rtclock()

kres =timeinstk()

kres =timeinsts()

ires =timek()
kres = timek()

ires =times()
kres = times()

Serial I/O

kval =arduinoRead(iPort, iStream [, iSmooth])

kval =arduinoReadF(iPort, iStream1, iStream2, iStream3)

iPort =arduinoStart(SPortName [, ibaudRate])

arduinoStop(iPort)

iPort =serialBegin(SPortName [, ibaudRate])

serialEnd(iPort)

serialFlush(iPort)

serialPrint(iPort)

kByte =serialRead(iPort)

serialWrite(iPort, iByte)
serialWrite(iPort, kByte)
serialWrite(iPort, SBytes)

serialWrite_i(iPort, iByte)
serialWrite_i(iPort, SBytes)

Table Control

ftfree(ifno, iwhen)

gir =ftgen(ifn, itime, isize, igen, iarga [, iargb ] [...])
gir = ftgen(ifn, itime, isize, igen, iarray)

ifno =ftgentmp(ip1, ip2dummy, isize, igen, iarga, iargb, ...)

Sdst =getftargs(iftno, ktrig)

sndload(Sfname[, ifmt[, ichns[, isr[, ibas[, iamp[, istrt [, ilpmod[, ilps \
    [, ilpe]]]]]]]]])

Table Control:Table Queries

karray[] =fillarray(ival1, ival2,.....ivaln)
karray = fillarray(ival1, ival2,.....ivaln)
karray = fillarray(kval1, kval2,.....kvaln)

ftchnls(x) (init-rate args only)

ftcps(x) (init-rate args only)

iexists =ftexists(ifn)
kexists = ftexists(kfn / ifn)

ftlen(x) (init-rate args only)

ftlptim(x) (init-rate args only)

ftsr(x) (init-rate args only)

karray =genarray(kstart, kens [, inc])
iarray = genarray(istart, iens [, inc])

karray =genarray_i(istart, iend [,inc])

ir =lenarray(karray[, iwhich])
kr = lenarray(karray[, iwhich])

karray =maparray(kinarray, String)
karray = maparray_i(kinarray, String)

nsamp(x) (init-rate args only)

karray =slicearray(kinarray, istart, iend [,istride])

ires =tableng(ifn)
kres = tableng(kfn)

kr =tabsum(ifn[[, kmin] [, kmax]])

Table Control:Dynamic Selection

ares =tableikt(xndx, kfn [, ixmode] [, ixoff] [, iwrap])
kres = tableikt(kndx, kfn [, ixmode] [, ixoff] [, iwrap])

ares =tablekt(xndx, kfn [, ixmode] [, ixoff] [, iwrap])
kres = tablekt(kndx, kfn [, ixmode] [, ixoff] [, iwrap])

ares =tablexkt(xndx, kfn, kwarp, iwsize [, ixmode] [, ixoff] [, iwrap])

Table Control:Read/Write Operations

ians =ftaudio(ifn, "filename", iformat[, ibeg, iend])
kans = ftaudio(ktrig, kfn, "filename", kformat [, isync, kbeg, kend])

ftload(Sfilename, iflag, ifn1 [, ifn2] [...])

ftloadk(Sfilename, ktrig, iflag, ifn1 [, ifn2] [...])

ftprint(ifn [, ktrig, kstart, kend, kstep, inumcols ])

iNumberOfFile =ftsamplebank(SDirectory, iFirstTableNumber, iSkipTime, iFormat, \
    iChannel,)
kNumberOfFile = ftsamplebank(SDirectory, kFirstTableNumber, kTrigger, kSkipTime, \
    kFormat, kChannel,)

ftsave("filename", iflag, ifn1 [, ifn2] [...])

ftsavek("filename", ktrig, iflag, ifn1 [, ifn2] [...])

ftset(ktablenum, kvalue [, kstart=0, kend=0, kstep=1 ])
ftset(itablenum, ivalue [, istart=0, iend=0, istep=1 ])

ftslice(ifnsource, ifndest [, kstart, kend, kstep ])
ftslice(kfnsource, kfndest [, kstart, kend, kstep ])

ftslicei(ifnsource, ifndest [, istart, iend, istep ])

tablecopy(kdft, ksft)

knumpassed =tablefilter(kouttable, kintatble, kmode, kparam)

inumpassed =tablefilteri(iouttable, iintatble, imode, iparam)

tablegpw(kfn)

tableicopy(idft, isft)

tableigpw(ifn)

tableimix(idft, idoff, ilen, is1ft, is1off, is1g, is2ft, is2off, is2g)

tablemix(kdft, kdoff, klen, ks1ft, ks1off, ks1g, ks2ft, ks2off, ks2g)

ares =tablera(kfn, kstart, koff)

tablew(asig, andx, ifn [, ixmode] [, ixoff] [, iwgmode])
tablew(isig, indx, ifn [, ixmode] [, ixoff] [, iwgmode])
tablew(ksig, kndx, ifn [, ixmode] [, ixoff] [, iwgmode])

kstart =tablewa(kfn, asig, koff)

tablewkt(asig, andx, kfn [, ixmode] [, ixoff] [, iwgmode])
tablewkt(ksig, kndx, kfn [, ixmode] [, ixoff] [, iwgmode])

kout =tabmorph(kindex, kweightpoint, ktabnum1, ktabnum2, ifn1, ifn2 \
    [, ifn3, ifn4, ...,ifnN])

aout =tabmorpha(aindex, aweightpoint, atabnum1, atabnum2, ifn1, ifn2 \
    [, ifn3, ifn4, ... ifnN])

aout =tabmorphak(aindex, kweightpoint, ktabnum1, ktabnum2, ifn1, ifn2 \
    [, ifn3, ifn4, ... ifnN])

kout =tabmorphi(kindex, kweightpoint, ktabnum1, ktabnum2, ifn1, ifn2 \
    [, ifn3, ifn4, ..., ifnN])

tabplay(ktrig, knumtics, kfn, kout1 [,kout2,..., koutN])

tabrec(ktrig_start, ktrig_stop, knumtics, kfn, kin1 [,kin2,...,kinN])

FLTK:Other

vphaseseg(kphase, ioutab, ielems, itab1,idist1,itab2 \
    [,idist2,itab3, ... ,idistN-1,itabN])

Mathematical Operations:Arithmetic and Logic Operations

!a (logical NOT; not audio-rate)

a&b (bitwise AND)

a&&b (logical AND; not audio-rate)

a * b (no rate restriction)

a^b (b not audio-rate)

a>>b (bitshift left)

a<<b (bitshift left)

a%b (no rate restriction)

a/b (no rate restriction)

a|b (bitwise OR)

a||b (logical OR; not audio-rate)

+a (no rate restriction)
a + b (no rate restriction)

-a (no rate restriction)
a - b (no rate restriction)

a#b (bitwise NON EQUIVALENCE)

~a (bitwise NOT)

Mathematical Operations:Arrays

ires[] =cbrt(iarg)
kres[] = cbrt(karg)

ires[] =fmax(iarg1[], iarg2[])
kres[] = fmax(karg1[], karg2[])
ires[] = fmax(iarg1[], iarg2)
kres[] = fmax(karg[], karg2)

ires[] =fmin(iarg1[], iarg2[])
kres[] = fmin(karg1[], karg2[])
ires[] = fmin(iarg1[], iarg2)
kres[] = fmin(karg[], karg2)

ires[] =fmod(iarg1[], iarg2[])
kres[] = fmod(karg1[], karg2[])
ires[] = fmod(iarg1[], iarg2)
kres[] = fmod(karg[], karg2)

ires[] =hypot(iarg1[], iarg2[])
kres[] = hypot(karg1[], karg2[])

ires[] =limit1(iarg)
kres[] = limit1(karg)

Mathematical Operations:Comparators and Accumulators

clear(avar1 [, avar2] [, avar3] [...])
clear(avar[])

vincr(accum, aincr)

Mathematical Operations:Mathematical Functions

abs(x) (no rate restriction)
abs(k/i[]) (k- or i-arrays )

ceil(x) (init-, control-, or audio-rate arg allowed)
ceil(k/i[]) (k- or i-arrays )

exp(x) (no rate restriction)
exp(k/i[]) (k- or i-arrays)

floor(x) (init-, control-, or audio-rate arg allowed)
floor(k/i[]) (k- or i-arrays )

frac(x) (init-rate or control-rate args; also works at audio rate in Csound5)
frac(k/i[]) (k- or i-arrays )

int(x) (init-rate or control-rate; also works at audio rate in Csound5)

log(x) (no rate restriction)
log(k/i[]) (k- or i-arrays )
kout[] log kin[], ibas

log10(x) (no rate restriction)
log10(k/i[]) (k- or i-arrays )

log2(x) (no rate restriction)
log2(k/i[]) (k- or i-arrays )

logbtwo(x) (init-rate or control-rate args only)

powoftwo(x) (init-rate or control-rate args only)

qinf(x) (no rate restriction)

qnan(x) (no rate restriction)

round(x) (init-, control-, or audio-rate arg allowed)
round(k/i[]) (k- or i-arrays )

sqrt(x) (no rate restriction)
sqrt(k/i[]) (k- or i-arrays )

Mathematical Operations:Trigonometric Functions

cos(x) (no rate restriction)
cos(k/i[]) (k- or i-arrays )

cosh(x) (no rate restriction)
cosh(k/i[]) (k- or i-arrays )

cosinv(x) (no rate restriction)
cosinv(k/i[]) (k- or i-arrays )

signum(x) (no rate restriction)

sin(x) (no rate restriction)
sin(k/i[]) (k- or i-arrays )

sinh(x) (no rate restriction)
sinh(k/i[]) (k- or i-arrays )

sininv(x) (no rate restriction)
sininv(k/i[]) (k- or i-arrays)

tan(x) (no rate restriction)
tan(k/i[]) (k- or i-arrays )

tanh(x) (no rate restriction)
tanh(k/i[]) (k- or i-arrays )

taninv(x) (no rate restriction)
taninv(k/i[]) (k- or i-arrays )

Mathematical Operations:Amplitude Functions

ampdb(x) (no rate restriction)

ampdbfs(x) (no rate restriction)

db(x)

dbamp(x) (init-rate or control-rate args only)

dbfsamp(x) (init-rate or control-rate args only)

Mathematical Operations:Random Functions

birnd(x) (init- or control-rate only)

rnd(x) (init- or control-rate only)

Mathematical Operations:Opcode Equivalents of Functions

aresdivzxa, xb, ksubst
ires divz ia, ib, isubst
kres divz ka, kb, ksubst
    ... divz(ka, kb, ksubst)... (no rate restriction)

ares =mac(ksig1, asig1 [, ksig2] [, asig2] [, ksig3] [, asig3] [...])

ares =maca(asig1 , asig2 [, asig3] [, asig4] [, asig5] [...])

aout =polynomial(ain, k0 [, k1 [, k2 [...]]])

ares =pow(aarg, k= [**pow**](opcodes/pow.md)([, inorm])
ires = pow(iarg, i= pow([, inorm])
kres = pow(karg, k= pow([, inorm])
ires[] = pow(iarg[], ipow[])
kres[] = pow(karg[], kpow[])
ires[] = pow(iarg[], ipow)
kres[] = pow(karg[], kpow)

ares =product(asig1, asig2 [, asig3] [...])

ares =sum(asig1 [, asig2] [, asig3] [...])
kres = sum(karr)
ires = sum(iarr)

arestaninv2ay, ax
ires taninv2 iy, ix
kres taninv2 ky, kx
    ... taninv2(ky, kx)... (no rate restriction)

Pitch Converters:Functions

cent(x)

cpsmidinn(MidiNoteNumber) (init- or control-rate args only)

cpsoct(oct) (no rate restriction)

cpspch(pch) (init- or control-rate args only)

imidi =ftom(ifreq [,irnd])
kmidi = ftom(kfreq [,irnd])
imidis[] = ftom(ifreqs[] [,irnd])
kmidis[] = ftom(kfreqs[] [,irnd])

ifreq =mtof(imidi)
kfreq = mtof(kmidi)
ifreqs[] = mtof(imidis[])
kfreqs[] = mtof(kmidis[])

Snote =mton(kmidi)
Snote = mton(imidi)

kfreq =ntof(Snote)
ifreq = ntof(Snote)

kmidi =ntom(Snote)
imidi = ntom(Snote)

octave(x)

octcps(cps) (init- or control-rate args only)

octmidinn(MidiNoteNumber) (init- or control-rate args only)

octpch(pch) (init- or control-rate args only)

pchmidinn(MidiNoteNumber) (init- or control-rate args only)

pchoct(oct) (init- or control-rate args only)

imidi =pchtom(ipch)
kmidi = pchtom(kpch)

semitone(x)

Pitch Converters:Tuning Opcodes

icps =cps2pch(ipch, iequal)

kcps =cpstun(ktrig, kindex, kfn)

icps =cpstuni(index, ifn)

icps =cpsxpch(ipch, iequal, irepeat, ibase)

Real-time MIDI:Input

kaft =aftouch([imin] [, imax])

ival =chanctrl(ichnl, ictlno [, ilow] [, ihigh])
kval = chanctrl(ichnl, ictlno [, ilow] [, ihigh])

idest =ctrl14(ichan, ictlno1, ictlno2, imin, imax [, ifn])
kdest = ctrl14(ichan, ictlno1, ictlno2, kmin, kmax [, ifn])

idest =ctrl21(ichan, ictlno1, ictlno2, ictlno3, imin, imax [, ifn])
kdest = ctrl21(ichan, ictlno1, ictlno2, ictlno3, kmin, kmax [, ifn])

idest =ctrl7(ichan, ictlno, imin, imax [, ifn])
kdest = ctrl7(ichan, ictlno, kmin, kmax [, ifn])
adest = ctrl7(ichan, ictlno, kmin, kmax [, ifn] [, icutoff])

ctrlinit(ichnl, ictlno1, ival1 [, ictlno2] [, ival2] [, ictlno3] \
    [, ival3] [,...ival32])

kpreset =ctrlpreset(ktag, kchnl, kctlno1, [kctlno2] [, kctlno3] ...)

ctrlprint(kcont[][, Sfile])

ctrlprintpresets([Sfilenam])

kconnt[] =ctrlsave(ichnl, ictlno1, [ictlno2] [, ictlno3] ...)

ctrlselect(kpre)

initc14(ichan, ictlno1, ictlno2, ivalue)

initc21(ichan, ictlno1, ictlno2, ictlno3, ivalue)

initc7(ichan, ictlno, ivalue)

massign(ichnl, insnum[, ireset])
massign(ichnl, "insname"[, ireset])

idest =midic14(ictlno1, ictlno2, imin, imax [, ifn])
kdest = midic14(ictlno1, ictlno2, kmin, kmax [, ifn])

idest =midic21(ictlno1, ictlno2, ictlno3, imin, imax [, ifn])
kdest = midic21(ictlno1, ictlno2, ictlno3, kmin, kmax [, ifn])

idest =midic7(ictlno, imin, imax [, ifn])
kdest = midic7(ictlno, kmin, kmax [, ifn])

ival =midictrl(inum [, imin] [, imax])
kval = midictrl(inum [, imin] [, imax])

ival =notnum()

ibend =pchbend([imin] [, imax])
kbend = pchbend([imin] [, imax])

pgmassign(ipgm, inst[, ichn])
pgmassign(ipgm, "insname"[, ichn])

ires =polyaft(inote [, ilow] [, ihigh])
kres = polyaft(inote [, ilow] [, ihigh])

ival =veloc([ilow] [, ihigh])

Real-time MIDI:Output

nrpn(kchan, kparmnum, kparmvalue)

outiat(ichn, ivalue, imin, imax)

outic(ichn, inum, ivalue, imin, imax)

outic14(ichn, imsb, ilsb, ivalue, imin, imax)

outipat(ichn, inotenum, ivalue, imin, imax)

outipb(ichn, ivalue, imin, imax)

outipc(ichn, iprog, imin, imax)

outkat(kchn, kvalue, kmin, kmax)

outkc(kchn, knum, kvalue, kmin, kmax)

outkc14(kchn, kmsb, klsb, kvalue, kmin, kmax)

outkpat(kchn, knotenum, kvalue, kmin, kmax)

outkpb(kchn, kvalue, kmin, kmax)

outkpc(kchn, kprog, kmin, kmax)

Real-time MIDI:Converters

iamp =ampmidi(iscal [, ifn])

igain =ampmidicurve(ivelocity, idynamicrange, iexponent)
kgain = ampmidicurve(kvelocity, kdynamicrange, kexponent)

iamplitude =ampmidid(ivelocity, idecibels)
kamplitude = ampmidid(kvelocity, idecibels)

icps =cpsmidi()

icps =cpsmidib([irange])
kcps = cpsmidib([irange])

icps =cpstmid(ifn)

ioct =octmidi()

ioct =octmidib([irange])
koct = octmidib([irange])

ipch =pchmidi()

ipch =pchmidib([irange])
kpch = pchmidib([irange])

Real-time MIDI:Generic I/O

kstatus, kchan, kdata1, kdata2 =midiin()

midiout(kstatus, kchan, kdata1, kdata2)

midiout_i(istatus, ichan, idata1, idata2)

Real-time MIDI:Event Extenders

kflag =lastcycle()

kflag =release()

xtratim(iextradur)

Real-time MIDI:Note Output

kMidiNoteNum, kTrigger =midiarp(kRate[, kMode])

midion(kchn, knum, kvel)

midion2(kchn, knum, kvel, ktrig)

moscil(kchn, knum, kvel, kdur, kpause)

noteoff(ichn, inum, ivel)

noteon(ichn, inum, ivel)

noteondur(ichn, inum, ivel, idur)

noteondur2(ichn, inum, ivel, idur)

Real-time MIDI:MIDI/Score Interoperability

midichannelaftertouch(xchannelaftertouch [, ilow] [, ihigh])

ichn =midichn()

midicontrolchange(xcontroller, xcontrollervalue [, ilow] [, ihigh])

mididefault(xdefault, xvalue)

midinoteoff(xkey, xvelocity)

midinoteoncps(xcps, xvelocity)

midinoteonkey(xkey, xvelocity)

midinoteonoct(xoct, xvelocity)

midinoteonpch(xpch, xvelocity)

midipitchbend(xpitchbend [, ilow] [, ihigh])

midipolyaftertouch(xpolyaftertouch, xkey [, ilow] [, ihigh])

midiprogramchange(xprogram)

Real-time MIDI:System Realtime

mclock(ifreq)

mrtmsg(imsgtype)

Real-time MIDI:Slider Banks

i1, ..., i16 =s16b14(ichan, ictlno_msb1, ictlno_lsb1, imin1, imax1, \
    initvalue1, ifn1, ..., ictlno_msb16, ictlno_lsb16, \
    imin16, imax16, initvalue16, ifn16)
k1, ..., k16 = s16b14(ichan, ictlno_msb1, ictlno_lsb1, imin1, imax1, \
    initvalue1, ifn1, ..., ictlno_msb16, ictlno_lsb16, \
    imin16, imax16, initvalue16, ifn16)

i1, ..., i32 =s32b14(ichan, ictlno_msb1, ictlno_lsb1, imin1, imax1, \
    initvalue1, ifn1, ..., ictlno_msb32, ictlno_lsb32, \
    imin32, imax32, initvalue32, ifn32)
k1, ..., k32 = s32b14(ichan, ictlno_msb1, ictlno_lsb1, imin1, imax1, \
    initvalue1, ifn1, ..., ictlno_msb32, ictlno_lsb32, \
    imin32, imax32, initvalue32, ifn32)

i1, ..., i16 =slider16(ichan, ictlnum1, imin1, imax1, init1, ifn1, ..., \
    ictlnum16, imin16, imax16, init16, ifn16)
k1, ..., k16 = slider16(ichan, ictlnum1, imin1, imax1, init1, ifn1, ..., \
    ictlnum16, imin16, imax16, init16, ifn16)

k1, ..., k16 =slider16f(ichan, ictlnum1, imin1, imax1, init1, ifn1, icutoff1, \
    ..., ictlnum16, imin16, imax16, init16, ifn16, icutoff16)

kflag =slider16table(ichan, ioutTable, ioffset, ictlnum1, imin1, imax1, \
    init1, ifn1, ...., \
    ictlnum16, imin16, imax16, init16, ifn16)

kflag =slider16tablef(ichan, ioutTable, ioffset, ictlnum1, imin1, imax1, \
    init1, ifn1, icutoff1, ...., \
    ictlnum16, imin16, imax16, init16, ifn16, icutoff16)

i1, ..., i32 =slider32(ichan, ictlnum1, imin1, imax1, init1, ifn1, ..., \
    ictlnum32, imin32, imax32, init32, ifn32)
k1, ..., k32 = slider32(ichan, ictlnum1, imin1, imax1, init1, ifn1, ..., \
    ictlnum32, imin32, imax32, init32, ifn32)

k1, ..., k32 =slider32f(ichan, ictlnum1, imin1, imax1, init1, ifn1, icutoff1, \
    ..., ictlnum32, imin32, imax32, init32, ifn32, icutoff32)

kflag =slider32table(ichan, ioutTable, ioffset, ictlnum1, imin1, \
    imax1, init1, ifn1, ...., \
    ictlnum32, imin32, imax32, init32, ifn32)

kflag =slider32tablef(ichan, ioutTable, ioffset, ictlnum1, imin1, imax1, \
    init1, ifn1, icutoff1, ...., \
    ictlnum32, imin32, imax32, init32, ifn32, icutoff32)

i1, ..., i64 =slider64(ichan, ictlnum1, imin1, imax1, init1, ifn1, ..., \
    ictlnum64, imin64, imax64, init64, ifn64)
k1, ..., k64 = slider64(ichan, ictlnum1, imin1, imax1, init1, ifn1, ..., \
    ictlnum64, imin64, imax64, init64, ifn64)

k1, ..., k64 =slider64f(ichan, ictlnum1, imin1, imax1, init1, ifn1, icutoff1, \
    ..., ictlnum64, imin64, imax64, init64, ifn64, icutoff64)

kflag =slider64table(ichan, ioutTable, ioffset, ictlnum1, imin1, \
    imax1, init1, ifn1, ...., \
    ictlnum64, imin64, imax64, init64, ifn64)

kflag =slider64tablef(ichan, ioutTable, ioffset, ictlnum1, imin1, imax1, \
    init1, ifn1, icutoff1, ...., \
    ictlnum64, imin64, imax64, init64, ifn64, icutoff64)

i1, ..., i8 =slider8(ichan, ictlnum1, imin1, imax1, init1, ifn1, ..., \
    ictlnum8, imin8, imax8, init8, ifn8)
k1, ..., k8 = slider8(ichan, ictlnum1, imin1, imax1, init1, ifn1, ..., \
    ictlnum8, imin8, imax8, init8, ifn8)

k1, ..., k8 =slider8f(ichan, ictlnum1, imin1, imax1, init1, ifn1, icutoff1, \
    ..., ictlnum8, imin8, imax8, init8, ifn8, icutoff8)

kflag =slider8table(ichan, ioutTable, ioffset, ictlnum1, imin1, imax1, \
    init1, ifn1, ..., ictlnum8, imin8, imax8, init8, ifn8)

kflag =slider8tablef(ichan, ioutTable, ioffset, ictlnum1, imin1, imax1, \
    init1, ifn1, icutoff1, ...., \
    ictlnum8, imin8, imax8, init8, ifn8, icutoff8)

k1, k2, ...., k16 =sliderKawai(imin1, imax1, init1, ifn1, imin2, imax2, \
    init2, ifn2, ..., imin16, imax16, init16, ifn16)

MIDI files:MIDI input and Initialization

ksig =midifilestatus()

Signal Flow Graph Opcodes

alwayson(Tinstrument [, p4, ..., pn])

connect(Tsource1, Soutlet1, Tsink1, Sinlet1)

ifno =ftgenonce(ip1, ip2dummy, isize, igen, iarga, iargb, ...)

asignal =inleta(Sname)

fsignal =inletf(Sname)

ksignal =inletk(Sname)

ksignal =inletkid(Sname, SinstanceID)

array =inletv(Sname)

outleta(Sname, asignal)

outletf(Sname, fsignal)

outletk(Sname, ksignal)

outletkid(Sname, SinstanceID, ksignal)

outletv(Sname, array)

Spectral Processing:STFT

ares =pvadd(ktimpnt, kfmod, ifilcod, ifn, ibins [, ibinoffset] \
    [, ibinincr] [, iextractmode] [, ifreqlim] [, igatefn])

pvbufread(ktimpnt, ifile)

ares =pvcross(ktimpnt, kfmod, ifile, kampscale1, kampscale2 [, ispecwp])

ares =pvinterp(ktimpnt, kfmod, ifile, kfreqscale1, kfreqscale2, \
    kampscale1, kampscale2, kfreqinterp, kampinterp)

ares =pvoc(ktimpnt, kfmod, ifilcod [, ispecwp] [, iextractmode] \
    [, ifreqlim] [, igatefn])

kfreq, kamp =pvread(ktimpnt, ifile, ibin)

tableseg(ifn1, idur1, ifn2 [, idur2] [, ifn3] [...])

tablexseg(ifn1, idur1, ifn2 [, idur2] [, ifn3] [...])

ares =vpvoc(ktimpnt, kfmod, ifile [, ispecwp] [, ifn])

Spectral Processing:LPC

ares =allpole(asig, kCoef[])

kPar[] =apoleparams(kCoef[])

kCoef[], krms, kerr, kcps =lpcanal(asrc, kflg, kprd, isiz, iord [, iwin])
kCoef[], krms, kerr, kcps = lpcanal(koff, kflg, ifn, isiz, iord [, iwin])
iCoef[], irms, ierr, icps = lpcanal(ioff, iflg, ifn, isiz, iord [, iwin])

ares =lpcfilter(asig, asrc, kflg, kprd, isiz, iord [, iwin])
ares = lpcfilter(asig, koff, kflg, ifn, isiz, iord [, iwin])

ares =lpfreson(asig, kfrqratio)

lpinterp(islot1, islot2, kmix)

krmsr, krmso, kerr, kcps =lpread(ktimpnt, ifilcod [, inpoles] [, ifrmrate])

ares =lpreson(asig)

lpslot(islot)

kCoef[], krms, kerr =pvscfs(fsig, iord [, imod])

fsig =pvslpc(asrc, idftsiz, ihop, iord [, iwin])

asig =resonbnk(ain, kPar[], kmin, kmax, iper [, imode, iscal, iskip])

Spectral Processing:Non-Standard

wsig =specaddm(wsig1, wsig2 [, imul2])

wsig =specdiff(wsigin)

specdisp(wsig, iprd [, iwtflg])

wsig =specfilt(wsigin, ifhtim)

wsig =spechist(wsigin)

koct, kamp =specptrk(wsig, kvar, ilo, ihi, istr, idbthresh, inptls, irolloff \
    [, iodd] [, iconfs] [, interp] [, ifprd] [, iwtflg])

wsig =specscal(wsigin, ifscale, ifthresh)

ksum =specsum(wsig [, interp])

wsig =spectrum(xsig, iprd, iocts, ifrqa [, iq] [, ihann] [, idbout] \
    [, idsprd] [, idsinrs])

Spectral Processing:Streaming

fsig =binit(fin, isize)

part2txt(SFile, ftrks)

ftrks =partials(ffr, fphs, kthresh, kminpts, kmaxgap, imaxtracks)

kframe =pvs2array(kvar[], fsig)
kframe = pvs2array(kmags[], kfreqs[], fsig)

kframe =pvs2tab(tvar|kvar[], fsig)
kframe = pvs2tab(kmags[], kfreqs[], fsig)

ares =pvsadsyn(fsrc, inoscs, kfmod [, ibinoffset] [, ibinincr] [, iinit])

fsig =pvsanal(ain, ifftsize, ioverlap, iwinsize, iwintype [, iformat] [, iinit])

fsig =pvsarp(fsigin, kbin, kdepth, kgain)

fsig =pvsbandp(fsigin, xlowcut, xlowfull, xhighfull, xhighcut [, ktype])

fsig =pvsbandr(fsigin, xlowcut, xlowfull, xhighfull, xhighcut [, ktype])

kbnd =pvsbandwidth(fsig)

kamp, kfr =pvsbin(fsig, kbin)

fsig =pvsblur(fsigin, kblurtime, imaxdel)

ihandle, ktime =pvsbuffer(fsig, ilen)

fsig =pvsbufread(ktime, khandle [, ilo, ihi, iclear])

fsig =pvsbufread2(ktime, khandle, ift1, ift2)

fsig =pvscale(fsigin, kscal [, kkeepform, kgain, kcoefs])

kcent =pvscent(fsig)
acent = pvscent(fsig)

keps[] =pvsceps(fsig[, icoefs])

fsig =pvscross(fsrc, fdest, kamp1, kamp2)

fsig =pvsdemix(fleft, fright, kpos, kwidth, ipoints)

fsig =pvsdiskin(SFname, ktscal, kgain [, ioffset, ichan])

pvsdisp(fsig [, ibins, iwtflg])

fsig =pvsfilter(fsigin, fsigfil, kdepth [, igain])

fsig =pvsfread(ktimpt, ifn [, ichan])

fsig =pvsfreeze(fsigin, kfreeza, kfreezf)

fsig =pvsfromarray(karr[] [,ihopsize, iwinsize, iwintype])
fsig = pvsfromarray(kmags[], kfreqs[] [,ihopsize, iwinsize, iwintype])

pvsftr(fsrc, ifna [, ifnf])

kflag =pvsftw(fsrc, ifna [, ifnf])

pvsfwrite(fsig, ifile)

fsig =pvsgain(fsigin, kgain)

fsig =pvshift(fsigin, kshift, klowest [, kkeepform, igain, kcoefs])

ffr, fphs =pvsifd(ain, ifftsize, ihopsize, iwintype [,iscal])

fsig =pvsin(kchan [, isize, iolap, iwinsize, iwintype, iformat])

ioverlap, inumbins, iwinsize, iformat =pvsinfo(fsrc)

fsig =pvsinit(isize [, iolap, iwinsize, iwintype, iformat])

fsig =pvsmaska(fsrc, ifn, kdepth)

fsig =pvsmix(fsigin1, fsigin2)

fsig =pvsmooth(fsigin, kacf, kfcf)

fsig =pvsmorph(fsig1, fsig2, kampint, kfrqint)

fsig =pvsosc(kamp, kfreq, ktype, isize [,ioverlap] [, iwinsize] [, iwintype] \
    [, iformat])

pvsout(fsig, kchan)

kfr, kamp =pvspitch(fsig, kthresh)

fsig =pvstanal(ktimescal, kamp, kpitch, ktab, [kdetect, kwrap, ioffset, \
    ifftsize, ihop, idbthresh])
    )

fsig =pvstencil(fsigin, kgain, klevel, iftable)

fsig =pvstrace(fsigin, kn)
fsig, kBins[] = pvstrace(fsigin, kn [, isort, imin, imax])

fsig =pvsvoc(famp, fexc, kdepth, kgain [, kcoefs])

fsig =pvswarp(fsigin, kscal, kshift [, klowest, kmeth, kgain, kcoefs])

ares =pvsynth(fsrc, [iinit])

asig =resyn(fin, kscal, kpitch, kmaxtracks, ifn)

asig =sinsyn(fin, kscal, kmaxtracks, ifn)

fsig =tab2pvs(tvar|karr[] [, ihopsize, iwinsize, iwintype])
fsig = tab2pvs(kmags[], kfreqs[] [, ihopsize, iwinsize, iwintype])

ffr,fphs =tabifd(ktimpt, kamp, kpitch, ifftsize, ihopsize, iwintype,ifn)

asig =tradsyn(fin, kscal, kpitch, kmaxtracks, ifn)

fsig =trcross(fin1, fin2, ksearch, kdepth [, kmode])

fsig =trfilter(fin, kamnt, ifn)

fsig, kfr, kamp =trhighest(fin1, kscal)

fsig, kfr, kamp =trlowest(fin1, kscal)

fsig =trmix(fin1, fin2)

fsig =trscale(fin, kpitch [, kgain])

fsig =trshift(fin, kpshift [, kgain])

fsiglow, fsighi =trsplit(fin, ksplit [, kgainlow, kgainhigh])

Spectral Processing:ATS

ar =ATSadd(ktimepnt, kfmod, iatsfile, ifn, ipartials [, ipartialoffset, \
    ipartialincr, igatefn])

ar =ATSaddnz(ktimepnt, iatsfile, ibands [, ibandoffset, ibandincr])

ATSbufread(ktimepnt, kfmod, iatsfile, ipartials [, ipartialoffset, \
    ipartialincr])

ar =ATScross(ktimepnt, kfmod, iatsfile, ifn, kmylev, kbuflev, ipartials \
    [, ipartialoffset, ipartialincr])

idata =ATSinfo(iatsfile, ilocation)

kamp =ATSinterpread(kfreq)

kfrq, kamp =ATSpartialtap(ipartialnum)

kfreq, kamp =ATSread(ktimepnt, iatsfile, ipartial)

kenergy =ATSreadnz(ktimepnt, iatsfile, iband)

ar =ATSsinnoi(ktimepnt, ksinlev, knzlev, kfmod, iatsfile, ipartials \
    [, ipartialoffset, ipartialincr])

Spectral Processing:Other

kcent =centroid(asig, ktrig, ifftsize)

asig [,asig2] =filescal(ktimescal, kamp, kpitch, Sfile, klock \
    [,ifftsize, idecim, ithresh])

asig =mincer(atimpt, kamp, kpitch, ktab, klock [ ,ifftsize, idecim])

asig, asig2, ktime =mp3scal(Sfile, ktimescal, kpitch, kamp \
    [, iskip, ifftsize, idecim, ilock])
    )

asig =paulstretch(istretch, iwindowsize, ift)

asig =temposcal(ktimescal, kamp, kpitch, ktab, klock [,ifftsize, idecim, ithresh])

Strings:Definition

Sdst =strfromurl(StringURL)

Sdst =strget(indx)

strset(iarg, istring)

Strings:Manipulation

puts(Sstr, ktrig [, inonl])

Sdst =sprintf(Sfmt, xarg1[, xarg2[, ... ]])

Sdst =sprintfk(Sfmt, xarg1[, xarg2[, ... ]])

Sdst =strcat(Ssrc1, Ssrc2)

Sdst =strcatk(Ssrc1, Ssrc2)

ires =strcmp(S1, S2)

kres =strcmpk(S1, S2)

Sdst =strcpy(Ssrc)
Sdst = Ssrc

Sdst =strcpyk(Ssrc)

ipos =strindex(S1, S2)

kpos =strindexk(S1, S2)

ilen =strlen(Sstr)

klen =strlenk(Sstr)

ipos =strrindex(S1, S2)

kpos =strrindexk(S1, S2)

Sout =strstrip(Sin [, Smode])

Sdst =strsub(Ssrc [, istart[, iend]])

Sdst =strsubk(Ssrc, kstart, kend)

Strings:Conversion

ichr =strchar(Sstr [, ipos])

kchr =strchark(Sstr [, kpos])

Sdst =strlower(Ssrc)

Sdst =strlowerk(Ssrc)

ir =strtod(Sstr)
ir = strtod(indx)

kr =strtodk(Sstr)
kr = strtodk(kndx)

ir =strtol(Sstr)
ir = strtol(indx)

kr =strtolk(Sstr)
kr = strtolk(kndx)

Sdst =strupper(Ssrc)

Sdst =strupperk(Ssrc)

Vectorial:Tables

vtaba(andx, ifn, aout1 [, aout2, aout3, .... , aoutN ])

vtabi(indx, ifn, iout1 [, iout2, iout3, .... , ioutN ])

vtabk(kndx, ifn, kout1 [, kout2, kout3, .... , koutN ])

vtable1k(kfn, kout1 [, kout2, kout3, .... , koutN ])

vtablea(andx, kfn, kinterp, ixmode, aout1 [, aout2, aout3, .... , aoutN ])

vtablei(indx, ifn, interp, ixmode, iout1 [, iout2, iout3, .... , ioutN ])

vtablek(kndx, kfn, kinterp, ixmode, kout1 [, kout2, kout3, .... , koutN ])

vtablewa(andx, kfn, ixmode, ainarg1 [, ainarg2, ainarg3 , .... , ainargN ])

vtablewi(indx, ifn, ixmode, inarg1 [, inarg2, inarg3 , .... , inargN ])

vtablewk(kndx, kfn, ixmode, kinarg1 [, kinarg2, kinarg3 , .... , kinargN ])

vtabwa(andx, ifn, ainarg1 [, ainarg2, ainarg3 , .... , ainargN ])

vtabwi(indx, ifn, inarg1 [, inarg2, inarg3 , .... , inargN ])

vtabwk(kndx, ifn, kinarg1 [, kinarg2, kinarg3 , .... , kinargN ])

Vectorial:Scalar operations

vadd(ifn, kval, kelements [, kdstoffset] [, kverbose])

vadd_i(ifn, ival, ielements [, idstoffset])

vexp(ifn, kval, kelements [, kdstoffset] [, kverbose])

vexp_i(ifn, ival, ielements [, idstoffset])

vmult(ifn, kval, kelements [, kdstoffset] [, kverbose])

vmult_i(ifn, ival, ielements [, idstoffset])

vpow(ifn, kval, kelements [, kdstoffset] [, kverbose])

vpow_i(ifn, ival, ielements [, idstoffset])

Vectorial:Vectorial operations

vaddv(ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose])

vaddv_i(ifn1, ifn2, ielements [, idstoffset] [, isrcoffset])

vcopy(ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [, kverbose])

vcopy_i(ifn1, ifn2, ielements [,idstoffset, isrcoffset])

vdivv(ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose])

vdivv_i(ifn1, ifn2, ielements [, idstoffset] [, isrcoffset])

vexpv(ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose])

vexpv_i(ifn1, ifn2, ielements [, idstoffset] [, isrcoffset])

vmap(ifn1, ifn2, ielements [,idstoffset, isrcoffset])

vmultv(ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose])

vmultv_i(ifn1, ifn2, ielements [, idstoffset] [, isrcoffset])

vpowv(ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose])

vpowv_i(ifn1, ifn2, ielements [, idstoffset] [, isrcoffset])

vsubv(ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose])

vsubv_i(ifn1, ifn2, ielements [, idstoffset] [, isrcoffset])

Vectorial:Envelopes

vexpseg(ifnout, ielements, ifn1, idur1, ifn2 [, idur2, ifn3 [...]])

vlinseg(ifnout, ielements, ifn1, idur1, ifn2 [, idur2, ifn3 [...]])

Vectorial:Limiting and Wrapping

vlimit(ifn, kmin, kmax, ielements)

vmirror(ifn, kmin, kmax, ielements)

vwrap(ifn, kmin, kmax, ielements)

Vectorial:Delay Paths

kout =vdelayk(ksig, kdel, imaxdel [, iskip, imode])

vecdelay(ifn, ifnIn, ifnDel, ielements, imaxdel [, iskip])

vport(ifn, khtime, ielements [, ifnInit])

Vectorial:Random

vrandh(ifn, krange, kcps, ielements [, idstoffset] [, iseed] \
    [, isize] [, ioffset])

vrandi(ifn, krange, kcps, ielements [, idstoffset] [, iseed] \
    [, isize] [, ioffset])

Vectorial:Cellular Automata

cell(ktrig, kreinit, ioutFunc, initStateFunc, iRuleFunc, ielements)

vcella(ktrig, kreinit, ioutFunc, initStateFunc, \
    iRuleFunc, ielements, irulelen [, iradius])

Zak Patch System

zacl(kfirst [, klast])

zakinit(isizea, isizek)

ares =zamod(asig, k[**zamod**](opcodes/zamod.md))

ares =zar(kndx)

ares =zarg(kndx, kgain)

zaw(asig, kndx)

zawm(asig, kndx [, imix])

ir =zir(indx)

ziw(isig, indx)

ziwm(isig, indx [, imix])

zkcl(kfirst, klast)

kres =zkmod(ksig, k[**zkmod**](opcodes/zkmod.md))

kres =zkr(kndx)

zkw(kval, kndx)

zkwm(ksig, kndx [, imix])

OSC

OSCbundle(kwhen, ihost, iport, Sdest[], Stype[], kArgs[][] [, isize])

kans =OSCcount()

ihandle =OSCinit(iport)

ihandle =OSCinitM(Sgroup, iport)

kans =OSClisten(ihandle, idest, itype [, xdata1, xdata2, ...])
kans, kdata[] = OSClisten(ihandle, idest, itype)
kans, ... = OSClisten(idest, itype)

Smess[], klen =OSCraw(iport)

OSCsend(kwhen, ihost, iport, idestination [, itype , xdata1, xdata2, ...])

Network

remoteport(iportnum)

asig =sockrecv(iport, ilength)
ksig = sockrecv(iport, ilength)
asigl, asigr = sockrecvs(iport, ilength)
String = sockrecv(iport, ilength)
asig [,kstate] = strecv(Sipaddr, iport)

socksend(asig, Sipaddr, iport, ilength)
socksend(ksig, Sipaddr, iport, ilength)
socksends(asigl, asigr, Sipaddr, iport, ilength)
stsend(asig, Sipaddr, iport)

Remote Opcodes

insglobal(isource, instrnum [,instrnum...])

insremot(idestination, isource, instrnum [, instrnum...])

midglobal(isource, instrnum [, instrnum...])

midremot(idestination, isource, instrnum [, instrnum...])

Mixer Opcodes

MixerClear()

kgain =MixerGetLevel(isend, ibuss)

asignal =MixerReceive(ibuss, ichannel)

MixerSend(asignal, isend, ibuss, ichannel)

MixerSetLevel(isend, ibuss, kgain)

MixerSetLevel_i(isend, ibuss, igain)

Array Opcodes

copya2ftab(kArray[], ktab [, koffset])
copya2ftab(iArray[], itab [, ioffset])

copyf2array(tab, kftbl)

kout1[], kout2[] =deinterleave(kin[])

i/kout[] =getcol(i/kin[], i/kcol)

i/kout[] =getrow(i/kin[], i/krow)

kout[] =interleave(kin1[], kin2[])

kmax [,kindx] =maxarray(karray)

kmin [,kindx] =minarray(karray)

printarray(ixs[] [, Smft, Slabel ])
printarray(kxs[] [, ktrig, Sfmt, Slabel ])

kres/ires =product(karr[]/iarr[]) (k- or i-arrays )

reshapearray(array[], isize0 [, isize1 ])

scalearray(tarray, kmin, kmax[, kleft, kright])

i/kout[] =setcol(i/kin[], i/kcol)

i/kout[] =setrow(i/kin[], i/krow)

kout[] =shiftin(asig)

asig =shiftout(kIn[] [, ioff])

ksum =sumarray(karray)

kout[] =tab2array(ifn [, kstart, kend, kstep ])
iout[] = tab2array(ifn [, istart, iend, istep ])

trim_i(iarray, ilen)
trim(xarray, klen)

Array Operations: Fast Fourier Transform

kout[] =fft(kin[])

kout[] =fftinv(kin[])

kout[] =rfft(kin[])

kout[] =rifft(kin[])

kout[] =unwrap(kin[])

kout[] =window(kin[] [, koff, itype])

Array Operations: complex numbers

kout[] =c2r(kin[])

kout[] =cmplxprod(kin1[], kin2[])

kout[] =mags(kin[])

kout[] =phs(kin[])

kout[] =pol2rect(kin[])
kout[] = pol2rect(kmags[], kphs[])

kout[] =r2c(kin[])

kout[] =rect2pol(kin[])

Array Operations: dot product

kres/ires =dot(karr1[]/iarr1[], karr2[]/iarr2[]) (k- or i-arrays)

Array Operations: sorting

k/i[] =sorta(k/i[]) (k- or i-arrays )

k/i[] =sortd(k/i[]) (k- or i-arrays )

Array Operations: Cepstrum

keps[] =ceps(kmags[] [, icoefs])

kenv =cepsinv(keps[])

Array Operations: Autocorrelation

kout[] =autocorr(kin[])

Array Operations: Discrete Cosine Transform

kout[] =dct(kin[])
iout[] = dct(iin[])

kout[] =dctinv(kin[])
iout[] = dctinv(iin[])

Array Operations: Mel scale filterbank

kout[] =mfb(kin[], klow, khigh, ibands)

Deprecated

tableiw(isig, indx, ifn [, ixmode] [, ixoff] [, iwgmode])

Miscellaneous

SFiles[] =directory(SDirectory [, SExtention])

kout[] =framebuffer(ain, isize)
aout = framebuffer(kin, isize)

modmatrix(iresfn, isrcmodfn, isrcparmfn, imodscale, inum_mod, \
    inum_parm, kupdate)

idacc, iadcc =nchnls_hw()

aout =olabuffer(kin, ioverlap)

Sres =pwd()

aout =select(a1, a2, aless, aequal, amore)

ires =system_i(itrig, Scmd, [inowait])
kres = system(ktrig, Scmd, [knowait])

tableshuffle(ktablenum)
tableshufflei itablenum)

Utilities

kmom, kint, kshort =lufs(kreset, ain1 [, ain2])