3 - PROGRAMAÇÃO-BÁSICA.sagews

%auto
typeset_mode(True, display=False)

PROGRAMAÇÃO BÁSICA

Operadores Lógicos e Booleanos

Operadores de comparação para determinar, por exemplo, se são iguais. Todos os operadores de comparação da SAGE retornam TRUE como verdade e FALSE como falso. Resumo:

• x < y, verdade se x é menor que y.

• x <= y, verdade se x é menor ou igual a y.

• x >= y, verdade se x é maior ou igual a y.

• x > y, verdade se x é maior que y.

• x == y, verdade se x é igual a y.

• x != y,

• x ~= y, verdade se x é diferente de y.

Uma expressão booleana elemento por elemento, é uma combinação de comparação de expressões usando os operadores:

• | |, operador “ou”

• & &, operador “e”

• ~ ou !, operador “não”

Uma expressão booleana é verdadeira se o resultado do cálculo das combinações lógicas das expressões booleanas for verdadeira. O valor será considerado falso se for zero, e verdadeiro de outra forma.

Estruturas de Controle

Condicional "SE" (IF)

x=randrange(0,10)

y=randrange(0,10)

x ; y

$0$

$3$

# se x< y será impresso a mensagem, se x>y não será feito nada

if x < y:
      print("x é menor que y")

if x < y:
    show("x é menor que y .","Valor de x: ",x," Valor de y: ",y)

else:
    show("x é maior que y .","Valor de x: ",x," Valor de y: ",y)

x é maior que y . Valor de x: $\displaystyle 9$ Valor de y: $\displaystyle 6$

if x < y:
    show("x é menor que y .","Valor de x: ",x," Valor de y: ",y)

elif x > y:
    show("x é maior que y .","Valor de x: ",x," Valor de y: ",y)

else:
    show("x é igual a y .","Valor de x: ",x," Valor de y: ",y)

x é maior que y . Valor de x: $\displaystyle 9$ Valor de y: $\displaystyle 6$

