मैं डिग्री से रेडियन में कैसे बदल सकता हूं?

Question

मैं इस Obj-Cकोड को Swiftकोड में बदलने की कोशिश कर रहा हूं, लेकिन मुझे नहीं पता कि इस कोड के बराबर क्या होना चाहिए?

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

मैंने गुगली की और यह पाया

लेकिन मुझे समझ नहीं आ रहा है कि मेरे मामले में स्विफ्ट में कैसे परिवर्तित किया जाए?

Comments

मुझे लगता है कि आप कुछ कोड याद कर रहे हैं। क्या आप सभी सभी प्रासंगिक कोड जोड़ सकते हैं? किसी भी अन्य परिभाषित, जैसे डिग्री?

— ब्लैकहैटसमुई

यह मेरा स्विफ्ट कोड है: pastebin.com/bZ4a7EVN

— धर्मेश खेनी

क्या आप मुझे .h फ़ाइल दिखा सकते हैं?

— ब्लैकहैटसमुई

यह स्थूल है। आपको एक फंक्शन चाहिए।

— gnasher729 16

ultratip ... stackoverflow.com/a/28600210/294884

— फेटी

Answer 1

Xcode 11 • स्विफ्ट 5.1 या बाद में

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

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

---

खेल का मैदान

45.degreesToRadians         // 0.7853981633974483

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

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

Double(45).degreesToRadians    // 0.7853981633974483
CGFloat(45).degreesToRadians   // 0.7853981633974483
Float(45).degreesToRadians     // 0.7853981
Float80(45).degreesToRadians   // 0.78539816339744830963

यदि आप बाइनरी पूर्णांक को एक फ्लोटिंग पॉइंट प्रकार वापस करना चाहते हैं तो हमेशा एक CGFloat को वापस करने के बजाय आप एक कम्प्यूटेड संपत्ति के बजाय एक सामान्य विधि बना सकते हैं:

extension BinaryInteger {
    func degreesToRadians<F: FloatingPoint>() -> F {  F(self) * .pi / 180 }
}

---

let radiansDouble: Double = 45.degreesToRadians()   // 0.7853981633974483
let radiansCGFloat: CGFloat = 45.degreesToRadians() // 0.7853981633974483
let radiansFloat: Float = 45.degreesToRadians()     // 0.7853981
let radiansFloat80: Float80 = 45.degreesToRadians() // 0.78539816339744830963

Comments

क्या आपको विस्तार नहीं करना चाहिए CGFloat?

— जोराएर

@Zorayr ने स्विफ्ट 3 को अपडेट किया और फ्लोटिंगपोन का विस्तार करते हुए अब उन सभी को विस्तारित किया

— लियो डबस

दरअसल, स्विफ्ट 3 में आप मापन प्रकारों का उपयोग कर सकते हैं और आपको रूपांतरण फार्मूला जानने की आवश्यकता नहीं है!

— मैट

इस सुपर टिप पर ध्यान दें ... stackoverflow.com/a/28600210/294884

— Fattie

बिना कारण के मतदान करने का कोई मतलब नहीं है। एक टिप्पणी पोस्ट करें

— लियो डबस

Answer 2

यह आपके द्वारा पूछे गए पहचान के अनुसार नहीं है, लेकिन स्विफ्ट 3 / iOS 10 में, आप मापन प्रकार का उपयोग कर सकते हैं और फॉर्मूला जाने बिना रूपांतरण कर सकते हैं!

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

Comments

अद्भुत @matt काम पर फिर से, धन्यवाद! दुर्भाग्य से केवल iOS 10।

— अर्थ-मामले

दिलचस्प बात यह है कि रेडियंस = CGFloat (30.3 * .pi / 180.0) को रेडियंस 2 = मापन (मान: 30.3, इकाई: UnitAngle.degrees) .converted (.radians) पर जाने दें। अंतराल अलग होगा: 0.5288347633542818 और 0.5288345742619878

— Zaporozhuan-

और निश्चित रूप से "'मापन' केवल iOS 10.0 या नए पर उपलब्ध है"

— Zaporozhchenko ऑलेक्ज़ेंडर

Answer 3

Apple रूपांतरण के लिए ये GLKit फ़ंक्शन प्रदान करता है :

func GLKMathDegreesToRadians(_ degrees: Float) -> Float
func GLKMathRadiansToDegrees(_ radians: Float) -> Float

Comments

GLKit जल्द ही बंद होने जा रहा है, क्योंकि अब यह धातु की दुनिया है, बाय GL। मैक के लिए iPad एप्लिकेशन को पोर्ट करने के रूप में, GLKit अब समर्थित नहीं है!।

— Juguang

Answer 4

let angle = 45° // angle will be in radians, 45 is in degrees

स्विफ्ट 3 के तहत संकलन । फिर भी सभी मान रखें, CGFloats के साथ रेडियन में सभी गणना करें ..., लेकिन डिग्री में स्थिरांक के साथ कोड को अधिक पठनीय बनाते हैं। उदाहरण के लिए: 90 ° ° चिन्ह जादुई रूप से रेडियन रूपांतरण के लिए डिग्री प्रदान करेगा।

इसे कैसे सेट करें:

° चिह्न के लिए पोस्टफ़िक्स ऑपरेटर को परिभाषित और उपयोग करें। यह ऑपरेटर डिग्रियों से रेडियन में रूपांतरण करेगा। यह उदाहरण इनट्स के लिए है, अगर जरूरत है तो फ्लोट प्रकारों के लिए भी इनका विस्तार करें।

postfix operator °

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

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

उपयोग के कुछ उदाहरण:

let angle = 45°

contentView.transform = CGAffineTransform(rotationAngle: 45°)

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

चेतावनी!

दो बार इस रूपांतरण का उपयोग करना बहुत आसान है (गलती से पहले से ही रेडियन में एक मूल्य पर), आपको परिणाम के रूप में बहुत कम संख्या मिलेगी, और प्रतीत होता है कि परिणामी कोण हमेशा शून्य होगा ... उसी पर ° का उपयोग न करें मूल्य दो बार (दो बार कन्वर्ट नहीं) !! !!

// 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

Comments

IntegerInitializableप्रोटोकॉल व्यर्थ है। Int पहले से ही अनुरूप हैExpressibleByIntegerLiteral

— लियो डबस

Btw आप किसी भी पूर्णांक का समर्थन करने के लिए इस ऑपरेटर को सामान्य बना सकते हैं और किसी भी फ्लोटिंग पॉइंट को वापस कर सकते हैं। public extension FixedWidthInteger { postfix static func °<T: FloatingPoint>(lhs: Self) -> T { T(lhs) * .pi / 180 } }

— सिंह डबस

और इससे पहले कि आप इस बारे में टिप्पणी करें कि एक सामान्य विधि बनाते समय आपको परिणामी प्रकार को स्पष्ट रूप से सेट करने की आवश्यकता होगी यदि कंपाइलर परिणामी प्रकार का अनुमान नहीं लगा सकता है let angle: CGFloat = 45°। लेकिन इसकी ज़रूरत नहीं है जहाँ यह एक CGFloatया किसी भी FloatingPointप्रकार की उम्मीद करता हैCGAffineTransform(rotationAngle: 45°)

— लियो डबस

Answer 5

इसके अलावा, फ्रॉन रेडियंस को डिग्री में बदलने के लिए (यदि कोई इस पर Google से ठोकर खाता है):

var degrees = radians * (180.0 / M_PI)

Answer 6

चर नाम बनाते समय आप ASCII वर्णों तक सीमित नहीं हैं, इसलिए alt (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
    }
}

उदाहरण का उपयोग:

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

Answer 7

स्विफ्ट 4.2

आप वैश्विक सामान्य कार्य लिख सकते हैं:

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

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

उदाहरण:

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

मामले में जब आप इस तरह से अपने सभी अस्थायी प्रकारों का विस्तार नहीं करना चाहते हैं

extension FloatingPoint { ... }

Comments

बस क्यों नहीं return .pi * degrees / 180?

— लियो डबस

@LeoDabus क्योंकि Tहै FloatingPointप्रकार और 180 है Intप्रकार। तेजी से आप विभिन्न प्रकारों पर गणना नहीं कर सकते।

— तिकोनोव अलेक्जेंडर

तुम गलत हो। स्विफ्ट प्रकार का अनुमान लगा सकता है। यह बिल्कुल वैसा ही व्यवहार करता है जैसे कि आप फ्लोटिंग पॉइंट प्रकार का विस्तार कर रहे थे। 180 किसी भी चीज की हो सकती है। जरूरी नहीं कि एक इंट

— लियो डबस

फ्लोटिंगपॉइंट ExpressibleByIntegerLiteral के अनुरूप है, इसलिए आप वहां 180 लिख सकते हैं

— लियो डबस

180.0 को T की आवश्यकता है क्योंकि T जरूरी नहीं कि डबल हो। यह किसी भी फ्लोटिंग पॉइंट प्रकार का हो सकता है। आप अपने डबल 180.0 से एक नया एक शुरू करते हैं

— लियो डबस

Answer 8

मैं ऊपर बताए गए समान सिद्धांत @ t1ser का उपयोग करूंगा, लेकिन CGFloatडिग्री के लिए दशमलव का उपयोग करना आसान बनाने के लिए एक एक्सटेंशन बनाएं (ताकि आपके पास 23.4 डिग्री हो, उदाहरण के लिए):

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

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

इसका उपयोग करना बहुत आसान होगा और साथ ही (मुख्यतः क्योंकि मैं व्यक्तिगत रूप से ° in टाइप करने के लिए नहीं जानता था - यदि आप या तो नहीं थे, तो यह बताया गया है option+shift+8:

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

या आरंभीकरण का उपयोग करने के लिए:

let convertedDegrees = CGFloat(degrees: 45.3)

Answer 9

तेजी से 2.3

func  kilometersBetween(Place1:CLLocationCoordinate2D , Place2:CLLocationCoordinate2D) -> Double{
    var start = MKMapPointForCoordinate(Place1)
    var finish = MKMapPointForCoordinate(Place2)
    print(MKMetersBetweenMapPoints(start, finish) / 1000)
    return MKMetersBetweenMapPoints(start, finish) / 1000
} 

Comments

हालांकि यह कोड प्रश्न का उत्तर दे सकता है, लेकिन यह समस्या का हल कैसे और / या इसके बारे में अतिरिक्त संदर्भ प्रदान करता है, इससे उत्तर के दीर्घकालिक मूल्य में सुधार होगा।

— निक 3500