Looplex Knowledge Base

Lista de operadores

Lista de operadores

Operadores lógicos

Equals

O operador relacional Equals verifica a igualdade entre dois valores. Sua forma de uso é value1 == value2. Exemplo: 

operations {
    if (<x> == <y>) {
        print "O valor das variáveis é idêntico!"
    }
}

Greater

O operador relacional Greater verifica se um valor é maior que outro. Sua forma de uso é value1 > value2. Exemplo:

operations {
    if (<x> > 10) {
        print "O valor da variável é superior a 10"
    }
}

Greater Equals

O operador relacional Greater Equals verifica se um valor é maior ou igual a outro. Sua forma de uso é value1 >= value2. Exemplo:

operations {
    if (<y> >= 10) {
        print "A variável tem valor igual ou superior a 10"
    }
}

Less Equals

O operador relacional Less Equals verifica se um valor é se um valor é menor ou igual a outro. Sua forma de uso é value1 ⇐ value2. Exemplo: 

operations {
    if (<x> ⇐ 10) {
        print "O valor da variável é igual ou inferior a 10"
    }
}

Less

O operador relacional Less verifica se um valor é se um valor é menor que outro. Sua forma de uso é value1 < value2. Exemplo: 

operations {
    if (<x> < 10) {
        print "O valor da variável é inferior a 10"
    }
}

Not Equals

O operador relacional Not Equals verifica a desigualdade entre dois valores. Sua forma de uso é value1 ~= value2. Exemplo: 

operations {
    if (<x> ~= 0) {
        print "O valor da variável é diferente de 0"
    }
}

Conectivos lógicos

AND

O conectivo conjuntivo AND é usado para concatenar condições de modo a uni-las por meio de E-lógico. Sua forma de uso é cond1 AND cond2. Exemplo:

operations {
    if (<x> > 10 AND <y> > 0) {
        print "A variável <x> é maior que 10 e a variável <y> é maior que 0"
    }
}

NOT

A negação NOT é usada para inverter o conteúdo lógico de uma expressão, representando o NÃO-lógico. Sua forma de uso é NOT value. Exemplo: 

operations {
    if(NOT <ehPessoaFisica> OR NOT(<y> > 0)) {
        print "A variável <ehPessoaFisica> não é verdadeira ou a variável <y> não é maior que 0."
    }
}

Nota: O NOT via de regra, é usado com a condição entre parênteses. Só não precisamos usar os parênteses quando usamos com uma variável boolean

OR

O conectivo disjuntivo OR é usado para concatenar condições de modo a uni-las por meio de OU-lógico. Sua forma de uso é cond1 OR cond2. Exemplo: 

operations {
    if (<x> > 10 OR <y> > 0) {
        print "A variável <x> é maior que 10 e/ou a variável <y> é maior que 0"
    }
}

XOR

O conectivo disjuntivo XOR é usado para concatenar condições de modo a uni-las por meio de OU-lógico com exclusividade. Sua forma de uso é cond1 XOR cond2. Exemplo: 

operations {
    if (<x> > 10 XOR <y> > 0) {
        print "A variável <x> é maior que 10 ou a variável <y> é maior que 0" 
    }
}

Operadores aritméticos

Div

A operador matemático div realiza a divisão entre dois valores, sua forma de uso é value1 / value2. Se ambos os valores forem inteiros, realiza uma divisão inteira, e se pelo menos um dos valores forem reais (Real ou Currency), realiza a divisão fracionária. Exemplo: 

declarations {
    -<exemplo01> : Integer,
    -<exemplo02> : Real
}
operations {
    <exemplo01> = 11 / 2, // resultado: 5
    <exemplo02> = 11.0 / 2, // resultado: 5,50
    print "11/2 devolve " & <exemplo01> & " e 11.0/2 devolve " & <exemplo02>
}

Mod

A operador matemático mod obtém o resto da divisão inteira entre dois valores inteiros, sua forma de uso é value1 % value2. Exemplo:

declarations {
    -<varResultado> : Integer
}
operations {
    <varResultado> = 11 % 2, // resultado: 1
    print "11 % 2 devolve " & <varResultado>
}

Mul

A operador matemático mul realiza a multiplicação entre dois valores, sua forma de uso é value1 * value2. Exemplo: 11.4*2 devolve 22.8

declarations {
    -<varResultado> : Real
}
operations {
    <varResultado> = 11.4 * 2, // resultado: 22.8
    print "11.4 * 2 devolve " & <varResultado>
}

Pow

A operador matemático pow realiza a potenciação entre dois valores, sua forma de uso é value1 ^ value2. Exemplo:

declarations {
    -<varResultado> : Integer
}
operations {
    <varResultado> = 10 ^ 2, // resultado: 100
    print "10 ^ 2 devolve " & <varResultado>
}

Sub

A operador matemático sub realiza a subtração entre dois valores, sua forma de uso é value1 - value2. Exemplo: 10-2 devolve 8