Definindo funções do tipo: f(x) = ParseError: KaTeX parse error: Expected 'EOF', got '&' at position 69: … & \text{x &̲lt; 0}. \end{ca…

x  = random()

print(x)

if x>=0:
    show("f = cos(x) = ",cos(x))

elif x<0:
    show("f = exp(-1/x^2) = ",exp(-1/x^2))

0.87180868238

f = cos(x) = $\displaystyle 0.643443064992$

a = randrange(0,4); b = randrange(0,4)

show('valor de a:', a, " valor de b:",b)


if (a^2 + 2*b -10)*(b^2 + 2*b -10) < 0:
    show("Existe uma raiz entre os intervalos")

elif (a^2 + 2*b -10)*(b^2 + 2*b -10) > 0:
    show("Não existe uma raiz entre os intervalos")

elif (a^2 + 2*b -10)*(b^2 + 2*b -10) < 0 == 0:
    show("Os intervalos são raízes da função")

else:
    show("intervalos inválidos, não existe raiz")

valor de a: $\displaystyle 3$ valor de b: $\displaystyle 3$

Não existe uma raiz entre os intervalos

Condicional "TROCAR" (SWITCH)

x = randrange(-10,10)

y = n(sin(x))

if  y == 0:
    show("Raiz: ",x)

elif y > 0:
    show("Valor positivo:  ",y,". valor de x: ",x)

elif y < 0:
    show("Valor negativo:  ",y,". valor de x: ",x)

Valor positivo: $\displaystyle 0.841470984807897$ . valor de x: $\displaystyle 1$

Repetição "PARA" (FOR)

for<referência>in<sequência>:      <bloco de código>

for<referência>in<sequência>:      condição           continue       else:              <bloco de código>

for<referência>in<sequência>:        condição             break       else:              <bloco de código>

• **Laços Básicos com FOR **

show("Valor da função sin(x)*cos(x/2)+x:")

for x in [1, 2, 3, 4, 5]:

    show( n(sin(x)*cos(x/2)+x) , '. Para x = ', x)

Valor da função sin(x)*cos(x/2)+x:

$\displaystyle 1.73846026260413$ . Para x = $\displaystyle 1$

$\displaystyle 2.49129549643388$ . Para x = $\displaystyle 2$

$\displaystyle 3.00998243446948$ . Para x = $\displaystyle 3$

$\displaystyle 4.31494096431338$ . Para x = $\displaystyle 4$

$\displaystyle 5.76823606043935$ . Para x = $\displaystyle 5$

vetor = range(1,5)

show("Valor da função sin(x)*cos(x/2)+x:")

for x in vetor:

    show( n(sin(x)*cos(x/2)+x)," Para x = ",x)

Valor da função sin(x)*cos(x/2)+x:

$\displaystyle 1.73846026260413$ Para x = $\displaystyle 1$

$\displaystyle 2.49129549643388$ Para x = $\displaystyle 2$

$\displaystyle 3.00998243446948$ Para x = $\displaystyle 3$

$\displaystyle 4.31494096431338$ Para x = $\displaystyle 4$

# para i de 1 até 10,
# se o resto da divisão i por 3 for diferente de zero,
# então o loop é parado e retorna para o inicio do for
# e o loop será continuado até final somente se o resto for 0

for i in range(1,10):
    if i % 3 != 0:
        continue

    show(i)

$\displaystyle 3$

$\displaystyle 6$

$\displaystyle 9$

# para i de 1 até 10,
# se a divisão i por 3 for igual maior ou igual a 4, então o loop é encerrado

for i in range(0,10):
    if (i / 3 >= 2):
        break

    show(i)

$\displaystyle 0$

$\displaystyle 1$

$\displaystyle 2$

$\displaystyle 3$

$\displaystyle 4$

$\displaystyle 5$

for n in range(1,3):
    show('valor de n:',n)
    for m in range(1,3):
        show('valor de m:',m)
        show("n * m =", (n * m))

    show("")

valor de n: $\displaystyle 1$

valor de m: $\displaystyle 1$

n * m = $\displaystyle 1$

valor de m: $\displaystyle 2$

n * m = $\displaystyle 2$

valor de n: $\displaystyle 2$

valor de m: $\displaystyle 1$

n * m = $\displaystyle 2$

valor de m: $\displaystyle 2$

n * m = $\displaystyle 4$

• **Usando o For para encontrar raízes de uma função utilizando o Método Bruto **

%time

# Método bruto de encontrar raízes de uma função sem otimização

x = srange(0 , 10 , 0.00001)

for k in x:
     if abs(sin(k)*k + 1 ) < 0.0001:
        print("Valor(y):",sin(k)*k + 1 ," . Raiz(x): ", k)

print("fim")

('Valor(y):', 0.0000676888000875620, ' . Raiz(x): ', 3.43681000001405) ('Valor(y):', 0.0000318979772357952, ' . Raiz(x): ', 3.43682000001405) ('Valor(y):', -3.89293696634319e-6, ' . Raiz(x): ', 3.43683000001405) ('Valor(y):', -0.0000396839425147455, ' . Raiz(x): ', 3.43684000001405) ('Valor(y):', -0.0000754750394051928, ' . Raiz(x): ', 3.43685000001405) ('Valor(y):', -0.0000835484924028851, ' . Raiz(x): ', 6.11900999993752) ('Valor(y):', -0.0000248154256290434, ' . Raiz(x): ', 6.11901999993752) ('Valor(y):', 0.0000339179384583055, ' . Raiz(x): ', 6.11902999993752) ('Valor(y):', 0.0000926515998534994, ' . Raiz(x): ', 6.11903999993751) ('Valor(y):', 0.0000415546593890426, ' . Raiz(x): ', 9.52989999980839) ('Valor(y):', -0.0000542676025068189, ' . Raiz(x): ', 9.52990999980839) fim CPU time: 12.77 s, Wall time: 14.01 s

%time

# Método bruto de encontrar raízes de uma função com otimização RDF

x = srange(0 , 10 , RDF(0.00001))

for k in x:
     if abs(sin(k)*k + 1 ) < 0.0001:
        print("Valor(y):",sin(k)*k + 1 ," . Raiz(x): ", k)

print("fim")

('Valor(y):', 6.768880008756195e-05, ' . Raiz(x): ', 3.436810000014048) ('Valor(y):', 3.189797723579524e-05, ' . Raiz(x): ', 3.436820000014048) ('Valor(y):', -3.892936966343186e-06, ' . Raiz(x): ', 3.436830000014048) ('Valor(y):', -3.9683942514745496e-05, ' . Raiz(x): ', 3.436840000014048) ('Valor(y):', -7.547503940541489e-05, ' . Raiz(x): ', 3.436850000014048) ('Valor(y):', -8.354849240288509e-05, ' . Raiz(x): ', 6.119009999937516) ('Valor(y):', -2.4815425629043375e-05, ' . Raiz(x): ', 6.119019999937516) ('Valor(y):', 3.3917938458305485e-05, ' . Raiz(x): ', 6.119029999937515) ('Valor(y):', 9.265159985349936e-05, ' . Raiz(x): ', 6.119039999937515) ('Valor(y):', 4.155465938893155e-05, ' . Raiz(x): ', 9.529899999808388) ('Valor(y):', -5.426760250704099e-05, ' . Raiz(x): ', 9.529909999808387) fim CPU time: 6.15 s, Wall time: 6.60 s

• Percorrimento de uma Matriz

mnum = matrix([[1,2,3],[4,5,6]])
mnum

$\left(\begin{array}{rrr} 1 & 2 & 3 \\ 4 & 5 & 6 \end{array}\right)$

for i in range(0,mnum.nrows()):

    for j in range(0,mnum.ncols()):

        show('elemento da linha %d coluna %d é :'% (i,j) , mnum[i,j])

elemento da linha 0 coluna 0 é : $\displaystyle 1$

elemento da linha 0 coluna 1 é : $\displaystyle 2$

elemento da linha 0 coluna 2 é : $\displaystyle 3$

elemento da linha 1 coluna 0 é : $\displaystyle 4$

elemento da linha 1 coluna 1 é : $\displaystyle 5$

elemento da linha 1 coluna 2 é : $\displaystyle 6$

for i in range(0,mnum.nrows()):

    for j in range(0,mnum.ncols()):

        show('elemento da linha %d coluna %d é :'% (i,j) , mnum[i][j]) # veja que há uma diferença

elemento da linha 0 coluna 0 é : $\displaystyle 1$

elemento da linha 0 coluna 1 é : $\displaystyle 2$

elemento da linha 0 coluna 2 é : $\displaystyle 3$

elemento da linha 1 coluna 0 é : $\displaystyle 4$

elemento da linha 1 coluna 1 é : $\displaystyle 5$

elemento da linha 1 coluna 2 é : $\displaystyle 6$

# Só os elementos

for i in mnum:
    for j in i:
         show('elemento ordem %d : '% j, j)

elemento ordem 1 : $\displaystyle 1$

elemento ordem 2 : $\displaystyle 2$

elemento ordem 3 : $\displaystyle 3$

elemento ordem 4 : $\displaystyle 4$

elemento ordem 5 : $\displaystyle 5$

elemento ordem 6 : $\displaystyle 6$

# Linha por linha

for i in mnum:
    show(i)

$\displaystyle \left(1,\,2,\,3\right)$

$\displaystyle \left(4,\,5,\,6\right)$

# coluna por coluna

for j in range(0,mnum.ncols()):
    mnum[:,j]

$\left(\begin{array}{r} 1 \\ 4 \end{array}\right)$

$\left(\begin{array}{r} 2 \\ 5 \end{array}\right)$

$\left(\begin{array}{r} 3 \\ 6 \end{array}\right)$

# coluna por coluna

for j in mnum.columns():
    print(j)

(1, 4) (2, 5) (3, 6)

• List Comprehension

Uma compreensão de lista é uma construção sintática disponível em algumas linguagens de programação para criação de uma lista baseada em listas existentes. Ela segue a forma da notação de definição de conjunto matemática (compreensão de conjunto) como forma distinta para uso de funções de mapa e filtro. Fonte: wikipedia. Sintaxe genérica:

    lista = [ < expressão > for < referência > in < sequência > if < condição > ]

# Elevar ao quadrado os números de 1 a 4

[x^2 for x in range(1,5)]

[$1$, $4$, $9$, $16$]

# Multiplica os numeros de 1 a 3 e de 3 a 5

[x*y for x in range(1,3)  for y in range(3,6)]

[$3$, $4$, $5$, $6$, $8$, $10$]

# Eleve os numeros maiores ou igual a 4 ao quadrado

num = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

[ x^2 for x in num if x >= 4 ]

[$16$, $25$, $36$, $49$, $64$, $81$, $100$, $121$, $144$]

# multiplicar por 2 todos os elementos maiores que 4 do vetor x

x = vector([1, 2, 3, 4 ,5, 9, 25, 32, 55 ,510])

[ y*2 for y in x if y > 4 ]

[$10$, $18$, $50$, $64$, $110$, $1020$]

# Aplicar os dados de vetores a uma funçãx = vetor; y = vetor

g(x,y) = x - y

A1 = [g(x,y) for x in vector([1, 2, 3]) for y in vector([1, 2, 3]) ]

A1

[$0$, $-1$, $-2$, $1$, $0$, $-1$, $2$, $1$, $0$]

# Acessar o elemento 3
A1[2]

$-2$

# dado um vetor, somar o sucessor com o antesessor

x = vector([10, 11, 12, 13, 14, 15, 16, 17])


[ x[i]+ x[i-1] for i in range(0,len(x)) ]

[$27$, $21$, $23$, $25$, $27$, $29$, $31$, $33$]

# filtro com função anônima

x = vector([10, 11, 12, 13, 14, 15, 16, 17])

[k+1 for k in filter(lambda x: (x > 11) and (x < 16), x)]

[$13$, $14$, $15$, $16$]

# filtro de numeros primos

[p^2 for p in [1,2,..,10] if is_prime(p)]

[$4$, $9$, $25$, $49$]

• Apresentar os dados no formato de uma tabela

tabela = table([['x', 'x^2']] + [[x , x^2] for x in range(5)], header_row = true)

print(tabela)

x x^2 +---+-----+ 0 0 1 1 2 4 3 9 4 16

Repetição "ENQUANTO" (WHILE)

while condicao:      instruções

while condicao:      instruções      if condição:         continue ou break;

reset()

• Laços Básicos

i = 0

while (i / 3 <= 4):
    print(i)
    i = i + 1

0 1 2 3 4 5 6 7 8 9 10 11 12

i = 0

while (i / 3 <= 4):
    i = i + 1
    print(i)

    if (i / 3 == 3 ):
        break

1 2 3 4 5 6 7 8 9

i = 0

while (i / 3 <= 4):
    i = i + 1
    if (i / 3 > 3 ):
        print(i)
        continue

10 11 12 13

• Método da Bisseção

# Metodo da Bisseccao
# Calcula uma aproximação para uma raiz da função de f(x)
# Entre os intervalo [ao,bo] e a tolerencia de erro daddo por tol.
# y = sin(x)*x^2 + cos(x)*x^2 + cos(sin(x))^2

ao = 1
bo = 5
tol = 0.000000001
interacao = 0

if ((sin(ao)*ao^2+cos(ao)*ao^2 + cos(sin(ao))^2) * (sin(bo)*bo^2+cos(bo)*bo^2 + cos(sin(bo))^2)) < 0:

    while (abs(bo-ao) > tol)  &  (interacao<10000000):
        x=(ao+bo)/2
        interacao = interacao+1

        if (sin(x)*x^2 + cos(x)*x^2 + cos(sin(x))^2)*(sin(ao)*ao^2 + cos(ao)*ao^2+ cos(sin(ao))^2) > 0:
            ao=x
        else:
            bo=x

    show("Interacoes: ",interacao)
    show("Valor da raiz: ",N(x))
    show("Valor de f(x)= ",round(sin(x)*x^2 + cos(x)*x^2 + cos(sin(x))^2,9)," com erro menor que ",tol)
else:
    show("Não há raízes no intervalo")

Interacoes: $\displaystyle 32$

Valor da raiz: $\displaystyle 2.43185340519994$

Valor de f(x)= $\displaystyle -2 \times 10^{-09}$ com erro menor que $\displaystyle 1.00000000000000 \times 10^{-9}$

Repetição "FAÇA ATÉ QUE" (DO...UNTIL)

FUNÇÕES ( def( ) )

Para definir uma nova função no Sage, use o comando def e dois pontos após a lista de nomes das variáveis. Em Python, blocos de código não são indicados por colchetes ou blocos de início e fim, como em outras linguagens. Em vez disso, blocos de código são indicados por tabulação, que devem estar alinhadas exatamente.

reset()

• Função Básica

#Função dimensão Matriz

def fmatrixD(L):
    show('------------ inicio funcao -----------')
    show(L)
    show('a dimensão da matriz é :',L.dimensions())
    show('_______________fim___________________')

fmatrixD(matrix([[2,2],[1,5]]))

------------ inicio funcao -----------

$\displaystyle \left(\begin{array}{rr} 2 & 2 \\ 1 & 5 \end{array}\right)$

a dimensão da matriz é : ($\displaystyle 2$, $\displaystyle 2$)

_______________fim___________________

# Função área do circulo

def areaC(raio):
  areaCirc = pi*raio^2
  return N(areaCirc)

areaC(2.1)

$13.8544236023310$

• Calculo das raízes de uma função do segundo grau

def raiz(a,b,c):

    d=(b^2)-(4*a*c)

    if d<0:
        print('Delta negativo, raiz real impossivel de ser extraida.')

    else:
        show('Delta: %f' % d)

        m1 = sqrt(d)
        x1 = (-b+m1)/(2*a)
        x2 = (-b-m1)/(2*a)

        show('Raiz X1 = %f' % x1)
        show('Raiz X2 = %f' % x2)

# parametros a , b e c

raiz(-2,4,15)

Delta: 136.000000

Raiz X1 = -1.915476

Raiz X2 = 3.915476

• Função Bisseção

reset()

def bissec(funcao,a,b,tol):

    # Metodo da Bisseccao
    # Calcula uma aproximação para uma raiz da função de f(x)
    # Entre os intervalo [ao,bo] e a tolerencia de erro dado por tol.

    x = 1
    ao = a
    bo = b
    interacao = 0
    show("f(x)=",funcao)
    g = funcao

    if (g(ao)*g(bo)<0):

        while (abs(bo-ao) > tol)  &  (interacao<10000000):
            x=(ao+bo)/2
            interacao = interacao+1
            if g(x)*g(ao) > 0:
                ao=x
            else:
                bo=x

        show("Interacoes: ",interacao)
        show('Valor da raiz: ',N(x) )
        show('Valor de f(x)= ',round(g(x),8)," com erro menor que :",tol)
    else:
        show("Não há raízes no intervalo, defina outro intervalo")

bissec(2*x^2 + 2*x - 2, 0, 1, 0.00000001)

f(x)= $\displaystyle 2 \, x^{2} + 2 \, x - 2$

<string>:1: DeprecationWarning: Substitution using function-call syntax and unnamed arguments is deprecated and will be removed from a future release of Sage; you can use named arguments instead, like EXPR(x=..., y=...) See http://trac.sagemath.org/5930 for details.

Interacoes: $\displaystyle 27$

Valor da raiz: $\displaystyle 0.618033982813358$

Valor de f(x)= $\displaystyle -3 \times 10^{-08}$ com erro menor que : $\displaystyle 1.00000000000000 \times 10^{-8}$

%%% FIM PROGRAMAÇÃO BÁSICA %%%