Como utilizar " arrays " (random) numa estrutura " If "

[Ritchy]

Ola pessoal... Estou a desenvolver um script que faz uso de arrays (random)

dentro de uma estrutura " if " com o seguinte código (só vale as partes não

comentadas, as outras foram outras tentivas lool):

################################
from pylab import*

##def flash15(Vi, Vref):
##Vref = int(raw_input("Please an integer Vref:"))
##Vi= int(raw_input("Please an integer y01:"))
Vref = arange(1, 20, 0.02)
Vi = arange(1, 10,0.1)
if Vi > Vref/4:
    V0 = 2*Vi-Vref
elif (-Vref/4) <= Vi and Vi <= Vref/4:
    V0 = 2*Vi
elif Vi < -Vref/4:
    V0 = 2*Vi+Vref
else:
    print "Try Again"
##print V0
plot (V0)
####################################

Sendo que este apresenta o seguinte erro:

" Traceback (most recent call last):

  File "C:/Users/richy/Desktop/flash15", line 8, in <module>

    if Vi > Vref/4:

ValueError: shape mismatch: objects cannot be broadcast to a single shape ".

Queria que me ajudassem a descobrir qual o erro, ou se possível outras

formas de solucionar o problema.

Obrigado.

[luizaugustomm]

Bom, se eu entendi corretamente, o erro acontece porque você está tentando dividir todos os elementos do array de uma vez só. Isto é permitido?

[Imoogi]

cara Vref é um array, vc ta tentando dividir ele inteiro, assim não da, tem que ser elemento por elemento

from pylab import*

Vref = arange(1, 20, 0.02)
Vi = arange(1, 10,0.1)

for i in Vref:
     for n in Vi:
          if n > i/4:
                V0 = 2*n-i
          elif (-i/4) <= n and n <= i/4:
                V0 = 2*n
          elif Vi < -i/4:
                V0 = 2*n+i
          else:
                print "Try Again"
                ##print V0
                plot (V0)

[Ritchy]

Olá pessoal, antes de mais obrigada pelas dicas  😄 ... Mas inflizmente ainda nao funciona, ou seja, ja nao tem mais erros de sintaxe mas o plot nao reproduz o desejado  🙂 . Pra ser mais preciso, na janela do plot nao forma nenhuma figura da onda V0 ( espera-se uma forma de onde tipo "dente de serra" ao longo do eixo dos xx).

Queria saber se o colega Imoogi conseguiu visualizar a forma de onda gerada ou se tem mais alguma outra dica/sujestao que possa ajudar-me.. E aos outros que responderam se podiam dar mais uma vista de olhos no problema e que deixassem as  Vossas opinioes.

Obrigado

Ritchy  ?

[Imoogi]

Hummm!!! Aqui não tem o modulo Pylab, vou instalar ele depois eu vejo o que dá!!! 🙂

[Pedro C.]

É possível que pretendas fazer tudo no mesmo ciclo o que é possível visto que segundo o caso que apresentaste Vref e Vi têm a mesma dimensão.

Além disso deves querer plotar um vector no fim e o que estás a plotar é um valor (faz do V0 um vector).

E suspeito que o teu vector V0 vai ter uma dimensão diferente dos dois acima (o que acrescenta mais um ponto ao teu problema).

Pessoalmente para mexer em vectores, matrizes (os tais arrays) gosto de utilizar o numpy (não conheço os comandos para fazer estas coisas como listas em python simples) mas deverá ser simples de implementar o que tu queres depois de conseguires conceptualizar bem o teu problema.

Se tiveres dificuldades em perceber o que escrevi acima avisa.

[Ritchy]

Olá

Pretendo plotar um vector V0 e nao somente o valor de V0. Por acaso em relaçao a dimensao do V0 nao sei bem se tera dimensao diferente do Vref e Vi...

Sim, depois de algumas pesquisas conclui que o melhor mesmo é  utilizar a biblioteca Numpy para o problema.

Queria introduzir aqui umas figuras explicativas do problema mas simplesmente nao percebi como se faz. Cliquei no icone "inserir imagens" mas nao me foi possivel fazer a operaçao uma vez que nao apareceu a janela para indicar o caminho/localizaçao do ficheiro nem nada que se pareça.

Aguardo sua resposta.

Obrigado.

