6 - EQUACOES-INEQUACOES-FUNCOES.sagews

%auto
typeset_mode(True, display=False)

EQUAÇÕES, INEQUAÇÕES E FUNÇÕES

De acordo com o dicionario matemático disponível em "http://www.somatematica.com.br/dicionarioMatematico" temos que:

Equação: Expressão algébrica indicada por uma igualdade, onde há valores desconhecidos expressos por letras (incógnitas). Logo, todo conjunto de expressões no qual há uma igualdade cuja(s) incógita(s) satisfaçam a um conjunto limitado de soluções, então temos uma equação. Ex: $x + 2 =0, xy - 2x = 2, x^2 + y^2 = 2^2$.

Inequação: Desigualdade verificada a determinado(s) valor(es) atribuídos à variável. Uma inequação é uma equação no qual há uma desigualdade do tipo <, >, >=, =< ou #. Ex: $x + 2 > 0,xy - 2x < 2, x^2 + y^2 2^2$

Função: É uma correspondência unívoca entre dois conjuntos em que a cada elemento do primeiro conjunto corresponde a um e somente um elemento do segundo. Dessa forma, temos que uma função é uma relação entre das variáveis, sendo uma dependente e outra independente. Ex: $y(x) = x + 2, z = xy - 2x, f(x) = x^2 + y^2$

EQUAÇÕES

Cálculo de uma expressão

O comando:

   sage_eval("expressão", {"variável":valor})

Interpreta a expressão, como se fosse uma linha de programa do SageMath e calcula com base no valor da variável.

reset()

sage_eval('x^2 - 2*x + 0', {'x':4})

$8$

sage_eval('x^2 - 2*x + y', {'x':4,'y':2})

$10$

INEQUAÇÕES

reset()

ineq1 = x^2 - 4 > 0
ineq1

$x^{2} - 4 > 0$

type(ineq1)

<type 'sage.symbolic.expression.Expression'>

solve(ineq1,x)

[[$x < \left(-2\right)$], [$x > 2$]]

ineq2 = (x^2 - 4)/(x + 1) > 0
ineq2

$\frac{x^{2} - 4}{x + 1} > 0$

solve(ineq2,x)

[[$x > \left(-2\right)$, $x < \left(-1\right)$], [$x > 2$]]

Conjunto colução: x maior que -2 e menor que -1 ou x maior que 2

**FUNÇÕES **

Simbólicas

Sage só trabalha com expressões e funções matemáticas simbólicas. Tecnicamente, não precisamos definir explicitamente "x" como uma variável simbólica, porque SAGE assume que x é simbólico por padrão. No entanto, para usar uma variável diferente de "x" sem a atribuição simbólica var("variável"), é necessário usar a forma função(variável) = expressão_variável. A desvantagem ou vavntagem é que a variável só funcionará dentro da expressão. Para usar a variável em outros cálculos, é necessário usar var("variável"). Sintaxe:

    %var variável
    funcao_nome = expressao Ou
    f(var) = expressao_var

reset()

f = x^2 + 1

f

$x^{2} + 1$

type(f)

<type 'sage.symbolic.expression.Expression'>

f(2)

/usr/local/lib/python2.7/dist-packages/smc_sagews/sage_server.py:957: 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. exec compile(block+'\n', '', 'single') in namespace, locals

$5$

Atribuir um valor para "x" fora de "f(valor)" não vai alterar o valor de "f". Para alterar é necesário definir novamente a função

x = 2

f

x^2 + 1

Para usar uma variável diferente de "x" sem a atribuição simbólica, é necessário usar a forma :

   função(variável) = expressão variável.

g(t) = t+2*t^2

g; g(t)

t |--> 2*t^2 + t 2*t^2 + t

type(g); type(g(t))

<type 'sage.symbolic.expression.Expression'> <type 'sage.symbolic.expression.Expression'>

g(2); print(g(2)); show(g(2))

$10$

10

$\displaystyle 10$

# uso de uma variável nao declarada na forma FUNCAO("variável")

h = s+1

Error in lines 1-1 Traceback (most recent call last): File "/usr/local/lib/python2.7/dist-packages/smc_sagews/sage_server.py", line 957, in execute exec compile(block+'\n', '', 'single') in namespace, locals File "", line 1, in <module> NameError: name 's' is not defined

# forma correta

h(s) = s+1

h(2)

$3$

• Funções de variáveis declaradas simbólicas

reset()

var('w')

$w$

y = w + 2

y

$w + 2$

type(y)

<type 'sage.symbolic.expression.Expression'>

y(2)

$4$

Atribuir um valor para "w" fora de "y(valor)" não vai alterar o valor de "y"

w = 3

y

$w + 2$

Função de variável simbólica atribuida diretamente sem o var()

s(t) = t + 2

