Visur – Minha aventura pelos cáculos!

Bem, pelas minhas aventuras em novas linguagens, conheci o Python.
Acreditem, é uma linguagem magnífica. Libs para tudo, sintaxe limpa, fácil, usado em grandes empresas e SUPERPODEROSA.
Querendo aprender melhor Python, acabei juntando ela a outra paixão: Matemática. Logo depois de aprender a resolver inequações de formas variadas (e percebendo a constância na resolução), comecei um programa que agilizasse o processo.

Daí nasceu o Visur (nome veio da junção de Vicente – meu sobrenome -, e Mansur – quem me ensinou os métodos que possibilitaram a criação do programa).

Ele funciona da seguinte forma:
Você coloca uma equação suportada pelo programa, aperta Calcular e ele retorna o conjunto solução. Ele atualmente só não suporta inequações produto. Tem interface gráfica e mostra a resolução no caso de inequações quociente do primeiro grau.
Essa característica que é a marcante. Meu projeto é que ele mostre a resolução de todos os tipos, para fins educativos. Porque de programas que só resolvem o mundo está cheio. Temos Mathematica e, mais recentemente, um programa online: wolframalpha, que seria inútil eu tentar ser melhor. Ele vem de um software de 20 anos feito por uma empresa reconhecida mundialmente, enquanto o Visur é feito por um aluno do Ensino Médio de 15 anos e tem pouco mais de 6 meses xD

Não chega a ter 1000 linhas, consegui enxugar MUITA COISA, e os maiores desafios foram na resolução de inequações quociente do segundo grau. Tive que usar combinação simples sem repetição em um if e, caso não fosse assim, ficaria uma gambiarra feia.

Tenho prints dele no meu Orkut (tá no ‘Sobre mim’, e os álbuns não estão bloquados). Deem uma conferida!
Logo logo, quando tiver mais tempo, disponibilizarei para baixarem e mudarem o source.
Está em Python e até tem como passar para .exe, mas seria ridículo. Em Python, tem 30kb, em forma executável tem uns 30mb.

E tá aí, VISUR! XD

Matemática aplicada ao PHP – Arrays II

Bem, agora vamos a um anexo da ‘matéria’, mas agora de uma forma mais analítica.

Vamos fazer um algoritmo para calcular o P de um conjunto. O P de um conjunto é o número de possibilidades de subconjuntos que dá para se fazer com seus elementos.

Vale ressaltar que, nos subconjuntos, sempre existe o subconjunto VAZIO, o ∅. Ele pode ser expressado com colchetes vazios ( { } ) ou a letra grega que já apresentei, o ∅. Gosto mais do ∅.

Logo, se existe o conjunto B:

B = {m, n, p}

Os seus subconjuntos são as possibilidades de conjuntos que podem ser feitas com seus elementos, sendo, no caso:

Com um elemento: {m}, {n}, {p}

Com dois elementos: {m,n}, {m,p}, {n,p}

Com três elementos: {m, n, p}

Bem, como só há 3 elementos, acabamos por aqui. Como também todo P de um conjunto tem o subconjunto ∅.

Logo, P(B) = {∅, {m}, {n}, {p}, {m,n}, {m,p}, {n,p}, {m, n, p}}

Mas, se quisermos saber o número de subconjuntos do P de algum conjunto precisamos de fazer isso? Amagad, seria péssimo! Logo, usamos o algoritmo:

a = número de elementos de um conjunto D qualquer

n[ P(D) ] = 2^a

No caso do último exemplo do conjunto B, com 3 elementos, n[ P(B) ] seria igual a 2³, logo, n[ P(B) ] = 8 !

Agora vamos paralelizar ao PHP! 😀 Chegou a boa hora!

Bem, mesmo eu sendo viciado em programação orientada a objetos, vamos fazer só uma função.

function np($a)
{
}

Pronto, demos nome! np (n de P de, no caso, $a! :D)

Qual é o primeiro passo? Verificar se é um conjunto, ué!

function np($a)
{
if (!is_array($a))
{
throw new Exception(“Wrong Parameter: We only accept arrays.”);
}
}

Agora, se não for array o parâmetro passado, ele mandará uma exceção! Legal… Agora, teremos que formar um bloco try/catch para isso se validar… Mas vamos antes pensar no próximo passo do algoritmo, que é… pegar o número de elementos! Porém, no caso, teremos que só aceitar arrays com 1 chave, não podemos aceitar arrays associativos… Logo, usaremos array_values!

Assim…
(int) $n = count(array_values($a));

perfeito! 😀
Já temos boa parte feita! Agora só falta elevar o 2 à variável $n e retornar esse valor! Logo…

$returner = pow(2, $n);

😀

Agora a função inteira!

