Comment puis-je adapter mon code Swift pour donner des solutions imaginaires à un quadratique?

Question

J'ai créé une fonction dans Swift pour résoudre et donner les solutions à une fonction quadratique. Je ne sais pas comment adapter ma fonction pour qu'elle donne des solutions imaginaires au lieu d'imprimer: "Il n'y a pas de vraies solutions". Je suis relativement nouveau à la programmation et pourrait utiliser de l'aide. Voici mon code:

func quadraticFormulaSolver(variableA a: Double, variableB b: Double, variableC c: Double) -> (Double, Double) { 
let firstSolution: Double = (-b + sqrt((b * b) + (-4.0 * a * c)))/2.0 
let secondSolution: Double = (-b - sqrt((b * b) + (-4.0 * a * c)))/2.0 
let checkSolution: Double = sqrt((b * b) + (-4.0 * a * c)) 

if checkSolution > 0 { 
    print("There are two real solutions and they are \(firstSolution) and \(secondSolution)") 
    return(firstSolution, secondSolution) } 

guard firstSolution != 0.0 else { 
    print("There is one real solution and it is \(firstSolution)") 
    return(firstSolution, secondSolution) } 


guard checkSolution < 0 else { 
print("There are no real solutions") 
    return(firstSolution, secondSolution) } 

    return(firstSolution, secondSolution) 
} 

Answer 1

Étant donné que votre fonction peut renvoyer un peu de choix différents, nous allons faire un Enum pour représenter les options:

enum QuadraticSolution { 
    case TwoReal(firstSolution: Double, secondSolution: Double) 
    case OneReal(solution: Double) 
    case TwoNonReal 
} 

Nous y reviendrons TwoNonReal un peu.

Votre fonction peut maintenant retourner une instance de cette ENUM:

func quadraticFormulaSolver(variableA a: Double, variableB b: Double, variableC c: Double) -> QuadraticSolution { 

Pour faire un peu le code plus lisible, nous allons filtrer les discriminante:

let discriminant = (b * b) - (4.0 * a * c) 

Ensuite, nous pouvons utiliser un switch déclaration à ce sujet. Si c'est positif, vous avez deux vraies racines. Si c'est zéro, vous avez une racine réelle (répétée). Si elle est négative, vous avez deux racines non réelles:

switch discriminant { 
    case _ where discriminant > 0: 
     let firstSolution = (-b + sqrt(discriminant))/(2.0 * a) 
     let secondSolution = (-b - sqrt(discriminant))/(2.0 * a) 
     return .TwoReal(firstSolution: firstSolution, secondSolution: secondSolution) 
    case _ where discriminant == 0: 
     let solution = (-b)/(2.0 * a) 
     return .OneReal(solution: solution) 
    default: // discriminant is negative 
     return .TwoNonReal 
    } 
} 

---

Swift ne possède pas de type intégré pour les numéros non réels. Plutôt que de réinventer la roue, je vous suggère d'intégrer swift-pons dans votre application.

Une fois que vous faites cela, vous pouvez changer votre TwoNonReal ENUM retourner deux Complex numéros:

case TwoNonReal(firstSolution: Complex, secondSolution: Complex) 

Ensuite, vous pouvez les calculer comme ceci:

default: // discriminant is negative 
     let base = (-b)/(2.0 * a) 
     let firstSolution = base + (Complex.sqrt(-1.0 * discriminant))/(2.0 * a) 
     let secondSolution = base - (Complex.sqrt(-1.0 * discriminant))/(2.0 * a) 
     return .TwoNonReal(firstSolution: firstSolution, secondSolution: secondSolution) 
    }