[Pedro C.]

Queria introduzir aqui umas figuras explicativas do problema mas simplesmente nao percebi como se faz. Cliquei no icone "inserir imagens" mas nao me foi possivel fazer a operaçao uma vez que nao apareceu a janela para indicar o caminho/localizaçao do ficheiro nem nada que se pareça.

Acho que a inserção de imagens só pode ser feita por url, ou melhor a imagem precisa de estar num servidor qualquer (um blog por exemplo) para tu a inserires aqui. Depois de meteres aqui o link da tua imagem é que a podes inserir com o ícone das imagens.

Então é assim: programação de algoritmos têm duas grandes ferramentas, ciclos e perguntas. Ciclos são comandos como o while e for, as perguntas são feitas com o comando if (acho que também existe o switch, não tenho a certeza).

Segundo o que percebi o que tu queres fazer é, conceptualmente:

- O primeiro valor do vi é maior do que o primeiro valor do vref a dividir por quatro (if vi[0]>vref[0]: )

----------- se for então:    v0[0]=2*vi[0]-vref[0]

----------- caso contrário escreves uma nova pergunta (o tal elif e finalmente else).

percorrendo isto para todos os valores tens o teu vector v0 como resultado.

para fazeres um vector em numpy metes vector=numpy.array([1,2,3,4,5,...,1001])

para acederes a uma dada posição fazes vector (sendo i=0 na primeira posição, i=1 na segunda, etc...)

deves declarar o teu vector v0 antes de o usares. Para isso utiliza uma função estilo zeros: v0=numpy.zeros(20) (isto vai fazer um vector de zeros com 20 casas)

Para veres as dimensões de um vector faz vector.shape, para teres mesmo o número de colunas (num vector cada posição é uma coluna) faz vector.shape[0].

Basicamente podes declarar o teu vector v0 como v0=numpy.zeros(vref.shape[0])

import numpy
from pylab import plot

Vref = numpy.arange(1, 20, 0.02)
Vi = numpy.arange(1, 10,0.1)
v0=numpy.zeros(vi.shape[0])
i=0
while i<vi.shape[0]:
      if if Vi[i] > Vref[i]/4:
             V0[i] = 2*Vi[i]-Vref[i]
      elif (-Vref[i]/4) <= Vi[i] and Vi[i] <= Vref[i]/4:
             V0[i] = 2*Vi[i]
      elif Vi[i] < -Vref[i]/4:
             V0[i] = 2*Vi[i]+Vref[i]
      i=i+1
plot(v0)

Não experimentei este código mas serve pelo menos para exemplificar o disse em cima.

Já agora tens a certeza que o plot que pretendes fazer é esse? É que a função plot costuma ser utilizada para pelo menos duas séries (eixo do x e eixo do y). Quanto se pretende gráficos de uma série, regra geral, quer-se algo do estilo um histograma (gráficos de barras).

[Ritchy]

Ja estou a ver qual é o esquema (das imagens), envio aqui um link que exemplifica o grafico na sua forma final, assim para ter-se a real visao do que pretendo lool

Em relaçao a orientaçao dos eixos (x, y), o Vref fica com o eixo dos yy e Vi fica com o eixo dos xx ( se bem entendi lool)

Testei o codigo mas nao plotou nada, se calhar um pouco a ver com a nao definiçao dos eixos de coordenadas.

http://www.google.com/imgres?imgurl=http://www.iadc.ca/Imran_ADC_tutorial_files/image048.gif&imgrefurl=http://www.iadc.ca/ADC_architectures_tutorial.htm&usg=__AEWlKS9keIa5m4sYN4KZDS5CjUo=&h=250&w=347&sz=3&hl=pt-BR&start=19&um=1&itbs=1&tbnid=r737HIevBfPX_M:&tbnh=86&tbnw=120&prev=/images%3Fq%3Dresidue%2Btransfer%2Bfunction%26um%3D1%26hl%3Dpt-BR%26lr%3D%26safe%3Doff%26client%3Dfirefox-a%26sa%3DN%26rls%3Dorg.mozilla:pt-BR:official%26channel%3Ds%26tbs%3Disch:1

[Pedro C.]

Teoria de sinas..., não é, claramente, a minha área mas vamos por partes.

O código que escrevi acima foi para exemplificar, não funciona por ter problemas de sintaxe.

