One place for hosting & domains

      matemáticos

      Como fazer cálculos matemáticos com operadores em Go


      Introdução

      Os números são comuns na programação. Eles são usados para representar coisas como: dimensões de tela, localizações geográficas, dinheiro e pontos, a quantidade de tempo que passa em um vídeo, posições de avatares de jogos, cores através da atribuição de códigos numéricos e assim por diante.

      O desempenho eficaz das operações matemáticas na programação é uma habilidade importante a se desenvolver, tendo em vista a frequência com a qual você vai trabalhar com números. Embora a compreensão de alto grau da matemática possa ajudar você a ser um melhor programador, tal compreensão não é um pré-requisito. Se você não tiver experiência em matemática, tente pensar nela como uma ferramenta para realizar o que quiser alcançar e também como uma maneira de melhorar seu pensamento lógico.

      Trabalharemos com dois tipos de dados mais usados em Go – os números inteiros e os floats:

      • Os inteiros, como o próprio nome diz, são número inteiros que podem ser positivos, negativos, ou 0 (…, -1, 0, 1, …).
      • Os floats são números reais que contêm casas decimais, como 9.0, ou -2.25.

      Este tutorial irá rever os operadores que podemos usar com os tipos de dados no Go.

      Operadores

      Um operador é um símbolo ou função que indica uma operação. Por exemplo, na matemática o sinal de mais ou + é o operador que indica a adição.

      Na linguagem Go, vamos ver alguns operadores familiares que são trazidos da matemática. No entanto, outros operadores que usaremos são específicos para a programação de computadores.

      Aqui está uma tabela de referência rápida de operadores relacionados à matemática em Go. Neste tutorial, vamos falar sobre todas as operações a seguir.

      Operação O que ela retorna
      x + y Soma de x e y
      x - y Diferença entre x e y
      -x Muda o sinal de x
      +x Identidade de x
      x * y Produto de x e y
      x / y Quociente de x e y
      x % y Resto de x / y

      Também vamos abordar os operadores de atribuição de compostos, incluindo o += e *=, que combinam operadores matemáticos com o operador =.

      Adição e subtração

      Em Go, os operadores de adição e subtração são executados assim como fazem na matemática. De fato, você pode usar a linguagem de programação Go como uma calculadora.

      Vamos examinar alguns exemplos, começando com os inteiros:

      fmt.Println(1 + 5)
      

      Output

      6

      Em vez de enviar os inteiros diretamente para a instrução fmt.Println, podemos inicializar variáveis para representar os valores inteiros usando a sintaxe como segue:

      a := 88
      b := 103
      
      fmt.Println(a + b)
      

      Output

      191

      Como os inteiros podem ser números positivos e negativos (e também 0), podemos adicionar um número negativo a um número positivo:

      c := -36
      d := 25
      
      fmt.Println(c + d)
      

      Output

      -11

      A adição irá comportar-se de maneira parecida com os floats:

      e := 5.5
      f := 2.5
      
      fmt.Println(e + f)
      

      Output

      8

      Como adicionamos dois floats juntos, o Go retornou um valor float com uma casa decimal. No entanto, como a casa decimal é zero neste caso, a fmt.Println retirou a formatação decimal. Para formatar a saída corretamente, podemos usar fmt.Printf e o verbo %2f, que irá formatar para duas casas decimais, desta forma:

      fmt.Printf("%.2f", e + f)
      

      Output

      8.00

      A sintaxe da subtração é a mesma que a da adição, exceto que mudamos o operador do sinal de mais (+) para o sinal de menos (-):

      g := 75.67
      h := 32.0
      
      fmt.Println(g - h)
      

      Output

      43.67

      Em Go, podemos usar somente os operadores nos mesmos tipos de dados. Não podemos somar um int e um float64:

      i := 7
      j := 7.0
      fmt.Println(i + j)
      

      Output

      i + j (mismatched types int and float64)

      Tentar usar os operadores em tipos de dados diferentes resultará em um erro de compilação.

      Operações aritmética unárias

      Uma expressão matemática unária consiste de apenas um componente ou elemento. Na linguagem Go, podemos usar os sinais mais e menos, como um único elemento com um valor para: retornar a identidade do valor (+), ou alterar o sinal do valor (-).

      Embora não seja comumente usado, o sinal mais indica a identidade do valor. Podemos usar o sinal de mais com valores positivos:

      i := 3.3
      fmt.Println(+i)
      

      Output

      3.3

      Ao usarmos o sinal de mais com um valor negativo, ele também retornará a identidade daquele valor e, neste caso, seria um valor negativo:

      j := -19
      fmt.Println(+j)
      

      Output

      -19

      Com um valor negativo, o sinal de mais retorna o mesmo valor negativo.

      No entanto, o sinal de menos muda o sinal de um valor. Então, quando enviarmos um valor positivo, vamos descobrir que o sinal de menos antes do valor retornará um valor negativo:

      k := 3.3
      fmt.Println(-k)
      

      Output

      -3.3

      De forma alternativa, quando usamos o operador unário de sinal menos com um valor negativo, será retornado um valor positivo:

      j := -19
      fmt.Println(-j)
      

      Output

      19

      As operações aritméticas unárias, indicadas pelo sinal de mais e de menos retornarão a identidade do valor no caso de +i ou o sinal oposto do valor como em -i.

      Multiplicação e divisão

      Como na adição e na subtração, a multiplicação e a divisão ficarão muito semelhantes à forma como elas funcionam na matemática. O sinal que usaremos para a multiplicação no Go é * e o sinal que usaremos para a divisão é a /.

      Aqui está um exemplo de como fazer uma multiplicação em Go com dois valores float:

      k := 100.2
      l := 10.2
      
      fmt.Println(k * l)
      

      Output

      1022.04

      Em Go, a divisão tem características diferentes, dependendo do tipo numérico que estivermos dividindo.

      Se estivermos dividindo números inteiros, o operador / do Go executará a divisão com arredondamento para baixo, onde para o quociente x, o número retornado será o maior número inteiro menor que ou igual a** x**.

      Se você executar o exemplo a seguir, fazendo a divisão 80 / 6, receberá 13 como o resultado e o tipo de dados será um int:

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          m := 80
          n := 6
      
          fmt.Println(m / n)
      }
      

      Output

      13

      Se o resultado desejado for um float, você precisa converter explicitamente os valores antes da divisão.

      Você pode fazer isso envolvendo seus valores com o seu tipo float desejado de float32() ou float64():

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          s := 80
          t := 6
          r := float64(s) / float64(t)
          fmt.Println(r)
      }
      

      Output

      13.333333333333334

      Módulo

      O operador % é o módulo que, após a divisão, retorna o resto em vez do quociente. Isso é útil para a descoberta de números que sejam múltiplos do mesmo número.

      Vamos examinar um exemplo do módulo:

      o := 85
      p := 15
      
      fmt.Println(o % p)
      

      Output

      10

      Desdobrando isso tudo, temos que 85 dividido por 15 retorna o quociente 5 com um resto de 10. Nosso programa retorna o valor 10 aqui, uma vez que o operador módulo retorna o resto de uma expressão de divisão.

      Para fazer cálculos de módulos com tipos de dados float64, você usará a função Mod do pacote math:

      package main
      
      import (
          "fmt"
          "math"
      )
      
      func main() {
          q := 36.0
          r := 8.0
      
          s := math.Mod(q, r)
      
          fmt.Println(s)
      }
      

      Output

      4

      Precedência de operador

      Na linguagem Go, assim como na matemática, precisamos ter em mente que os operadores serão avaliados por ordem de precedência e não da esquerda para a direita ou da direta para a esquerda.

      Se examinarmos a seguinte expressão matemática:

      u = 10 + 10 * 5
      

      Podemos lê-la da esquerda para a direita, mas a multiplicação será feita primeiro; assim, se tivéssemos que imprimir u, receberíamos o seguinte valor:

      Output

      60

      Isso acontece porque 10 * 5 é igual a 50 e, em seguida, adicionamos 10 para retornar 60 como o resultado final.

      Se, em vez disso, quiséssemos somar o valor de 10 a 10 e depois multiplicássemos aquela soma por 5, usaríamos parênteses em Go, assim como faríamos na matemática:

      u := (10 + 10) * 5
      fmt.Println(u)
      

      Output

      100

      Uma maneira de lembrar a ordem da operação é através do acrônimo PEMDAS:

      Ordem Letra Representa
      1 P Parênteses
      2 E Expoente
      3 M Multiplicação
      4 D Divisão
      5 A Adição
      6 S Subtração

      Você pode estar familiarizado com outro acrônimo para a ordem das operações, como o BEDMAS ou BODMAS. Qualquer que seja o acrônimo que funcione melhor para você, procure tê-lo em mente ao realizar operações matemáticas em Go para que os resultados que você espera sejam retornados.

      Operadores de atribuição

      O operador de atribuição mais comum é aquele que você já usou: o sinal igual =. O operador de atribuição = atribui o valor à direita para uma variável à esquerda. Por exemplo, o v = 23 atribui o valor do inteiro 23 à variável v.

      Ao programar, é comum usar operadores de atribuição compostos que realizam uma operação no valor de uma variável e, depois, atribuem o novo valor resultante para aquela variável. Esses operadores compostos combinam um operador aritmético com o operador =. Portanto, para a adição vamos combinar + com = para obter o operador composto +=. Vejamos como fica:

      w := 5
      w += 1
      fmt.Println(w)
      

      Output

      6

      Primeiro, definimos a variável w igual ao 5 e, depois, usamos o operador de atribuição composto += para somar o número da direita ao valor da variável à esquerda; em seguida, atribuímos o resultado para w.

      Os operadores de atribuição compostos são usados frequentemente no caso de loops for, que você usará quando quiser repetir um processo várias vezes:

      package main
      
      import "fmt"
      
      func main() {
      
          values := []int{0, 1, 2, 3, 4, 5, 6}
      
          for _, x := range values {
      
              w := x
      
              w *= 2
      
              fmt.Println(w)
          }
      
      }
      

      Output

      0 2 4 6 8 10 12

      Ao usar um loop for para iterar na fatia chamada valores, você pôde automatizar o processo do operador *=, o qual multiplicou a variável w pelo número 2 e, então, atribuiu o resultado de volta para a variável w.

      Go tem um operador de atribuição composto para cada um dos operadores aritméticos discutidos neste tutorial.

      Para adicionar e, então, atribuir o valor:

      y += 1
      

      Para subtrair e, então, atribuir o valor:

      y -= 1
      

      Para multiplicar e, então, atribuir o valor:

      y *= 2
      

      Para dividir e, então, atribuir o valor:

      y /= 3
      

      Para retornar o resto e, então, atribuir o valor:

      y %= 3
      

      Os operadores de atribuição compostos podem ser úteis quando as coisas precisam ser aumentadas ou diminuídas, de maneira incremental, ou quando você precisar automatizar certos processos em seu programa.

      Conclusão

      Este tutorial tratou de muitos dos operadores que você usará com os tipos de dados numéricos inteiros e float. Você pode aprender mais sobre os diferentes tipos de dados em Entendendo tipos de dados em Go e em Como converter tipos de dados.



      Source link

      Cómo hacer cálculos matemáticos en Go con operadores


      Introducción

      En el ámbito de la programación, los números son comunes. Se utilizan para representar aspectos como dimensiones de tamaños de pantalla, ubicaciones geográficas, dinero y puntos, el tiempo transcurrido de un video, posiciones de avatares, colores mediante la asignación de códigos numéricos, entre otros.

      En el sector de la programación, desarrollar la capacidad de realizar operaciones matemáticas de forma eficaz es importante debido a la frecuencia con la que se trabaja con números. Si bien tener conocimientos matemáticos avanzados ciertamente puede servirle a programar mejor, no es un requisito previo. Si no tiene conocimientos matemáticos previos, trate concebir la matemática como una herramienta para lograr sus objetivos y como una forma de mejorar su pensamiento lógico.

      Trabajaremos con dos de los tipos de datos numéricos más utilizados en Go: enteros y flotantes:

      • Los enteros son números enteros que pueden ser positivos, negativos o 0 (…, -1, 0, 1,…).
      • Los flotantes son números reales que contienen un punto decimal, como 9.0 o -2.25.

      En este tutorial, analizaremos los operadores que podemos usar con tipos de datos numéricos en Go.

      Operadores

      Un operador es un símbolo o una función que indica una operación. Por ejemplo, en matemática, el signo más o + es el operador que indica suma.

      En Go, veremos algunos operadores conocidos que provienen de la matemática. Sin embargo, otros operadores que usaremos son específicos de la programación informática.

      A continuación, se muestra una tabla de referencia rápida de los operadores relacionados con la matemática que se usan en Go. En este tutorial se abarcan todas las funciones que se indican a continuación.

      Operación Lo que muestra
      x + y​​​ Suma de x e y
      x - y​​ Diferencia entre x e y
      -x Cambio de signo de x
      +x Identidad de x
      x * y​​ Producto de x e y
      x / y​ Cociente de x e y
      x % y​​ Resto de x e y

      También veremos los operadores de asignación compuestos, como += y *=, en los que se combinan un operador aritmético con el operador =.

      Suma y resta

      En Go, los operadores de resta funcionan con los mismos principios que la operación matemática. De hecho, puede usar el lenguaje de programación Go como una calculadora.

      Veamos algunos ejemplos, comenzando por los enteros:

      fmt.Println(1 + 5)
      

      Output

      6

      En lugar de pasar enteros directamente a la instrucción fmt.Println, podemos inicializar variables que representen valores enteros usando sintaxis como la siguiente:

      a := 88
      b := 103
      
      fmt.Println(a + b)
      

      Output

      191

      Debido a que los números enteros pueden ser tanto positivos como negativos (y también 0), podemos añadir un número negativo con uno positivo:

      c := -36
      d := 25
      
      fmt.Println(c + d)
      

      Output

      -11

      La adición se comportará de manera similar con los flotantes:

      e := 5.5
      f := 2.5
      
      fmt.Println(e + f)
      

      Output

      8

      Debido a que añadimos dos flotantes juntos, Go devolvió un valor flotante con un decimal. Sin embargo, como la posición decimal es cero en este caso, fmt.Println no utilizó el formato decimal. Para darle al resultado el formato adecuado, podemos utilizar fmt.Printf y el verbo %.2f, que dará el formato de dos posiciones decimales, como se indica en este ejemplo:

      fmt.Printf("%.2f", e + f)
      

      Output

      8.00

      La sintaxis para la resta es la misma que la de la suma, con la excepción de que cambiamos nuestro operador de signo más (+) por el de signo menos (-):

      g := 75.67
      h := 32.0
      
      fmt.Println(g - h)
      

      Output

      43.67

      En Go, solo podemos usar operadores en los mismos tipos de datos. No podemos añadir un int y un float64:

      i := 7
      j := 7.0
      fmt.Println(i + j)
      

      Output

      i + j (mismatched types int and float64)

      Si se intenta usar operadores en tipos de datos que no son los mismos se producirá en error de compilación.

      Operaciones aritméticas unarias

      Las expresiones matemáticas unarias constan de un solo componente o elemento. En Go, podemos usar los signos más y menos como elementos únicos en combinación con un valor para mostrar la identidad del valor (+) o cambiar el signo del valor (-).

      Aunque no se utiliza comúnmente, el signo más indica la identidad del valor. Podemos usar el signo más con valores positivos:

      i := 3.3
      fmt.Println(+i)
      

      Output

      3.3

      Cuando usamos el signo más con un valor negativo, también devuelve la identidad de ese valor, pero en este caso será negativo:

      j := -19
      fmt.Println(+j)
      

      Output

      -19

      Con un valor negativo, el signo más devuelve el mismo valor negativo.

      Sin embargo, el signo menos cambia el signo de un valor. Por lo tanto, al pasar un valor positivo, notaremos que el signo menos antes del valor mostrará un valor negativo:

      k := 3.3
      fmt.Println(-k)
      

      Output

      -3.3

      De forma alternativa, al usar el operador unario de signo menos con un valor negativo, se muestra un valor positivo:

      j := -19
      fmt.Println(-j)
      

      Output

      19

      Las operaciones aritméticas unarias indicadas por el signo más y el signo menos devolverán la identidad del valor, como en el caso de +i, o el signo opuesto del valor, como sucede con -i.

      Multiplicación y división

      Al igual que la suma y la resta, la multiplicación y la división tienen un funcionamiento muy similar al de las operaciones matemáticas. El signo que usaremos en Go para multiplicar es * y el signo para dividir es /.

      Aquí tenemos un ejemplo de cómo hacer una multiplicación en Go con dos valores flotantes:

      k := 100.2
      l := 10.2
      
      fmt.Println(k * l)
      

      Output

      1022.04

      En Go, la división tiene características diferentes según el tipo numérico que dividamos.

      Si dividimos enteros, el operador / de Go realiza una división de piso, en la que, para el cociente x, se muestra el número entero más grande menor o igual que x.

      Si ejecuta el siguiente ejemplo de división 80 / 6, obtendrá 13 como resultado y el tipo de datos será int:

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          m := 80
          n := 6
      
          fmt.Println(m / n)
      }
      

      Output

      13

      Para obtener un flotante como resultado, debe convertir los valores de forma explícita antes de la división.

      Puede hacerlo envolviendo sus valores con el tipo de flotante que desee, float32() o float64():

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          s := 80
          t := 6
          r := float64(s) / float64(t)
          fmt.Println(r)
      }
      

      Output

      13.333333333333334

      Módulo

      El operador % es el módulo, que muestra el resto en lugar del cociente después de la división. Esto es útil para encontrar números que son múltiplos de un mismo número.

      Veamos un ejemplo del módulo:

      o := 85
      p := 15
      
      fmt.Println(o % p)
      

      Output

      10

      Para desglosarlo, de la división de 85 por 15 se obtiene el cociente 5 con un resto de 10. Aquí, nuestro programa muestra el valor 10 porque el operador de módulo muestra el resto de una expresión de división.

      Para hacer cálculos con módulos con tipos de datos float64, usará la función Mod del paquete math:

      package main
      
      import (
          "fmt"
          "math"
      )
      
      func main() {
          q := 36.0
          r := 8.0
      
          s := math.Mod(q, r)
      
          fmt.Println(s)
      }
      

      Output

      4

      Prioridad de los operadores

      En Go, al igual que en la matemática, debemos tener en cuenta que los operadores se evaluarán en orden de prioridad, no de izquierda a derecha o de derecha a izquierda.

      Si observamos la siguiente expresión matemática:

      u = 10 + 10 * 5
      

      Podemos leerla de izquierda a derecha, pero la multiplicación se realizará primero. Por lo tanto, si imprimiéramos u obtendríamos el siguiente valor:

      Output

      60

      Esto se debe a que 10 * 5 da como resultado 50, y luego sumamos 10 para obtener 60 como resultado final.

      Si, como alternativa, queremos sumar el valor 10 a 10 y luego multiplicar esa suma por 5, en Go debemos usar paréntesis tal como lo haríamos en el campo de la matemática:

      u := (10 + 10) * 5
      fmt.Println(u)
      

      Output

      100

      Una opción para recordar el orden de las operaciones es el acrónimo PEMDAS:

      Orden Letra Representa
      1 P Paréntesis
      2 E Exponente
      3 M Multiplicación
      4 D División
      5 A Suma
      6 S Resta

      Es posible que esté familiarizado con otros acrónimos, como BEDMAS o BODMAS, para recordar el orden de las operaciones. Sea cual sea el acrónimo que le resulte más útil, intente tenerlo en cuenta al realizar operaciones matemáticas en Go para obtener los resultados esperados.

      Operadores de asignación

      El operador de asignación más frecuente es uno que ya utilizó: el signo igual =. El operador = le asigna el valor de la derecha a una variable a la izquierda. Por ejemplo, v = 23 asigna el valor del número entero 23 a la variable v.

      Durante la programación, es común usar operadores de asignación compuestos que realizan una operación en el valor de una variable y luego asignan el valor nuevo resultante a esa variable. Estos operadores compuestos combinan un operador aritmético con el operador = Por lo tanto, para la adición, combinaremos + con = para obtener el operador compuesto +=. Observemos cómo se ve:

      w := 5
      w += 1
      fmt.Println(w)
      

      Output

      6

      Primero, configuramos la variable w equivalente al valor de 5, luego usamos el operador de asignación += para sumar el número de la derecha al valor de la variable izquierda y, a continuación, asignamos el resultado a w.

      Los operadores de asignación compuestos se utilizan frecuentemente en los bucles for, que emplearemos cuando queramos repetir un proceso varias veces:

      package main
      
      import "fmt"
      
      func main() {
      
          values := []int{0, 1, 2, 3, 4, 5, 6}
      
          for _, x := range values {
      
              w := x
      
              w *= 2
      
              fmt.Println(w)
          }
      
      }
      

      Output

      0 2 4 6 8 10 12

      Usando un bucle for para iterar el elemento llamado values, pudo automatizar el proceso del operador *=, que multiplicó la variable w por el número 2, y luego volvió a asignar el resultado a la variable w.

      Go cuenta con un operador de asignación compuesto para cada uno de los operadores aritméticos que se analizan en este tutorial.

      Para sumar y luego asignar el valor:

      y += 1
      

      Para restar y luego asignar el valor:

      y -= 1
      

      Para multiplicar y luego asignar el valor:

      y *= 2
      

      Para dividir y luego asignar el valor:

      y /= 3
      

      Para mostrar el resto y luego asignar el valor:

      y %= 3
      

      Los operadores de asignación compuestos pueden ser útiles cuando se debe realizar un aumento o una reducción incremental o cuando se deben automatizar determinados procesos de un programa.

      Conclusión

      En este tutorial, se analizaron muchos de los operadores que usará con los tipos de datos numéricos enteros y flotantes. Puede aprender más sobre los diferentes tipos de datos en Información sobre tipos de datos en Go y Cómo convertir tipos de datos.



      Source link