迅速作出假设度三角计算

问题描述 投票：3回答：7

是否可以更改设置，财产等在斯威夫特的iOS，以便它假定度三角计算，而不是弧度？

例如sin(90)将被评估，以1。

我有：

let pi = 3.14 
var r2d = 180.0/pi
var d2r = pi/180

...但转换却变得非常涉及一些长期三角函数公式。

ios swift trigonometry
7个回答
29
投票

正如在其他的答案已经说了，有标准库接受的参数中没有度三角函数。

如果你定义自己的功能，那么你可以使用__sinpi()，__cospi()，等等...而不是由π乘以：

// Swift 2:
func sin(degrees degrees: Double) -> Double {
    return __sinpi(degrees/180.0)
}

// Swift 3:
func sin(degrees: Double) -> Double {
    return __sinpi(degrees/180.0)
}

从__sinpi manual page（强调）：

所述__sinpi（）函数返回PI倍x的正弦（以弧度为单位）。这可以更精确地比SIN（M_PI * x）的计算，因为所必需提供一个全面的结果它可以隐含地使用，而不是53位，其M_PI是有限pi的​​一样多的位。对于大的x也可以是更有效的，因为所涉及的参数减少是显著简单。

__sinpi()和相关函数是非标准的，但在iOS 7 / OS X 10.9和以后版本。

例：

sin(degrees: 180.0)       // 0

给出一个确切的结果，相比于：

sin(180.0 * M_PI/180.0) // 1.224646799147353e-16

而只是为了好玩：这是你如何定义基于度的正弦函数的所有浮点类型，包括函数重载（现在更新的斯威夫特3）CGFloat：

func sin(degrees: Double) -> Double {
    return __sinpi(degrees/180.0)
}

func sin(degrees: Float) -> Float {
    return __sinpif(degrees/180.0)
}

func sin(degrees: CGFloat) -> CGFloat {
    return CGFloat(sin(degrees: degrees.native))
}

在过去的变型，编译器会自动从实际类型degrees.native调用哪个函数，因此，这正常工作32位和64位平台上的推断。

7
投票

添加的扩展，清楚地确定哪种类型的值是处理这样的事情一个适当的方式：

import Darwin // needed to get M_PI
extension Double {
  public var degrees: Double { return self * M_PI / 180 }
  public var ㎭: Double { return self * 180 / M_PI }
}

流行的是到操场，看看你得到你所期望的结果：

sin(90.degrees)  --> 1.0
1.㎭  -->  57.2957795130823
1.㎭.degrees --> 1.0
(M_PI / 3).㎭  -->  60.0
3
投票

您可以定义返回度数值的罪全局函数。只需将功能以迅速文件中的任何类之外。

func sind(degrees: Double) -> Double {
    return sin(degrees * M_PI / 180.0)
}

所以，在你的项目的任何地方，你可以只使用：

sind(90) // Returns 1
2
投票

这将运行在一个操场，并提供度/弧度单位类型安全的实现。该类型定义自由地从here做出了如此迅速演变邮件列表上有几个小的语法修正。我在一些三角函数中写道;其余的是我已经展示了什么是简单的延续。

import Cocoa

//MARK:- AngleType    
protocol AngleType: FloatLiteralConvertible, IntegerLiteralConvertible {
    var value: Double { get set }

    init(_ value: Double)
    init(_ value: Int)
    init<T: IntegerType>(integerLiteral value: T)
    init<T: FloatingPointType>(floatLiteral value: T)
}


// Implement FloatLiteralConvertible and IntegerLiteralConvertible
extension AngleType {
    init<T: IntegerType>(integerLiteral value: T) {
        self.init(value)
    }

    init<T: IntegerType>(_ value: T) {
        self.init(integerLiteral: value)
    }

    init<T: FloatingPointType>(floatLiteral value: T) {
        self.init(value)
    }

    init<T: FloatingPointType>(_ value: T) {
        self.init(floatLiteral: value)
    }
}

//MARK:- Degree
struct Degree: AngleType {
    typealias FloatLiteralType = Double
    typealias IntegerLiteralType = Int

    var value: Double

    init(_ value: Double) {
        self.value = value
    }

    init(_ value: Int) {
        self.value = Double(value)
    }
}

protocol DegreeConvertible {
    init(degreeLiteral value: Degree)
}

extension Degree: CustomStringConvertible, CustomDebugStringConvertible {
    var description: String {
        return self.value.description
    }

    var debugDescription: String {
        return "\(self.value.description)°"
    }
}

extension Degree: RadianConvertible {
    init(radianLiteral value: Radian) {
        self.value = Double(radianLiteral:value) * 180.0 / M_PI
    }

    init(_ value: Radian) {
        self.init(radianLiteral: value)
    }
}

//MARK:- Radian
struct Radian: AngleType {
    typealias FloatLiteralType = Double
    typealias IntegerLiteralType = Int