(Vref é diferente de vref ou vReF ou qualquer outra combinação maiúsculas, minúsculas. Penso que se chama "case sensitive" a esta propriedade, mas não tenho a certeza)

Para além disto é preciso dizer ao compilador para mostrar o gráfico. O código seguinte já é funcional:

import numpy
import pylab as plt

Vref=numpy.arange(-20,20,0.2)
Vi=numpy.arange(-10,10,0.1)
V0=numpy.zeros(Vref.shape[0])

i=0
while i<Vi.shape[0]:
    if Vi[i]>Vref[i]/4:
        V0[i]=2*Vi[i]-Vref[i]
    elif (Vref[i]/4)<=Vi[i] and Vi[i]<=Vref[i]/4:
        V0[i]=2*Vi[i]
    elif Vi[i]<Vref[i]/4:
        V0[i]=2*Vi[i]+Vref[i]
    i=i+1
    
plt.plot(Vref,V0)
plt.show()

Agora penso que não é bem isto que pretendes porque o resultado é tudo menos semelhante ao que mostraste na figura. (ah, é verdade, troquei os limites da função numpy.arange para serem simétricos por razões que já te digo).

O problema aqui não é de programação mas sim matemático. Repara que o vector Vref e Vi são, de facto, resultado de diferentes equações da recta: Vref[xx]=0.2*xx, com xx inteiro entre -100 e 100      /      Vi[xx]=0.1*xx, com xx inteiro entre -100 e 100

Duas rectas cruzam-se se tiverem declives diferentes, mas apenas se cruzam uma vez, pelo que as perguntas que estás a fazer apenas vão fazer sentido para dois casos diferentes: um que o Vref/4 é maior que o Vi e outro em que é menor.

Tenta o seguinte código:

import numpy
import pylab as plt

Vref=numpy.arange(-2,2,0.2)
Vref2=numpy.arange(-2,2,0.2)
Vi=numpy.arange(-1,1,0.1)
V0=numpy.zeros(Vref.shape[0])
i=0
while i<Vref2.shape[0]:
    Vref2[i]=Vref[i]/4
    i=i+1

i=0
while i<Vi.shape[0]:
    if Vi[i]>Vref[i]/4:
        V0[i]=2*Vi[i]-Vref[i]
    elif (Vref[i]/4)<=Vi[i] and Vi[i]<=Vref[i]/4:
        V0[i]=2*Vi[i]
    elif Vi[i]<Vref[i]/4:
        V0[i]=2*Vi[i]+Vref[i]
    i=i+1
print Vref.shape[0],Vi.shape[0]
#print Vref
#print Vi
#print V0
plt.plot(Vref,Vref,'r',Vref,Vi,'g',Vref,Vref2,'b') #numpy.linspace(1,10,20)
plt.legend(('Vref','Vi','Vref/4'))
plt.plot(Vref,V0,'black',linestyle='dashed')
plt.grid()
plt.show()

No gráfico que resulta disto tens a linha do Vref, Vi e Vref/4 (e também está o resultado do teu algoritmo no tracejado preto). Existe uma altura em que a linha azul (Vref/4) é superior à linha verde (Vi) e outra em que a linha azul é inferior à verde (sendo preciso são três casos porque de facto existe um ponto onde ambas são iguas,x=0). Com os teus dados de input é impossível chegar a um resultado como o que mostraste no exemplo, usando este algoritmo. Será mesmo isto que pretendes?

[Ritchy]

Interessante a forma como explicas as tuas ideias, coerentes e claras (pareces um professor, se nao és pelo menos devias ser lool).

Em relaçao ao codigo de ontem experimentei nao sei bem porque deu erro mas posso dizer que tive a maxima atençao nos "cases sensitives" porque eu conheço esta propriedades (tive disciplinas de programaçao), mas deve de ter sido pela minha inesperiencia com  esta nova linguagem (para mim) o python.

Como eu disse, ja tive disciplinas de programaçao durante o meu curso (estudei C, C++ e java) embora nao tenha aprofundado muito, mas tive o "azar" de o meu projecto vir a ser feito em python (que é pouco comum aqui em PT)

Testei o ultimo script que deixaste mas pra variar deu erro de novo  , acho que tem haver com a parte do plot.

Do inicio tive que alterar o "namespace":

