Hemos estado buscado en internet para de este modo tener para ti la respuesta para tu problema, si continúas con alguna inquietud déjanos tu comentario y respondemos porque estamos para servirte.
paqueteMatemáticas
El objeto del paquete scala.math contiene métodos para realizar operaciones numéricas básicas como funciones elementales exponenciales, logarítmicas, raíz y trigonométricas.
Todos los métodos reenvían a java.lang.Math a menos que se indique lo contrario.
- Fuente
- package.scala
- Ver también
-
java.lang.Math
- Supertipos lineales
- CualquieraRef, Cualquiera
Miembros de tipo
final clase BigDecimal se extiende ScalaNumber con ScalaNumericConversions con Serializable con Ordered[BigDecimal]
BigDecimal representa números decimales en coma flotante de precisión arbitraria. De forma predeterminada, la precisión coincide aproximadamente con la de los números de coma flotante IEEE de 128 bits (34 dígitos decimales, HALF_EVEN modo de redondeo). Dentro del rango de números IEEE binary128, BigDecimal estará de acuerdo con BigInt para los códigos hash y de igualdad (y también coincidirá con los tipos primitivos). Más allá de ese rango, números con más de 4934 dígitos cuando se escriben en su totalidad, el hashCode de BigInt y BigDecimal se permite divergir debido a la dificultad de calcular de manera eficiente tanto la representación decimal en BigDecimal y la representación binaria en BigInt.
Al crear un BigDecimal a partir de una Double o Float, se debe tener cuidado ya que la representación de fracción binaria de Double y Float no se convierte fácilmente en una representación decimal. Hay tres esquemas explícitos disponibles para conversión. BigDecimal.decimal convertirá el número de punto flotante en una representación de texto decimal, y construirá un BigDecimal basado en eso. BigDecimal.binary expandirá la fracción binaria a la precisión solicitada o predeterminada. BigDecimal.exact expandirá la fracción binaria al número completo de dígitos, produciendo así el valor decimal exacto correspondiente a la fracción binaria de ese número de punto flotante. BigDecimal la igualdad coincide con la expansión decimal de Double: BigDecimal.decimal(0.1) == 0.1. Tenga en cuenta que desde 0.1f != 0.1, lo mismo no es cierto para Float. En lugar de, 0.1f == BigDecimal.decimal((0.1f).toDouble).
Para probar si un BigDecimal El número se puede convertir en un Double o Float y luego regrese sin pérdida de información usando uno de estos métodos, pruebe con isDecimalDouble, isBinaryDouble, o isExactDouble o el correspondiente Float versiones. Tenga en cuenta que BigInt‘s isValidDouble estará de acuerdo con isExactDouble, no la isDecimalDouble utilizado por defecto.
BigDecimal utiliza la representación decimal de números binarios de coma flotante para determinar la igualdad y los códigos hash. Esto produce respuestas diferentes a la conversión entre Long y Double valores, donde se utiliza la forma exacta. Como siempre, dado que el punto flotante es una representación con pérdidas, es aconsejable tener cuidado al asumir que la identidad se mantendrá en múltiples conversiones.
BigDecimal mantiene un MathContext que determina el redondeo que se aplica a ciertos cálculos. En la mayoría de los casos, el valor de la BigDecimal también se redondea a la precisión especificada por el MathContext. Para crear un BigDecimal con una precisión diferente a su MathContext, usar new BigDecimal(new java.math.BigDecimal(...), mc). El redondeo se aplicará a aquellas operaciones matemáticas que pueden cambiar drásticamente el número de dígitos en una representación completa, a saber, multiplicación, división y potencias. El argumento de la izquierda MathContext Siempre determina el grado de redondeo, si lo hay, y es el que se propaga mediante operaciones aritméticas que no aplican redondeo en sí mismas.
final clase Empezando se extiende ScalaNumber con ScalaNumericConversions con Serializable con Ordered[BigInt]
rasgo Equiv[T] extiende serializable
Un rasgo para representar relaciones de equivalencia. Es importante distinguir entre un tipo que se puede comparar por igualdad o equivalencia y una representación de equivalencia en algún tipo. Este rasgo es para representar a este último.
Un relación de equivalencia es una relación binaria en un tipo. Esta relación se expone como la equiv método del Equiv rasgo. La relación debe ser:
reflexivo: equiv(x, x) == true para cualquier x de tipo T.simétrico: equiv(x, y) == equiv(y, x) para cualquier x y y de tipo T.transitivo: si equiv(x, y) == true y equiv(y, z) == true, luego equiv(x, z) == true para cualquier x, y, y z de tipo T.
- Ya que
-
2,7
rasgo Fraccionario[T] extiende numérico[T]
- Ya que
-
2.8
rasgo Integral[T] extiende numérico[T]
- Ya que
-
2.8
rasgo LowPriorityEquiv extiende AnyRef
rasgo LowPriorityOrderingImplicits extiende AnyRef
rasgo Numérico[T] extiende el pedido[T]
rasgo Ordenado[A] se extiende Comparable[A]
Un rasgo para los datos que tienen un orden natural único. Consulte scala.math.Ordering antes de usar este rasgo para obtener más información sobre si debe usar scala.math.Ordering en su lugar.
Las clases que implementan este rasgo se pueden ordenar con scala.util.Sorting y se pueden comparar con operadores de comparación estándar (por ejemplo,> y <).
Ordered debe usarse para datos con un solo orden natural (como números enteros), mientras que Ordering permite múltiples implementaciones de pedidos. Una instancia de Ordering se creará implícitamente si es necesario.
scala.math.Ordering es una alternativa a este rasgo que permite definir varios ordenamientos para el mismo tipo.
scala.math.PartiallyOrdered es una alternativa a este rasgo para datos parcialmente ordenados.
Por ejemplo, cree una clase simple que implemente Ordered y luego ordenarlo con scala.util.Sorting:
case class OrderedClass(n:Int) extends Ordered[OrderedClass] def compare(that: OrderedClass) = this.n - that.n val x = Array(OrderedClass(1), OrderedClass(5), OrderedClass(3)) scala.util.Sorting.quickSort(x) x
Es importante que el equals método para una instancia de Ordered[A] Sea consistente con el método de comparación. Sin embargo, debido a las limitaciones inherentes a la semántica de borrado de tipos, no existe una forma razonable de proporcionar una implementación predeterminada de igualdad para instancias de Ordered[A]. Por lo tanto, si necesita poder usar la igualdad en una instancia de Ordered[A] debe proporcionarlo usted mismo al heredar o instanciar.
Es importante que el hashCode método para una instancia de Ordered[A] ser coherente con el compare método. Sin embargo, no es posible proporcionar una implementación predeterminada sensata. Por lo tanto, si necesita poder calcular el hash de una instancia de Ordered[A] debe proporcionarlo usted mismo al heredar o instanciar.
- Ver también
-
scala.math.Ordering, scala.math.PartiallyOrdered
rasgo Ordenando[T] se extiende Comparador[T] con PartialOrdering[T] con serializable
El ordenamiento es un rasgo cuyas instancias representan cada una una estrategia para clasificar instancias de un tipo.
El objeto complementario de Ordering define muchos objetos implícitos para tratar subtipos de AnyVal (por ejemplo, Int, Double), String y otros.
Para ordenar instancias por una o más variables miembro, puede aprovechar estos ordenamientos integrados usando Ordering.by y Ordering.on:
import scala.util.Sorting
val pairs = Array(("a", 5, 2), ("c", 3, 1), ("b", 1, 3))
// sort by 2nd element
Sorting.quickSort(pairs)(Ordering.by[(String, Int, Int), Int](_._2))
// sort by the 3rd element, then 1st
Sorting.quickSort(pairs)(Ordering[(Int, String)].on(x => (x._3, x._1)))
Un pedido[T] se implementa especificando comparar (a: T, b: T), que decide cómo ordenar dos instancias ay b. Ejemplos de pedidos[T] puede ser utilizado por cosas como scala.util.Sorting para ordenar colecciones como Array[T].
Por ejemplo:
import scala.util.Sorting
case class Person(name:String, age:Int)
val people = Array(Person("bob", 30), Person("ann", 32), Person("carl", 19))
// sort by age
object AgeOrdering extends Ordering[Person]
def compare(a:Person, b:Person) = a.age compare b.age
Sorting.quickSort(people)(AgeOrdering)
Este rasgo y scala.math.Ordered proporcionan la misma funcionalidad, pero de diferentes formas. A un tipo T se le puede dar una única forma de ordenarse extendiendo Ordered. Con Ordering, este mismo tipo se puede clasificar de muchas otras formas. Ordered y Ordering proporcionan implícitos que les permiten usarse indistintamente.
Puede importar scala.math.Ordering.Implicits para obtener acceso a otros pedidos implícitos.
- Anotaciones
- @implicitNotFound(“Ningún orden implícito definido para $ T”.)
- Ya que
-
2,7
- Ver también
-
scala.math.Ordered, scala.util.Sorting
rasgo PartialOrdering[T] extiende Equiv[T]
Un rasgo para representar ordenamientos parciales. Es importante distinguir entre un tipo que tiene un orden parcial y una representación de orden parcial en algún tipo. Este rasgo es para representar a este último.
A pedido parcial es una relación binaria en un tipo T, expuesto como el lteq método de este rasgo. Esta relación debe ser:
reflexivo: lteq(x, x) == true, para cualquier x de tipo T.anti-simétrico: si lteq(x, y) == true y lteq(y, x) == true luego equiv(x, y) == true, para cualquier x y y de tipo T.transitivo: si lteq(x, y) == true y lteq(y, z) == true luego lteq(x, z) == true, para cualquier x, y, y z de tipo T.
Además, una ordenación parcial induce una relación de equivalencia en un tipo T: x y y de tipo T son equivalentes si y solo si lteq(x, y) && lteq(y, x) == true. Esta relación de equivalencia se expone como equiv método, heredado del rasgo Equiv.
- Ya que
-
2,7
rasgo Parcialmente ordenado[+A] extiende Cualquiera
rasgo ScalaNumericAnyConversions extiende Cualquiera
rasgo ScalaNumericConversions se extiende ScalaNumber con ScalaNumericAnyConversions
Miembros de valor
final val mi: Doble (2.718281828459045)
def IEEEremainder(x: Doble, y: Doble): Doble
final val Pi: Doble (3.141592653589793)
def abdominales(x: Doble): Doble
def abdominales(x: flotar): Flotar
def abdominales(x: largo): Largo
def abdominales(x: Int): En t
def acos(x: Doble): Doble
def addExact(x: largo, y: largo): Largo
def addExact(x: Int, y: Int): En t
def como en(x: Doble): Doble
def un bronceado(x: Doble): Doble
def atan2(y: Doble, x: Doble): Doble
Convierte coordenadas rectangulares (x, y) a polar (r, theta).
- y
-
la coordenada de abscisas
- X
-
la coordenada ordenada
- devoluciones
-
los theta componente del punto
(r, theta)en coordenadas polares que corresponde al punto(x, y)en coordenadas cartesianas.
def cbrt(x: Doble): Doble
Devuelve la raíz cúbica de lo dado. Double valor.
- X
-
el número para sacar la raíz cúbica de
- devoluciones
-
el valor ∛x
def hacer techo(x: Doble): Doble
def copySign(magnitud: flotar, signo: flotar): Flotar
def copySign(magnitud: Doble, signo: Doble): Doble
def porque(x: Doble): Doble
def aporrear(x: Doble): Doble
def decremento exacto(x: largo): Largo
def decremento exacto(x: Int): En t
def Exp(x: Doble): Doble
Devuelve el número de Euler e elevado al poder de un Double valor.
- X
-
el exponente a subir
epara. - devoluciones
-
el valor
ea, dóndeees la base de los logaritmos naturales.
def expm1(x: Doble): Doble
def suelo(x: Doble): Doble
def floorDiv(x: largo, y: largo): Largo
def floorDiv(x: Int, y: Int): En t
def floorMod(x: largo, y: largo): Largo
def floorMod(x: Int, y: Int): En t
def getExponent(d: Doble): En t
def getExponent(f: flotar): En t
def hipot(x: Doble, y: Doble): Doble
Devuelve la raíz cuadrada de la suma de los cuadrados de ambos dados Double valores sin subdesbordamiento o desbordamiento intermedios.
los r componente del punto (r, theta) en coordenadas polares que corresponde al punto (x, y) en coordenadas cartesianas.
def incrementExact(x: largo): Largo
def incrementExact(x: Int): En t
def Iniciar sesión(x: Doble): Doble
Devuelve el logaritmo natural de a. Double valor.
- X
-
el número para tomar el logaritmo natural de
- devoluciones
-
el valor
logₑ(x)dóndeees el número de Eulers
def log10(x: Doble): Doble
def log1p(x: Doble): Doble
def max(x: Doble, y: Doble): Doble
def max(x: flotar, y: flotar): Flotar
def max(x: largo, y: largo): Largo
def max(x: Int, y: Int): En t
def min(x: Doble, y: Doble): Doble
def min(x: flotar, y: flotar): Flotar
def min(x: largo, y: largo): Largo
def min(x: Int, y: Int): En t
def multiplicarExacto(x: largo, y: largo): Largo
def multiplicarExacto(x: Int, y: Int): En t
def negarExacto(x: largo): Largo
def negarExacto(x: Int): En t
def siguienteDespués(inicio: flotar, dirección: Doble): Flotar
def siguienteDespués(inicio: Doble, dirección: Doble): Doble
def nextDown(f: flotar): Flotar
def nextDown(d: Doble): Doble
def nextUp(f: flotar): Flotar
def nextUp(d: Doble): Doble
def pow(x: Doble, y: Doble): Doble
Devuelve el valor del primer argumento elevado a la potencia del segundo argumento.
- X
-
la base.
- y
-
el exponente.
- devoluciones
-
el valor
xy.
def aleatorio(): Doble
def rint(x: Doble): Doble
Devuelve el Double valor que tiene el valor más cercano al argumento y es igual a un número entero matemático.
- X
-
a
Doublevalor - devoluciones
-
el valor de punto flotante más cercano a a que es igual a un entero matemático.
def ronda(x: Doble): Largo
Devuelve lo más cercano Long al argumento.
- X
-
un valor de punto flotante que se redondeará a un
Long. - devoluciones
-
el valor del argumento redondeado al más cercano
longvalor.
def ronda(x: flotar): En t
Devuelve lo más cercano Int al argumento.
- X
-
un valor de punto flotante que se redondeará a un
Int. - devoluciones
-
el valor del argumento redondeado al más cercano
Intvalor.
def cuero cabelludo(f: flotar, scaleFactor: Int): Flotar
def cuero cabelludo(d: Doble, scaleFactor: Int): Doble
def signum(x: Doble): Doble
def signum(x: flotar): Flotar
def signum(x: largo): Largo
- Nota
-
Reenvía a java.lang.Long
def signum(x: Int): En t
- Nota
-
Reenvía a java.lang.Integer
def pecado(x: Doble): Doble
def pecado(x: Doble): Doble
def sqrt(x: Doble): Doble
Devuelve la raíz cuadrada de a Double valor.
- X
-
el número para sacar la raíz cuadrada de
- devoluciones
-
el valor √x
def restarExacto(x: largo, y: largo): Largo
def restarExacto(x: Int, y: Int): En t
def broncearse(x: Doble): Doble
def tanh(x: Doble): Doble
def toDegrees(x: Doble): Doble
Convierte un ángulo medido en radianes en un ángulo aproximadamente equivalente medido en grados.
- X
-
ángulo, en radianes
- devoluciones
-
la medida del ángulo
xen grados.
def toIntExact(x: largo): En t
def toRadians(x: Doble): Doble
Convierte un ángulo medido en grados en un ángulo aproximadamente equivalente medido en radianes.
- X
-
un ángulo, en grados
- devoluciones
-
la medida del ángulo
xen radianes.
def ulp(x: flotar): Flotar
def ulp(x: Doble): Doble
objeto BigDecimal se extiende java.io.Serializable
- Ya que
-
2,7
objeto Empezando se extiende java.io.Serializable
- Ya que
-
2.1
objeto Equiv extiende LowPriorityEquiv con java.io.Serializable
objeto Fraccionario se extiende java.io.Serializable
objeto Integral se extiende java.io.Serializable
objeto Numérico se extiende java.io.Serializable
- Ya que
-
2.8
objeto Ordenado
objeto Ordenando extiende LowPriorityOrderingImplicits con java.io.Serializable
Este es el objeto complementario del rasgo scala.math.Ordering.
Contiene muchos ordenamientos implícitos, así como métodos para construir nuevos ordenamientos.
objeto PartialOrdering se extiende java.io.Serializable
Si haces scroll puedes encontrar las notas de otros creadores, tú igualmente puedes insertar el tuyo si te gusta.