web-dev-qa-db-fra.com

Comment puis-je convertir des degrés en radians?

J'essaie de convertir ce code Obj-C en code Swift mais je ne sais pas quel doit être l'équivalent de ce code?

#define DEGREES_TO_RADIANS(degrees)((M_PI * degrees)/180)

J'ai googlé et trouvé this

Mais je ne comprends pas comment convertir cela en Swift dans mon cas?

iosobjective-cmacosswiftmacros
99
Dharmesh

Xcode 10 • Swift 4.2 ou version ultérieure

extension BinaryInteger {
    var degreesToRadians: CGFloat { return CGFloat(self) * .pi / 180 }
}

extension FloatingPoint {
    var degreesToRadians: Self { return self * .pi / 180 }
    var radiansToDegrees: Self { return self * 180 / .pi }
}

Terrain de je

45.degreesToRadians         // 0.785398163397448

Int(45).degreesToRadians    // 0.785398163397448
Int8(45).degreesToRadians   // 0.785398163397448
Int16(45).degreesToRadians  // 0.785398163397448
Int32(45).degreesToRadians  // 0.785398163397448
Int64(45).degreesToRadians  // 0.785398163397448

UInt(45).degreesToRadians   // 0.785398163397448
UInt8(45).degreesToRadians  // 0.785398163397448
UInt16(45).degreesToRadians // 0.785398163397448
UInt32(45).degreesToRadians // 0.785398163397448
UInt64(45).degreesToRadians // 0.785398163397448

Double(45).degreesToRadians    // 0.7853981633974483
CGFloat(45).degreesToRadians   // 0.785398163397448
Float(45).degreesToRadians     // 0.7853981
Float80(45).degreesToRadians   // 0.785398163397448278999
242
Leo Dabus

Ce n'est pas identique à ce que vous avez demandé, mais dans Swift 3/iOS 10, vous pouvez utiliser le type de mesure et effectuer la conversion sans connaître la formule!

let result = Measurement(value: 45, unit: UnitAngle.degrees)
    .converted(to: .radians).value
56
matt

Apple fournit ces fonctions GLKit pour la conversion:

func GLKMathDegreesToRadians(_ degrees: Float) -> Float
func GLKMathRadiansToDegrees(_ radians: Float) -> Float
42
Crashalot
let angle = 45° // angle will be in radians, 45 is in degrees

Compile sous Swift. Conservez toujours toutes les valeurs, effectuez tous les calculs en radians avec CGFloats ..., mais rendez le code plus lisible avec les constantes en degrés. Par exemple: 90 ° Le signe ° effectuera comme par magie la conversion des degrés en radians.

Comment configurer ceci:

Définissez et utilisez un opérateur postfix pour le signe °. Cet opérateur effectuera la conversion de degrés en radians. Cet exemple concerne Ints, développez-les également pour les types Float si vous en avez besoin.

postfix operator °

protocol IntegerInitializable: ExpressibleByIntegerLiteral {
  init (_: Int)
}

extension Int: IntegerInitializable {
  postfix public static func °(lhs: Int) -> CGFloat {
    return CGFloat(lhs) * .pi / 180
  }
}

Quelques exemples d'utilisation:

let angle = 45°

contentView.transform = CGAffineTransform(rotationAngle: 45°)

let angle = 45
contentView.transform = CGAffineTransform(rotationAngle: angle°)

Attention!

Il est trop facile d'utiliser cette conversion deux fois (sur une valeur déjà exprimée en radians par erreur), vous obtiendrez un très petit nombre comme résultat, et apparemment, l'angle résultant sera toujours égal à zéro ... N'UTILISEZ PAS ° sur le même valeur deux fois (ne pas convertir deux fois) !!:

// OBVIOUSLY WRONG!
let angle = 45°° // ° used twice here

// WRONG! BUT EASY TO MISS
let angle = 45° // ° used here
contentView.transform = CGAffineTransform(rotationAngle: angle°) // ° also used here
16
t1ser

Aussi, pour convertir des radians en degrés (si quelqu'un tombe sur ceci sur Google):

var degrees = radians * (180.0 / M_PI)
11
nikans

Vous n'êtes plus limité à ASCII caractères lors de la création de noms de variables, pourquoi ne pas utiliser ceci avec π (alt-p):

typealias RadianAngle = CGFloat

let π = RadianAngle(M_PI)
let π_x_2 = RadianAngle(M_PI * 2)
let π_2 = RadianAngle(M_PI_2)
let π_4 = RadianAngle(M_PI_4)

extension RadianAngle {
    var degrees: CGFloat {
        return self * 180 / π
    }
    init(degrees: Int) {
        self = CGFloat(degrees) * π / 180
    }
}

Exemple d'utilisation:

let quarterCircle = RadianAngle(degrees: 90)
print("quarter circle = \(quarterCircle) radians")
// quarter circle = 1.5707963267949 radians

let halfCircle = π
print("half circle = \(halfCircle.degrees) degrees")
// half circle = 180.0 degrees
2
Ashley Mills

J'utiliserais le même principe @ t1ser que mentionné ci-dessus, mais créerais une extension de CGFloat pour faciliter l'utilisation des décimales pour le degré (vous pouvez donc avoir 23,4 degrés, par exemple):

extension CGFloat {
    func degrees() -> CGFloat {
        return self * .pi / 180
    }

    init(degrees: CGFloat) {
        self = degrees.degrees()
    }
}

Il serait également très facile de l'utiliser (principalement parce que personnellement, je ne savais pas comment taper ° ???? - dans le cas contraire, il s'agit de option+shift+8 btw):

let degreesToConvert: CGFloat = 45.7
.
.
.
let convertedDegrees = degreesToConvert.degrees()

Ou pour utiliser l'initialiseur:

let convertedDegrees = CGFloat(degrees: 45.3)
1
Septronic

Swift 4.2

Vous pouvez écrire des fonctions génériques globales:

public func radians<T: FloatingPoint>(degrees: T) -> T {
    return .pi * degrees / 180
}

public func degrees<T: FloatingPoint>(radians: T) -> T {
    return radians * 180 / .pi
}

Exemple:

let cgFloat: CGFloat = 23.0
let double: Double = 23.0
let float: Float = 23.0
let int: Int = 23

let cgf = radians(degrees: cgFloat) // 0.4014 CGFloat
let d = radians(degrees: double)    // 0.4014 Double
let f = radians(degrees: float)     // 0.4014 Float
let i = radians(degrees: int)       // compile error

Au cas où vous ne voudriez pas étendre tous vos types flottants comme ceci

extension FloatingPoint { ... }
1
Tikhonov Alexander