import pylab as plt

para:

import matplotlib.pylab as plt

Só assim consegui ter as primeiras imagens (da 1ª versao do codigo) mas depois com o plot mais completo que introduziste ja nao consegui porque deu erro.

O primeiro plot do V0 (das 1ª versao) nao me pareceu estranho. Se calhar posso pegar apartir daí para tentar fazer alguma coisa.

A figura que deixei no meu ultimo Post é a que realmente preciso obter (de facto nao se parece muito com aquela que obteste), e ela é obtida atraves da funçao que é transcrita no ciclo while que foi implementado.

[Pedro C.]

Hmm, talvez seja do meu IDE (é o Spyder, http://packages.python.org/spyder/). É possível que logo ao inicio ele importe automaticamente não sei quantas bibliotecas. De qualquer maneira se conseguiste meter o primeiro a funcionar já tens o mais importante (o outro plotava o gráfico que estava no meu post anterior).

O primeiro plot do V0 (da 1ª versao) nao me pareceu estranho. Se calhar posso pegar apartir daí para tentar fazer alguma coisa.

Estive a dar uma vista de olhos no link que mandaste e embora não perceba grande coisa da ciência havia lá uma série de transformações que podiam afectar a linearidade dos teus dados iniciais embora pelo gráfico que meteste aqui parece que tens uma recta, originalmente, e sempre que a mesma toca num dado patamar (qual é que não consegui perceber) é feito uma espécie de reset à origem da recta.

Qualquer recta é dada pela fórmula y=mx+b (no caso destes dados o b é zero, a tal "origem" da recta). Conceptualmente parece que é subtraído um b sempre que a recta original toca num patamar.

y=mx  (até tocar o patamar)

y=mx-b (após tocar o patamar)

y=mx-b-b=mx-2b (após tocar o patamar pela segunda vez)

y=mx-b-b-b=mx-3b (após a terceira e por ai adiante)

Não haverá outro formalismo para definir o vector de comparação (o Vi neste caso)?

A figura que deixei no meu ultimo Post é a que realmente preciso obter (de facto nao se parece muito com aquela que obteste), e ela é obtida atraves da funçao que é transcrita no ciclo while que foi implementado.

Pois, mais uma vez, é possível que te esteja a faltar um passo porque repara nesta linha de código:

elif (Vref[i]/4)<=Vi[i] and Vi[i]>=Vref[i]/4:

Que originalmente escreveste assim:

elif (-Vref/4) <= Vi and Vi <= Vref/4:

Isto não faz sentido considerando que estás a usar rectas como dados iniciais e das duas uma ou esta condição acontece no ponto em que ambos os vectores são iguais (o) ou então ficará necessariamente dentro das outras duas condições que enunciaste.

De qualquer maneira boa sorte para o teu projecto.

[Ritchy]

Ola a todos,

Antes de mais queria queria agradecer a todos que ate agora ajudaram...

Ja consegui obter os resultados que procurava e gostaria de mostrar-vos...

import numpy as np
import matplotlib.pyplot as plt
import matplotlib
from pylab import *
from scipy import *

Inc = raw_input("Valor do Incrimento = ")
#step = Inc

Vref = np.linspace(1,1, Inc)
Vin = np.linspace(-1,1, Inc)

cs = np.linspace(1.5e-12, 1.5e-12, Inc)
cf = np.linspace(1.5e-12, 1.5e-12, Inc)

Vout = np.zeros(Vin.shape, dtype=np.float)

i = 0

def Flash15(Vin, Vout):
    print Vout
    plt.plot(Vin, Vout) # Plot one single point at x = Vin, y = Vout
    grid (True); title('FLASH 1.5 BIT'); xlabel('Vin');ylabel('Vout')
    limit = [-1,1,-1.5,1.5]
    axis(limit)
    plt.show()

while i < Vin.shape[0]:
    if Vin[i] > Vref[i]/4:
        #Vout[i] = 2*Vin[i]-Vref[i]
        Vout[i] = (1+(cs[i]/cf[i]))*Vin[i] - (cs[i]/cf[i])*Vref[i]
    elif (-Vref[i]/4)<= Vin[i] and Vin[i] <= Vref[i]/4:
        #Vout[i] = 2*Vin[i]
        Vout[i] = (1+(cs[i]/cf[i]))*Vin[i]
    elif Vin[i] < -Vref[i]/4:
        #Vout[i] = 2*Vin[i] + Vref[i]
        Vout[i] = (1+(cs[i]/cf[i]))*Vin[i] + (cs[i]/cf[i])*Vref[i]
    i = i + 1

Flash15(Vin, Vout)

Após algumas alterações no código proposto pelo colega aqui no fórum consegui obter a forma de onda desejada através do código acima transcrito. Mas este mostrou-se ser muito lento uma vez que percorria os vectores elemento a elemento o que tornava o processamento muito lento, então que surgiu a seguinte solução para aumentar a rapidez de processamento.

import matplotlib.pyplot as plt
from matplotlib.pyplot import figure
import numpy as np
from pylab import *

def Flash15(Vi, Vr, Cs, Cf):

    if any(Vi > Vr/4):
        Vin = (Vi > Vr/4)
        Vin1 = Vi.compress(Vin)
        Vref1 = Vr.compress(Vin)
        cs1 = Cs.compress(Vin)
        cf1 = Cf.compress(Vin)
        a1 = Vin1.size
        V01= (1+cs1/cf1)*Vin1 - (cs1/cf1)*Vref1
        Vout_dig1 = repeat(2,a1)
    ##
    if any(-Vr/4 <= Vi) and any( Vi<= Vr/4):
        Vin = (-Vr/4 <= Vi) & (Vi <= Vr/4)
        Vin2 = Vi.compress(Vin)
#        Vref2 = Vr.compress(Vin)
        cs2 = Cs.compress(Vin)
        cf2 = Cf.compress(Vin)
        a2 = Vin2.size
        V02 = (1+(cs2/cf2))*Vin2
        Vout_dig2 = repeat(1, a2)
    ##
    if any(Vi < -Vr/4):
        Vin = (Vi < -Vr/4)
        Vin3 = Vi.compress(Vin)
        Vref3 = Vr.compress(Vin)
        cs3 = Cs.compress(Vin)
        cf3 = Cf.compress(Vin)
        a3 = Vin3.size
        V03= (1+cs3/cf3)*Vin3 + (cs3/cf3)*Vref3
        Vout_dig3 = repeat(0, a3)

    V_ent1 = append(Vin3,Vin2)
    V_ent = append(V_ent1,Vin1)

    Vout1 = append(V03,V02)
    Vout = append(Vout1,V01)

    V_d = append(Vout_dig3,Vout_dig2)
    Vout_dig = append(V_d, Vout_dig1)

    S_Out = [V_ent, Vout, Vout_dig]

    return S_Out

if __name__ == "__main__":

    Inc = raw_input("Valor do Incrimento = ")
    #w = 2*np.pi*50
    Vr = np.linspace(1,1, Inc)
    Vi= np.linspace(-1,1, Inc)
    #Vi = 0.5*np.sin(w*x/100 + 30)

    Cs = np.linspace(3e-12, 3e-12, Inc)
    Cf = np.linspace(3e-12, 3e-12, Inc)

    f = Flash15(Vi, Vr, Cs, Cf)

    Vin = f[0]
    Vout_ana = f[1]
    Vout_dig = f[2]

    fig1 = figure(1,figsize=(8,5))
    ax1 = fig1.add_subplot(211, autoscale_on=False, xlim=(-1,1), ylim=(-1,1))
    ax1.plot(Vin, Vout_ana, lw=2, color='blue')
    grid (True); title('FLASH 1.5 BIT',fontsize = 16);ylabel('Vout_Residuo')

    ax1.annotate('00', xy=(-0.5, 0.5))
    ax1.annotate('01', xy=(0.0, 0.5))
    ax1.annotate('11', xy=(0.5, 0.5))

    hold(True)

    fig2 = figure(1,figsize=(8,5))
    ax2 = fig2.add_subplot(212, autoscale_on=False, xlim=(-1,1), ylim=(-0.5,2.5))
    ax2.plot(Vin, Vout_dig, lw=2, color='red')
    grid (True); xlabel('V_ent');ylabel('Vout_Digital')

    ax2.annotate('00 --> 0', xy=(-0.5, 0.1))
    ax2.annotate('01 --> 1', xy=(0.0, 1.1))
    ax2.annotate('11 --> 2', xy=(0.5, 2.1))

    plt.show()

Baseia-se em fazer os cálculos isoladamente para cada um dos casos dentro na estrutura "If" (em comparação ao primeiro script) e armazenar em vectores separadamente em V01, V02, V03 para de seguida junta-los através  da função "append"em um  Vout final. juntamente adicionamos uma saída digital mas isso não e para ser levado em conta, pelo menos não por agora.

Mas como um problema nunca vem só  ? o próximo desafio passa por desenvolver uma 10 bit pipeline ADC. Para o qual gostaria imenso de contar com a vossa ajuda para o implementar.

A figura acima mostra a configuração de uma pipeline ADC de 10Bit que preciso implementar, onde cada um dos blocos no desenho, representa um estagio de 1.5 Bit e o ultimo um estagio de 2 Bit.

Por agora quero fazer com que: Dado uma tensão de entrada (Vin), esta será processada no estagio 1, originando uma tensão de saída (Vout) do estagio 1, onde esta mesma tensão será a entrada do estagio 2 e que por sua vez será processada para originar uma segunda tensão de saída desta feita do estagio 2 e que servira de tensão de entrada para o estagio 3 e assim sucessivamente ate que chegue a entrada do estagio final que será o de 2 Bit que fará o processamento final.

O estagio de 1.5Bit e a funcao que foi implementada que e o Flash15 postado acima e passo a postar a funcao do estagio de 2Bit:

import matplotlib.pyplot as plt
from matplotlib.pyplot import figure
import numpy as np
from pylab import *


def flash2bit(Vi, Vr):

    if any(Vi > Vr/2):
        Vin = (Vi > Vr/2)
        Vin1 = Vi.compress(Vin)
        a1 = Vin1.size
        Vt1 = repeat(3,a1)

    if any(Vi > 0) and any(Vr/2 >= Vi):
        Vin = (Vr/2 >= Vi) & (Vi > 0)
        Vin2 = Vi.compress(Vin)
        a2 = Vin2.size
        Vt2 = repeat(2, a2)

    if any(Vi <= 0) and any(-Vr/2 < Vi):
        Vin = (-Vr/2 < Vi) & (Vi <= 0)
        Vin3 = Vi.compress(Vin)
        a3 = Vin3.size
        Vt3 = repeat(1, a3)

    if any(Vi <= -Vr/2):
        Vin = (Vi < -Vr/2)
        Vin4 = Vi.compress(Vin)
        a4 = Vin4.size
        Vt4 = repeat(0, a4)

    V_ent1 = append(Vin4,Vin3)
    V_ent2 = append(V_ent1,Vin2)
    V_ent = append(V_ent2, Vin1)

    Vt_dig1 = append(Vt4,Vt3)
    Vt_dig2 = append(Vt_dig1,Vt2)
    Vt_dig = append(Vt_dig2, Vt1)

    S_Out = [V_ent, Vt_dig]

    return S_Out

if __name__ == "__main__":

    Inc = raw_input("Valor do Incrimento = ")
    #w = 2*np.pi*50
    Vr = np.linspace(1,1, Inc)
#    Vi = f15.
    Vi= np.linspace(-1,1, Inc)
    #Vi = 0.5*np.sin(w*x/100 + 30)

    f = flash2bit(Vi, Vr)

    Vin = f[0]
    Vout_dig = f[1]

    fig2 = figure(1,figsize=(8,5))
    ax2 = fig2.add_subplot(111, autoscale_on=False, xlim=(-1,1), ylim=(-1,4))
    ax2.plot(Vin, Vout_dig, lw=2, color='red')
    grid (True); xlabel('V_ent');ylabel('Vout_Digital')

    ax2.annotate('000 --> 0', xy=(-0.8, 0.1))
    ax2.annotate('001 --> 1', xy=(-0.3, 1.1))
    ax2.annotate('011 --> 2', xy=(0.2, 2.1))
    ax2.annotate('111 --> 3', xy=(0.7, 3.1))
    plt.show()

No final pretende-se obter uma onda similar a figura abaixo, mas muito mais parecida com uma rampa uma vez que os vários processamentos entre os estágios 1 a 8 são de certa forma longos e densos o que provoca alteração na onda final (mais esticada).

Obrigado pela atenção, ficarei aguardando por sujestoes.