s ; s(t) ; s()

$t \ {\mapsto}\ t + 2$

$t + 2$

$t + 2$

type(s) ; type(t)

<type 'sage.symbolic.expression.Expression'> <type 'sage.symbolic.expression.Expression'>

s(2)

$4$

Atribuir um valor para "t" fora de "s(valor)" não vai alterar o valor de "s"

t = 3

s

$t \ {\mapsto}\ t + 2$

• Funções de mais de uma variável

reset()

var('y')

$y$

g = x + y;

g

$x + y$

g(2,1)

$3$

f(x,y) = x + y;

f

$\left( x, y \right) \ {\mapsto} \ x + y$

f(2,3)

$5$

f(u,v) = sin(u)*v

f ; f(u,v) ; f()

$\left( u, v \right) \ {\mapsto} \ v \sin\left(u\right)$

$v \sin\left(u\right)$

$v \sin\left(u\right)$

Funções Anônimas

Funções anônimas - funções sem nome - são funções no qual não há nome para defini-las. Um bom exemplo são as funções map() e compreensões de lista. Não precisam usar o SymPy ou a forma de função genérica (funcao(variavel) = expressao). O uso principal para funções anônimas é passá-los para funções que assumem outras funções como argumentos. A finalidade de uma função anônima é exatamente a de permitir passá-la como se fosse um objeto qualquer, que você pode atribuir a uma variável, independentemente de haver um nome para a função.

Lambda

Uma expressão lambda permite escrever funções anônimas usando apenas uma linha de código. Sintaxe:

(lambda var1, var2, ..., varN  : expressão)

Onde var1, var2, ..., varN são variáveis que representam o argumento da função.

• Função de uma variável

# Com atribuição de uma variável

fanon = (lambda x : x^2)
fanon(2)

$4$

# Sem atribuição de uma variável

(lambda x : x^2)(2)

$4$

• Função de duas variáveis

# Com atribuição de uma variável

fanon = (lambda x , y :  2*y - 1 + x)
fanon(1,0)

$0$

# Sem atribuição de uma variável

(lambda x , y :  2*y - 1 + x)(1,0)

$0$

Função definida "def"

• **Calculo da área de um Circulo **

def area(raio):
  areaCirc = pi * raio^2
  show('A área vale: ', n(areaCirc) )

area(2.4)

A área vale: $\displaystyle 18.0955736846772$

• Calculo das raizes de uma função polinomial do segundo grau utilizando a formula Bhaskara