declarations {
    -<varResultado> : Integer
}
operations {
    <varResultado> = 10 - 2, // resultado: 8
    print "10 - 2 devolve " & <varResultado>
}

Sum

A operador matemático sum realiza a soma entre dois valores, sua forma de uso é value1 + value2. Exemplo:

declarations {
    -<varResultado> : Integer
}
operations {
    <varResultado> = 10 + 2, // resultado: 10
    print "10 + 2 devolve " & <varResultado>
}

Operadores para texto

Concatenation (&)

A operador matemático strcat realiza a concatenação entre dois valores em uma String. Sua notação é value1 & value2. No exemplo usaremos a variável <varString> para receber um valor e usá-la no print concatenada com a string "Casa número ". 

declarations {
    -<varString> : String
}
operations {
    <varString> = 2,
    
    print "Casa número " & <varString> // devolve: Casa número 2
}

Operadores de inclusão

In

O operador de inclusão IN é usado para testar condições em que um elemento pertença a um determinado vetor ou lista não-atômica.
No exemplo abaixo declaramos uma lista não-atômica e um vetor de string. Nas operações, temos uma sequência de "if" com o operador IN avaliando se um determinado item da lista foi selecionado pelo usuário. Se um item foi selecionado, usamos o tube add para adicionar uma string no vetor oculto.
Ao final, usamos o "if" com o operador IN para avaliar se um determinado item se encontra no vetor, caso positivo ele fará um print com um texto relacionado ao item. 

declarations {
    +<pedidos> : List ("Danos materiais", "Danos morais", "Justiça gratuita") {
        atomic = false
        name = "Pedidos"
    },
    -|vetorPedidos| : Vector[String]
}
operations {
    if ("Danos materiais" IN <pedidos>) {
        |vetorPedidos|.add("Pedido de danos materiais")
    },
    if ("Danos morais" IN <pedidos>) {
        |vetorPedidos|.add("Pedido de danos morais")
    },
    if ("Justiça gratuita" IN <pedidos>) {
        |vetorPedidos|.add("Pedido de justiça gratuita")
    },
    if ("Pedido de danos materiais" IN |vetorPedidos|) {
        print "Pedido de indenização por danos materiais\b"
    },
    if ("Pedido de danos morais" IN |vetorPedidos|) {
        print "Pedido de indenização por danos morais\b"
    },
    if ("Pedido de justiça gratuita" IN |vetorPedidos|) {
        print "Pedido de concessão do benefício da justiça gratuita\b"
    }
}

Exists

O operador existencial EXISTS é usado para testar condições em que um elemento pertença a um determinado vetor segundo um critério de existência. Sua forma de uso é EXISTS <elem> IN |vect| : condition. No exemplo abaixo declaramos um vetor de estrutura. Nas operações temos dois "if" com o operador EXISTS avaliando se existe ao menos um elemento do vetor com a condição determinada.

declarations {
    +|strPartesAutoras| : Vector[Struct] {
        name = "Parte autora"
        fields {
            +[nome] : String  {
                name = "Nome"
            },
            +[tipo] : List ("Pessoa Física", "Pessoa Jurídica") {
                atomic = true
                name = "Tipo de pessoa"
            }
        }
    }
}
operations {
    if (EXISTS <autora> IN |strPartesAutoras| : "Pessoa Física" == <autora.tipo>) {
        print "Texto usado se existir ao menos uma autora no vetor |strPartesAutoras| que seja Pessoa Física.\b"
    },
    if (EXISTS <autora> IN |strPartesAutoras| : "Pessoa Jurídica" == <autora.tipo>) {
        print "Texto usado se existir ao menos uma autora no vetor |strPartesAutoras|que seja Pessoa Jurídica.\b"
    }
}

Forall

O operador universal FORALL é usado para testar condições em que um elemento pertença a um determinado vetor segundo um critério de universalidade. Sua forma de uso é FORALL <elem> IN |vect| : condition. No exemplo abaixo declaramos um vetor de estrutura. Nas operações temos dois "if" com o operador FORALL avaliando se todos elementos do vetor possuem a condição determinada.

declarations {
    +|strPartesAutoras| : Vector[Struct] {
        name = "Parte autora"
        fields {
            +[nome] : String  {
                name = "Nome"
            },
            +[tipo] : List ("Pessoa Física", "Pessoa Jurídica") {
                atomic = true
                name = "Tipo de pessoa"
            }
        }
    }
}
operations {
    if (FORALL <autora> IN |strPartesAutoras| : "Pessoa Física" == <autora.tipo>) {
        print "Texto usado se todas autoras são Pessoa Física."
    },
    if (FORALL <autora> IN |strPartesAutoras| : "Pessoa Jurídica" == <autora.tipo>) {
        print "Texto usado se todas autoras são Pessoa Jurídica."
    }
}
Edit this page on GitHub

Prev

Templates de lógica

Next

Tubes

On this page