// diferenca simetrica
function DS=diffsim(A,B)
    // union une todos os elementos de cada conjunto
    // intersect intersecta todos os elementos comuns a ambos
    // setdiff exclui os elemetos de B a A
    // uniao excluindo a itersecao, igual a diferennca simetrica
    // unique remove todos os elementos duplicados do vetor
    DS=unique(setdiff(union(A,B),intersect(A,B)))
endfunction

// relacao composta
function M=relcomp(MR,MS)
    // bool2s serve para passar os valores diferentes de 0 para 1 havendo apenas
    // valores booleanos
    M=bool2s(MR*MS)
endfunction


// verificar simetria
function s=is_simetrica(M)
    // se a matriz relacao for igual a sua transposta entao e simetrica
    // outra abordagem seria verificar se a,b e b,a estao na relacao. se apenas
    // um deles estiver, entao nao e simetrica.
    if isequal(M,M')
        s=%t
    else
        s=%f
    end
endfunction


// fecho simetrico
function ret=fecho_simetrico(M)
    [u v]=size(M)
    for i=1:u
        for j=1:v
            // se existir um a,b tem de existir um b,a
            if M(i,j)<>M(j,i)
                // garantir a existencia de ambos: a,b e b,a
                M(i,j)=1
                M(j,i)=1
            end
        end
    end
    ret=M
endfunction


// verificar a transitividade
function t=is_transitiva(M)
    // se M for igual a M+M^2 significa que qualquer M^3.. M^n com n a ordem da
    // matriz dada, nunca ira mudar entao ela e transitiva. se ao inicio falhar,
    // existe pelo menos um elemento que falha para que ela seja transitiva
    if isequal(M,bool2s(M+M^2))
        t=%t
    else
        t=%f
    end
endfunction


// fecho transitivo
function t=fecho_transitivo(M)
    [u v]=size(M)
    t=M
    for i=2:u
        // adiciona todas as possibilidades de transitividade apartir da matriz
        // relacao original
        t=t+M^i
    end
    // coloca os valores diferetes de 0 a 1
    t=bool2s(t)
endfunction


// verificar a reflexividade
function r=is_reflexiva(M)
    [a b]=size(M)
    for i=1:a
        // verifica se a diagonal principal esta a 1. se tiver algum elemento a
        // zero, significa que nao e reflexiva
        if M(i,i)==0 then
            r=%f
            return
        end
    end
    r=%t
endfunction


// fecho reflexivo
function ret=fecho_reflexivo(M)
    [u v]=size(A)
    // coloca a diagonal principal a 1
    ret=bool2s(M+eye(u,v))
endfunction


// verifica se e uma relacao antissimetrica
function as=is_antissimetrica(M)
    [a b]=size(M)
    for i=1:a
        for j=1:b
            if i<>j & M(i,j)==1 & M(j,i)==1 then
                as=%f
                return
            end
        end
    end
    as=%t
endfunction


// verifica se e uma relacao de equivalencia
function ret=is_equival(M)
    // para ser uma relacao de equivalencia, tem de ser reflexiva, simetrica e
    // transitiva
    ret = is_reflexiva(M) & is_simetrica(M) & is_transitiva(M)
endfunction


function e=equival(M)
    [a b]=size(M)
    if is_equival(M) then
        //"A rela??o dada ? uma rela??o de equival?ncia
        e=M;
        return
    else
        //A rela??o dada n?o ? uma rela??o de equival?ncia. A menor rela??o de
        // equival?ncia que cont?m a rela??o R tem a seguinte matriz de rela??o:
        A=bool2s(eye(a,b)+M+M')
        e=zeros(a,b)
        for i=1:a
            e=e+A^i
        end
        e=bool2s(e)
    end
endfunction


// verifica se e relacao de ordem parcial
function ret=is_ordem_parcial(M)
    // para ser relacao de ordem parcial a relacao tem de ser reflexiva,
    // antissimetrica e transitiva
    ret = is_reflexiva(M) & is_antissimetrica(M) & is_transitiva(M)
endfunction


// devolve a matriz de caminhos apartir da matriz de adjacencias do grafo
// util para saber se existe caminho e quantos caminhos existem
function MC=matriz_gcaminhos(A)
    [u,v]=size(A)
    MC=A
    for i=2:u
        MC=MC+A^i
    end
endfunction


// verifica se o grafo e fortemente conexo
function FC=forteconexo(A)
    [u,v]=size(A)
    S=matriz_gcaminhos(A)
    for i=1:u
        for j=1:v
            // para verificar se e fortemente conexo, tem que existir caminho
            // para todos os vertices
            if S(i,j)==0 then
                FC=%f
                return
            end
        end
    end
    FC=%t
endfunction


// verifica se o grafo e unilateralmente conexo
function UC=unilateralconexo(A)
    [u,v]=size(A)
    S=matriz_gcaminhos(A)

    // para verificar o vertice i,j ou j,i
    T=S+S'

    for i=1:u
        for j=1:v
            // se nenhum deles for alcancavel nao e unilateralmente conexo
            if i<>j & T(i,j)==0 then
                UC=%f
                return
            end
        end
    end
    UC=%t
endfunction


// verifica se o grafo e fracamente conexo
function frC=fracaconexo(A)
    [u,v]=size(A)

    V=matriz_gcaminhos(A+A')

    for i=1:u
        for j=1:v
            if V(i,j)==0 then
                frC=%f
                return
            end
        end
    end

    frC=%t
endfunction


// verifica se o grafo e conexo ou disconexo
function ret=conetividade(A)
    if forteconexo(A) | unilateralconexo(A) | fracaconexo(A) then
        ret=%t
    else
        ret=%f
    end
endfunction


// retorna os graus de saida de um vertice num grafo
function ret=graus_out(A,v)
    [a,b]=size(A)

    ret=0
    for i=1:a
        ret=ret+A(v,i)
    end
endfunction


// retorna os graus de entrada de um vertice num grafo
function ret=graus_in(A,v)
    [a,b]=size(A)

    ret=0
    for i=1:a
        ret=ret+A(i,v)
    end
endfunction


// devolve o numero de pocos do grafo
function v=pocos_grafo(A)
    [a,b]=size(A)
    v=0;
    for i=1:a
        if graus_out(A,i) == 0
            v=v+1
        end
    end
endfunction


// devolve o numero de fontes do grafo
function v=fontes_grafo(A)
    [a,b]=size(A)
    v=0;
    for i=1:a
        if graus_in(A,i) == 0
            v=v+1
        end
    end
endfunction