Pular para conteúdo

3.2 Funções de Padrões🔗

Introdução🔗

Existem várias funções que geram um padrão de valores para atingirmos resultados úteis no FoxDot, como ritmos e melodias. Esta página é uma lista de funções de padrão acompanhadas de descrições e exemplos.

Usados como parâmetros para os players do FoxDot, eles podem ser tratados como padrões e seus métodos podem ser aplicados diretamente, por exemplo, PDur(3, 8).reverse(). Você também pode substituir qualquer argumento de entrada por um padrão ou TimeVar para criar um padrão estendido ou Pvar. Vejamos alguns exemplos:

# Função padrão básica
>>> PDur(3, 8)
P[0.75, 0.75, 0.5]

# Use uma lista/padrão para unir dois padrões usando a mesma função.
>>> PDur([3, 2], [8, 4])
P[0.75, 0.75, 0.5, 0.5, 0.5]

# Use um TimeVar para criar uma Pvar
>>> PDur(var([3, 5]), 8)
P[0.75, 0.75, 0.5]             # Equal to PDur(3,8)
P[0.5, 0.25, 0.5, 0.25, 0.5]   # Equal to PDur(5,8) after 4 beats

Lista de Funções de Patterns🔗

PStep(n, value, default=0)🔗

Cria um padrão de comprimento n com o último elemento definido como valor. Todos os outros valores são definidos como padrão.

>>> PStep(5, 4)
P[0, 0, 0, 0, 4]

>>> PStep(4, "o", "x")
P["x", "x", "x", "o"]

PSum(n, total, lim=0.125)🔗

Retorna um padrão de comprimento n cuja soma é igual a total e cada valor é aproximadamente igual. Todos os valores são divisíveis por lim, que também é o menor valor possível para cada elemento.

>>> PSum(5, 4)
P[1.0, 0.75, 0.75, 0.75, 0.75]

>>> PSum(3, 2)
P[0.75, 0.75, 0.5]

PRange(start, stop=None, step=1)🔗

Retorna um padrão preenchido com a série de start a stop (não inclusivo) com incrementos de step (padrão é 1). Se stop for omitido, a série começa em 0 e termina em start.

>>> PRange(5)
P[0, 1, 2, 3, 4]

>>> PRange(2, 7)
P[2, 3, 4, 5, 6]

>>> PRange(4, 14, 2)
P[4, 6, 8, 10, 12]

PTri(start, stop=None, step=1)🔗

Retorna um padrão preenchido com a série de start a stop e vice-versa (não inclusivo) com incrementos de step (padrão é 1). Se stop for omitido, a série começa em 0 e atinge o pico em start.

>>> PTri(5)
P[0, 1, 2, 3, 4, 3, 2, 1]

>>> PTri(2, 7)
P[2, 3, 4, 5, 6, 5, 4, 3]

>>> PTri(4, 14, 2)
P[4, 6, 8, 10, 12, 10, 8, 6]

PSine(n=16)🔗

Retorna um padrão com n valores retirados de uma função de onda senoidal básica com distâncias iguais entre si.

>>> PSine(16)
P[0.0, 0.3826834323650898, 0.7071067811865476, 0.9238795325112867, 1.0, 0.9238795325112867, 0.7071067811865476, 0.3826834323650899, 1.2246467991473532e-16, -0.38268343236508967, -0.7071067811865475, -0.9238795325112865, -1.0, -0.9238795325112866, -0.7071067811865477, -0.3826834323650904]

PEuclid(n, k)🔗

Usa o Algoritmo de Euclides para criar um padrão de comprimento k com n número de pulsos distribuídos da forma mais equitativa possível ao longo do conjunto. Os pulsos são representados como 1.

>>> PEuclid(3, 8)
P[1, 0, 0, 1, 0, 0, 1, 0]

PEuclid2(n, k, lo, hi)🔗

Mesma função que PEuclid, mas substitui os 1 por hi e os 0 por lo.

>>> PEuclid2(3, 8, "x", "o")
P["o", "x", "x", "o", "x", "x", "o", "x"]

PDur(n, k, start=0, dur=0.25)🔗

Retorna a saída de PEuclid como uma série de durações em que cada elemento é um passo de duração dur. O parâmetro start especifica o índice inicial do padrão.

>>> PDur(3, 8)
P[0.75, 0.75, 0.5]

>>> PDur(3, 8, 1)
P[0.75, 0.5, 0.75]

>>> PDur(3, 8, 1, 0.5)
P[1.5, 1.0, 1.5]

PBern(size=16, ratio=0.5)🔗

Retorna um padrão de tamaho size preenchido com uma seleção aleatória de 1s e 0s com base no valor da proporção, conhecido como Processo de Bernoulli.

>>> PBern(6)
P[1, 0, 0, 1, 1, 0]

>>> PBern(6, 0.75)
P[0, 1, 1, 1, 1, 0]

PBeat(string, start=0, dur=0.5)🔗

Retorna um padrão de durações com base em uma string de entrada, em que os caracteres que não são espaços em branco denotam um pulso.

>>> PBeat("x xxx x")
P[1, 0.5, 0.5, 1, 0.5]

>>> PBeat("x xxx x", start=1, dur=1/4)
P[0.25, 0.25, 0.5, 0.25, 0.5]

PSq(a=1, b=2, c=3)🔗

Retorna um padrão de números quadrados no intervalo de (a + c) - 1.

>>> PSq(1, 2, 3)
P[1, 4, 9]

>>> PSq(2, 2, 5)
P[4, 9, 16, 25, 36]