    var value: Double

    init(_ value: Double) {
        self.value = value
    }

    init(_ value: Int) {
        self.value = Double(value)
    }
}

protocol RadianConvertible {
    init(radianLiteral value: Radian)
}

extension Radian: CustomStringConvertible, CustomDebugStringConvertible {
    var description: String {
        return self.value.description
    }

    var debugDescription: String {
        return "\(self.value.description)㎭"
    }
}

extension Radian: DegreeConvertible {
    init(degreeLiteral value: Degree) {
        self.value = Double(degreeLiteral: value) * M_PI / 180.0
    }

    init(_ value: Degree) {
        self.init(degreeLiteral: value)
    }
}

//MARK:- Adding Conformance To Built In Types
extension FloatLiteralType: DegreeConvertible, RadianConvertible {
    init(degreeLiteral degree: Degree) {
        self = degree.value
    }

    init(radianLiteral radian: Radian) {
        self = radian.value
    }
}

extension CGFloat: DegreeConvertible, RadianConvertible {
    init(degreeLiteral degree: Degree) {
        self.init(degree.value)
    }

    init(radianLiteral radian: Radian) {
        self.init(radian.value)
    }

    init(_ degree: Degree) {
        self.init(degreeLiteral: degree)
    }

    init(_ radian: Radian) {
        self.init(radianLiteral: radian)
    }
}

func sin(value: Radian) -> Double { return sin(Double(value.value)) }
func asin(value: Double) -> Radian { return Radian(Double(asin(value))) }
func cos(value: Radian) -> Double{ return cos(Double(value.value)) }
func acos(value: Double) -> Radian { return Radian(Double(acos(value))) }


func sin(value: Degree) -> Double{ return sin(Radian(value)) }
func asin(value: Double) -> Degree { return Degree(Double(asin(value))) }
func cos(value: Degree) -> Double{ return cos(Radian(value)) }
func acos(value: Double) -> Degree { return Degree(Double(acos(value))) }

let d180: Degree = Degree(180.0)
let r180: Radian = Radian(degreeLiteral: d180)

let d0 = Degree(0.0)
let r0 = Radian(d0)

let dsin180 = sin(d180)
let rsin180 = sin(r180)
let dcos180 = cos(d180)
let rcos180 = cos(r180)

let dsin0 = sin(d0)
let rsin0 = sin(r0)
let dcos0 = cos(d0)
let rcos0 = cos(r0)

let adsin180: Degree = asin(dsin180)
let adcos180: Degree = acos(dcos180)
2
投票

有没有设置或属性来更改内置三角函数。你应该只弧度严格的工作，如果你想简化你的表情，也可以定义自己sindeg，cosdeg等。

每个浮点类型都有一个内置的static成员名为pi其值π最佳逼近。例如：Double.pi，Float.pi，CGFloat.pi。

此外，罪90˚是1，而不是0。

1
投票

我不完全知道为什么你会想重载默认的全局方法，但如果你一定要，你可以提供一个替代方法签名：

func sin(#degrees: Double) -> Double { // Require a parameter name for method call
    let radians: Double = degrees * (M_PI / 180) // Convert to rad
    return sin(radians) // Return result of default method call with automatic conversion
}

sin(degrees: 90) // 1.0
sin(degrees: 180) // 0.0

然而，这确实是这样做的一种奇怪的方式，它会更有意义，明确地定义自己的方法（这是他们是什么），以类似的方式：

func sinFromDegrees(degrees: Double) -> Double {
    let radians: Double = degrees * (M_PI / 180)
    return sin(radians)
}

sinFromDegrees(90) // 1.0
sinFromDegrees(180) // 0.0
1
投票

看到我使用触发了很多。我发现最好的方法是定义class ViewController之外的一些功能。

如果您在.swift文件仅低于imports，略高于class ViewController:UIViewController { }中的任何一个定义它们，那么你可以打电话给他们在整个项目。

因此，对于正弦函数，我把它命名为sindeg()代表“罪恶度”。

func sindeg(degrees: Double) -> Double {
    return sin(degrees * M_PI / 180.0)
    }

因此，这需要你的度数转换它，解决它，并返回度。因此，所有你需要做的是类型sindeg(45.5)其结果将= 0.71325045.

这里是别人：

func cosdeg(degrees: Double) -> Double {
    return cos(degrees * M_PI / 180.0)
}
func tandeg(degrees: Double) -> Double {
    return tan(degrees * M_PI / 180.0)
}

反正切这里很相似，唯一的区别是返回式

 func atanDegree(degrees: Double) -> Double {
        return atan(degrees) * 180 / M_PI
    }

这一次只是转换一个弧度值度。以弧度，转换，返回度。

func Convert(radians: Double) -> Double {
    return radians * 180.0 / M_PI
}
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.