def raiz(a,b,c):

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

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

    else:
        print ('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)

raiz(2,2,-5)

Delta: 44.000000

Raiz X1 = 1.158312

Raiz X2 = -2.158312

• Fibonacci

def fiboR_NORMAL(n):
    if n < 2:
        return n
    else:
        return fiboR_NORMAL(n-1) + fiboR_NORMAL(n-2)

%time

fiboR_NORMAL(30)

$832040$

CPU time: 0.79 s, Wall time: 0.79 s

Importando funções

Vá no menu dados e faça o upload do arquivo .py . Depois use:

# sem o '.py'

load('ffiboR_NORMAL.py')

%time

ffiboR_NORMAL(30)

$832040$

CPU time: 1.16 s, Wall time: 1.18 s

Importando um arquivo.py rodando o SAGE a partir do computador local

use o comando:

load("endereço do arquivo/arquivo.py").

EX: load("/home/jmarcellopereira/fiboR_SG.py")

Mapeamento

A função map( ) serve para aplicarmos uma função a cada elemento de uma lista, retornando uma nova lista contendo os elementos resultantes da aplicação da função.

Mapeamento com função simbólica

# uma variável

fx(x) = x^2

map(fx, range(0,4))

[$0$, $1$, $4$, $9$]

map(f, srange(0,4,0.5))

[$0$, $0.479425538604203 \, v$, $0.841470984807897 \, v$, $0.997494986604054 \, v$, $0.909297426825682 \, v$, $0.598472144103957 \, v$, $0.141120008059867 \, v$, $-0.350783227689620 \, v$]

# mais de uma variável

fxy(x,y) = x + y

map(fxy, range(0,4),range(0,4))

[$0$, $2$, $4$, $6$]

# Exemplo com matrizes

f(x)=x^2

A = matrix([[1,2],[3,4]])

A.apply_map(f)

$\left(\begin{array}{rr} 1 & 4 \\ 9 & 16 \end{array}\right)$

(matrix([[1,2],[3,4]])).apply_map(x^2)

$\left(\begin{array}{rr} 1 & 4 \\ 9 & 16 \end{array}\right)$

Mapeamento com função "def"

def quad(x):
    return x^2

map(quad, range(0,4))

[$0$, $1$, $4$, $9$]

def soma(x , y):
    return x + y

map(soma, range(0,4),range(0,4))

[$0$, $2$, $4$, $6$]

Mapeamento com função Anônima

map(lambda x : x^2, range(0,4))

[$0$, $1$, $4$, $9$]

map(lambda x : x^2, srange(0,2,0.5))

[$0.000000000000000$, $0.250000000000000$, $1.00000000000000$, $2.25000000000000$]

# trabalhando com duas variáveis, as ranges devem ser iguais em tamanho

map(lambda x,y : x + y, range(0,4),range(0,4))

[$0$, $2$, $4$, $6$]

Redução

A função reduce( ) aplica acumuladamente os ítens de uma seqüência de entrada a uma função de dois parâmetros até reduzir esse cálculo a um único valor de resposta. Ex:

reduce(lambda x, y: x + y, [47, 11, 42,13])

reduce com função def

# como funciona a função reduce aplicado a x + y

def soma_reduce (x , y ):
    print  ('somar( x = %s , y = %s ) -> %s' %(x , y , x + y ))
    return x + y

reduce ( soma_reduce , [47, 11, 42, 13 ])

somar( x = 47 , y = 11 ) -> 58 somar( x = 58 , y = 42 ) -> 100 somar( x = 100 , y = 13 ) -> 113

$113$

# como funciona a função reduce aplicado a x + y

def soma_reduce (x , y ):
    print  ('somar( x = %s , y = %s ) -> %s' %(x , y , x + y ))
    return x + y

reduce ( soma_reduce , [47, 11, 42, 13 ], 10)

somar( x = 10 , y = 47 ) -> 57 somar( x = 57 , y = 11 ) -> 68 somar( x = 68 , y = 42 ) -> 110 somar( x = 110 , y = 13 ) -> 123

$123$

def soma_reduce (x , y ):
    print  ('somar( x = %s , y^2 = %s ) -> %s' %(x , y^2 , x + y^2 ))
    return x + y^2

reduce ( soma_reduce , [47, 11, 42, 13 ], 10)

somar( x = 10 , y^2 = 2209 ) -> 2219 somar( x = 2219 , y^2 = 121 ) -> 2340 somar( x = 2340 , y^2 = 1764 ) -> 4104 somar( x = 4104 , y^2 = 169 ) -> 4273

$4273$

reduce com função Simbólica

fxy1(x,y) = x + y

reduce(fxy1, [47, 11, 42,13])

$113$

fxy2(x,y) = x + y^2

reduce(fxy2, [47, 11, 42,13])

$2101$

reduce com função Anonima

#

reduce(lambda x, y: x + y, [47, 11, 42,13])

$113$

#

reduce ( lambda x, y: x + y, [47, 11, 42, 13], 10)

$123$

#

reduce(lambda x, y: x + y^2, [47, 11, 42, 13],10)

$4273$

Filtragem

A função **filter ** devolve uma nova sequência formada pelos itens do segundo argumento para os quais funcao(item) é verdadeiro. Se a sequencia de entrada for string ou tupla, a saída será do mesmo tipo; caso contrário, o resultado será sempre uma lista.

filter com função Simbólica

# valores da range cujo resultado de f é maior que 10

f = x^2

filter(f > 10, range(1,10))

[$4$, $5$, $6$, $7$, $8$, $9$]

filter((f > 10)and(f < 50), range(1,10))

[$4$, $5$, $6$, $7$, $8$, $9$]

fxy(x,y) = x + y

filter com função def

reset()

# valores da range cujo resultado de f é maior que 10

def quad(x):
    return x^2

filter(quad(x) > 10, range(1,10))

[$4$, $5$, $6$, $7$, $8$, $9$]

filter((quad(x) > 20) and (quad(x) < 50), range(1,10))

[$5$, $6$, $7$, $8$, $9$]

filter com função Anônima

filter(lambda x: x^2 > 10, range(1,10))

[$4$, $5$, $6$, $7$, $8$, $9$]

CALCULOS DIVERSOS COM EQUAÇÕES, INEQUAÇÕES E FUNÇÕES

reset()

• Expansão dos termos de uma expressões

y = (x-2)^4 * (x-3)^3;
y

${\left(x - 2\right)}^{4} {\left(x - 3\right)}^{3}$

expand(y); y.expand()

$x^{7} - 17 \, x^{6} + 123 \, x^{5} - 491 \, x^{4} + 1168 \, x^{3} - 1656 \, x^{2} + 1296 \, x - 432$

$x^{7} - 17 \, x^{6} + 123 \, x^{5} - 491 \, x^{4} + 1168 \, x^{3} - 1656 \, x^{2} + 1296 \, x - 432$

• Fatorização

y = x^7 - 17*x^6 + 123*x^5 - 491*x^4 + 1168*x^3 - 1656*x^2 + 1296*x - 432;
y

$x^{7} - 17 \, x^{6} + 123 \, x^{5} - 491 \, x^{4} + 1168 \, x^{3} - 1656 \, x^{2} + 1296 \, x - 432$

factor(y);

y.factor()

${\left(x - 2\right)}^{4} {\left(x - 3\right)}^{3}$

${\left(x - 2\right)}^{4} {\left(x - 3\right)}^{3}$

• Frações parciais

fx(x) = (2*x^2 +3*x -1) / (x^2 - 3*x + 2);

fx(x)

$\frac{2 \, x^{2} + 3 \, x - 1}{x^{2} - 3 \, x + 2}$

fx.partial_fraction(x)

$x \ {\mapsto}\ -\frac{4}{x - 1} + \frac{13}{x - 2} + 2$

• Manipulações diversas

gx(x,y) = x*y^2 + sin(x)/sin(y) + x^5 - y^2

gx

$\left( x, y \right) \ {\mapsto} \ x^{5} + x y^{2} - y^{2} + \frac{\sin\left(x\right)}{\sin\left(y\right)}$

gx.numerator()

$\left( x, y \right) \ {\mapsto} \ x^{5} \sin\left(y\right) + x y^{2} \sin\left(y\right) - y^{2} \sin\left(y\right) + \sin\left(x\right)$

gx.denominator()

$\left( x, y \right) \ {\mapsto} \ \sin\left(y\right)$

gx.normalize()

$\left( x, y \right) \ {\mapsto} \ \frac{x^{5} \sin\left(y\right) + x y^{2} \sin\left(y\right) - y^{2} \sin\left(y\right) + \sin\left(x\right)}{\sin\left(y\right)}$

gx.powers(3)

[$\left( x, y \right) \ {\mapsto} \ 1$, $\left( x, y \right) \ {\mapsto} \ x^{5} + x y^{2} - y^{2} + \frac{\sin\left(x\right)}{\sin\left(y\right)}$, $\left( x, y \right) \ {\mapsto} \ {\left(x^{5} + x y^{2} - y^{2} + \frac{\sin\left(x\right)}{\sin\left(y\right)}\right)}^{2}$]

• Simplificação de expressões

simplify_full(), simplify_trig(), simplify_rational(), simplify_rectform() simplify_factorial(), simplify_log(), simplify_real(), simplify_hypergeometric(), canonicalize_radical()

frac_fx = 13/(x-2) + -4/(x-1) +2; frac_fx

$-\frac{4}{x - 1} + \frac{13}{x - 2} + 2$

frac_fx.simplify_full()

$\frac{2 \, x^{2} + 3 \, x - 1}{x^{2} - 3 \, x + 2}$

Substituir variável por um valor ou outra variável

Para substituir o valor de X na equação acima, utilizamos o comando subs(variável, variável_expressão, variavel/valor). Observe no exemplo 1, que a expressão de Y continua a mesma, só o valor de X que é alterado para o valor (2) e o cálculo é realizado (Y = 2). No exemplo 2, a variável X é alterada para W. E no exemplo 3, as variáveis X e W são substituídas por valores e outras variáveis

reset()

# definido a função

y(x) = x^2-3*x+2

y

$x \ {\mapsto}\ x^{2} - 3 \, x + 2$

Para substituir o valor de X na equação acima, utilizamos o comando var.subs(x = valor/variável). Observe no Exemplo 1, que a expressão de Y continua a mesma, só o valor de X que é alterado para o valor (0) e o cálculo é realizado (Y = 2). No exemplo 2, a variável X é alterada para W. E no exemplo 3, as variáveis X e W são substituídas por valores e outras variáveis

• Exemplo 1: substituição por um valor numérico

y

y.subs(x = 2);

$x \ {\mapsto}\ x^{2} - 3 \, x + 2$

$x \ {\mapsto}\ 0$

• Exemplo 2: substituição por uma variável

var('w')

y
y.subs(x = w)

$w$

$x \ {\mapsto}\ x^{2} - 3 \, x + 2$

$x \ {\mapsto}\ w^{2} - 3 \, w + 2$

• Exemplo 3: Para substituir mais de uma variável:

r(x,w) = x*w + 2

r
r.subs(x = 2,w = 1)

$\left( x, w \right) \ {\mapsto} \ w x + 2$

$\left( x, w \right) \ {\mapsto} \ 4$

var('p,q')

r
r.subs(x = p,w = q)

($p$, $q$)

$\left( x, w \right) \ {\mapsto} \ w x + 2$

$\left( x, w \right) \ {\mapsto} \ p q + 2$

• Resetar o valor da variável X e Y

reset('x,y')

%%%% FIM EQUAÇÕES, INEQUAÇÕES E FUNÇÕES