Mathématiques plus avancées avec les nombres numériques et fractionnaires de Scala

Question

Récemment, j'ai (enfin) commencé à utiliser le trait numérique de Scala, qui fait des merveilles. Par exemple:

def square[A](x: A)(implicit num: Numeric[A]): A = num.times(x, x) 

Maintenant, je peux carré un nombre que ce soit Double, Integer, BigDecimal, ou que non. Et si je voulais faire des maths plus avancés? Par exemple, mes logistic function pour Double nombres ressemble à ceci:

def logisticFunction(x: Double): Double = 1.0/(1.0 + math.exp(-x)) 

que je pouvais faire l'ajout et la division facilement (je devrais juste utiliser trait Fractional au lieu de Numeric), mais qu'en est-exposant? Je ne veux certainement pas écrire ma propre fonction exp (ou toute fonction arbitraire qui prend Double arguments). Donc, ma question est la suivante: comment puis-je convertir mon A en Double, faire mes calculs à ce sujet, puis revenir à A. Est-ce même possible?

EDIT:

Voilà comment la signature de ma fonction devrait ressembler à:

def logisticFunction[A](x: A)(implicit num: Fractional[A]): A = 
    /* Magic happens here */ 

J'ai compris la partie sur la conversion de doubler, ce qui est aussi facile que num.toDouble(x). Cependant, le problème de la conversion à A reste.

Answer 1

Je doute encore cette approche est vraiment utile. Mais avec votre description, vous voulez quelque chose comme ceci:

type FromDouble[A] = Double => A 
type ToDouble [A] = A => Double 

def logisticFunction[A: FromDouble: ToDouble](x: A): A = 1.0/(1.0 + math.exp(-x)) 

logisticFunction(0.5) 
implicit def bigDecimalToDouble(b: BigDecimal) = b.toDouble  
logisticFunction(BigDecimal(0.5)) 

Ou avec classe de type dédié:

object FromDouble { 
    implicit object _Double extends FromDouble[Double] { 
    def apply(d: Double) = d 
    } 
    implicit object _BigDecimal extends FromDouble[BigDecimal] { 
    def apply(d: Double) = BigDecimal(d) 
    } 
} 
trait FromDouble[A] extends (Double => A) 

object ToDouble { 
    implicit object _Double extends ToDouble[Double] { 
    def apply(d: Double) = d 
    } 
    implicit object _BigDecimal extends ToDouble[BigDecimal] { 
    def apply(b: BigDecimal) = b.toDouble 
    } 
} 
trait ToDouble[A] extends (A => Double) 

def logisticFunction[A: FromDouble: ToDouble](x: A): A = 1.0/(1.0 + math.exp(-x)) 

logisticFunction(0.5) 
logisticFunction(BigDecimal(0.5)) 

Answer 2

Vous aurez besoin d'une classe de type fournissant des fonctions trigonométriques telles que exp. La bibliothèque standard de Scala ne va pas au-delà de Fractional. Vous pouvez essayer d'utiliser Spire.

Exemple:

$ sbt core/console 

import spire.math._ 
import spire.algebra._ 
import spire.implicits._ 

def logisticFunction[A](x: A)(implicit m: Field[A], t: Trig[A]): A = 
    m.one/(m.one + exp(-x)) 

logisticFunction(0.5) 
logisticFunction(BigDecimal(0.5))