function np($a)
{
if (!is_array($a))
{
throw new Exception(“Wrong Parameter: We only accept arrays.”);
}

try
{
(int) $n = count(array_values($a));
$returner = pow(2, $n);
return $returner;
}
catch(Exception $e)
{
echo $e->getMessage().”\n”;
}
}

Pronto! Nossa funçãozinha está pronta! 😀 Tente:
$a = array(“oi”, “v”, “iu”);
echo np($a);

E verás!

😀

FlwS e até a próxima !

Matemática aplicada ao PHP – Arrays

Bem, eu no meu curso de matemática mais ‘avançado’, estava estudando conjuntos. Sim, aquela matéria aparentemente simples que nos ensinam na escola, mas nos ensinam porcamente. MUITA coisa passa e acreditem, vi questões que nunca imaginei terem um grau tão grande de dificuldade envolvendo somente conjuntos.

Porém, enquanto estava lendo a teoria básica, aquela explanação antes de ‘partir pro fight’ e começarem os exercícios (só desafio :P), eu percebi o porquê (percebi REALMENTE) de dizerem que a programação depende da matemática.

Sim, depois da parte ‘burocrática’ e básica que todos sabemos de matemática na programação e da interpretação que pode envolver, coisas mais simples se aplicam claramente a ela.

Começando relacionando Arrays com Conjuntos:

Bem, um array é um conjunto caracterizado e uma explicação perfeita pra quem quer uma definição. Ela agrupa elementos num mesmo grupo, sendo que esses elementos também podem ser grupos (arrays dentro de arrays, ou arrays bidimensionais).

Matemática:

A = {a, e, i, o, u}

No caso, o conjunto A com todas as vogais.
Em PHP:

$A = array(‘a’, ‘e’, ‘i’, ‘o’, ‘u’);

Agora, em PHP, uma explanação equivalente, só que na forma de um array com as mesmas características da explicação matemática, encapsulada numa variável, que no caso corresponderia ao conjunto.

Agora a união de conjuntos:

A = {a, e, i}
B = {a, a, a, e, o, u}

Qual seria o resultado de A união B ?
Chamaremos A união B de D, logo..:
D = {a, e, i, o, u}

Não é necessário, pelo menos na matemática, valores serem repetidos em conjuntos, {a, a, a} é completamente igual a {a}.
Em PHP, equivalente seria:

$A = array(‘a’, ‘e’, ‘i’);
$B = array(‘a’, ‘a’, ‘a’, ‘e’, ‘o’, ‘u’);
$D = array_unique( array_merge( $A, $B ) );

Array_merge equivale à união de conjuntos. Coloquei a função array_unique ali para não existirem resultados repetidos, como o (‘a’,’a’,’a’).

Vamos para mais uma operação, e essa, com muitos que têm dificuldade, mostra que é exatamente o que acontece no PHP, a subtração de arrays.
Bem, como já disse, subtração de arrays causa muitos problemas a alguns desenvolvedores, normalmente os mais novatos. Como não é algo EXATO, não é um número, a forma mais fácil de se pensar uma subtração de conjuntos (no caso, arrays), é pensar no que o PRIMEIRO CONJUNTO tem que o SEGUNDO NÃO TEM.

Exemplo

A = {1, 2}
B = {2, 3, 4}

A – B = {1}

Como vêem, o 1, que é o resultado da subtração, é o elemento que A tem e B não tem!
Se fosse o contrário, seria:

B – A = {3, 4}

No PHP, seria algo assim:

$A = array(1, 2);
$B = array(2, 3, 4);

$C = array_diff($A, $B);

Array_diff é a nossa ‘diferença de conjuntos’ no PHP, que fará a diferença de $A – $B (dê um print_r($C) e verás) ! Seria legal se isso fosse uma coisa mais natural em PHP, sem precisar de uma função especial, mas fazer o quê…

Agora vem uma parte bem legal, em que eu tenho algumas histórias pra falar… Geralmente, quando passava no manual, nem dava importância para as funções array_intersect_*, ou mesmo o próprio array_intersect, parece até engraçado… Também, não precisava muito em projetos (não sei como não precisaria de uma função dessas até aquele momento, mas essas são as chamadas ironias da vida!) e, quando finalmente fui precisar, fiquei encucado pra achar!

Mal sabia eu que, interseção de conjuntos era o que eu precisava! E ela se resumia num cognato (palavras que se parecem em inglês e português, no caso intersect e interseção) !

Agora, sem mais blá-blá-blá, vamos fazer a nossa paralelização!

A = {1, 2}
B = {2, 3, 4}
A inter B = {2}

Como vimos, o conjunto A em interseção com B, resulta no elemento 2, pois ele está presente tanto no A quanto no B!

Em PHP seria:

$A = array(1, 2);
$B = array(2, 3, 4);
$C = array_intersect($A, $B);

E, como sempre, se quiser verificar o resultado, o famoso print_r($C) !

Viu como bastante coisa coincide?

Vlw e até o próximo post!