对于一个简单的源代码来说，Swift编译性能太慢了

我试图制作一个小的Swift 3代码，将声纳日期转换为农历日期。 一个非常小的代码，但是Xcode需要大约10分钟来编译它。 你能给我一些建议来提高性能吗。 这是我的swift代码：

class DateExtensions {
    let PI: Double = M_PI

    func jdFromDate(day: Int, month: Int, year: Int) ->Int {
        let a: Int = (14 - month) / 12
        let y: Int = year + 4800 - a
        let m: Int = month + 12 * a - 3
        var jd: Int = day + (153 * m + 2)/5 + 365 * y + y/4 - y/100 + y/400 - 32045

        if (jd < 2299161) {
            jd = day + (153 * m + 2)/5 + 365 * y + y/4 - 32083
        }

        return jd
    }

    func jdToDate(_ jd: Int) -> [Int] {
        var a: Int = 0
        var b: Int = 0
        var c: Int = 0

        if (jd > 2299160) { // After 5/10/1582, Gregorian calendar
            a = jd + 32044
            b = (4 * a + 3) / 146097
            c = a - (b * 146097) / 4
        } else {
            b = 0
            c = jd + 32082
        }
        let d: Int = (4 * c + 3)/1461
        let e: Int = c - (1461 * d)/4
        let m: Int = (5 * e + 2)/153
        let day: Int = e - (153 * m + 2)/5 + 1
        let month: Int = m + 3 - 12 * (m/10)
        let year: Int = b * 100 + d - 4800 + m/10

        return [day, month, year]
    }

    func SunLongitude(_ jdn: Double) -> Double {
        return SunLongitudeAA98(jdn)
    }

    func SunLongitudeAA98(_ jdn: Double) -> Double {
        let T: Double = (jdn - 2451545.0 ) / 36525 // Time in Julian centuries from 2000-01-01 12:00:00 GMT
        let T2: Double = T * T
        let dr: Double = PI/180 // degree to radian
        let M: Double = 357.52910 + 35999.05030 * T - 0.0001559 * T2 - 0.00000048 * T * T2 // mean anomaly, degree
        let L0: Double = 280.46645 + 36000.76983 * T + 0.0003032 * T2 // mean longitude, degree
        var DL: Double = (1.914600 - 0.004817 * T - 0.000014 * T2) * sin(dr * M)
        DL = DL + (0.019993 - 0.000101 * T) * sin(dr * 2 * M) + 0.000290 * sin(dr * 3 * M)
        var L: Double = L0 + DL // true longitude, degree
        L = Double(L - 360 * (INT(L/360))) // Normalize to (0, 360)

        return L
    }

    func NewMoon(_ k: Int) -> Double {
        return NewMoonAA98(k)
    }

    func NewMoonAA98(_ k: Int) -> Double {
        var T: Double = k/1236.85 // Time in Julian centuries from 1900 January 0.5
        var T2: Double = T * T
        var T3: Double = T2 * T
        var dr: Double = PI/180
        var Jd1: Double = Double(2415020.75933 + 29.53058868*k + 0.0001178*T2 - 0.000000155*T3)
        Jd1 = Jd1 + 0.00033*sin((166.56 + 132.87*T - 0.009173*T2)*dr) // Mean new moon
        var M: Double = Double(359.2242 + 29.10535608*k - 0.0000333*T2 - 0.00000347*T3) // Sun's mean anomaly
        var Mpr: Double = Double(306.0253 + 385.81691806*k + 0.0107306*T2 + 0.00001236*T3) // Moon's mean anomaly
        var F: Double = Double(21.2964 + 390.67050646*k - 0.0016528*T2 - 0.00000239*T3) // Moon's argument of latitude
        var C1: Double = (0.1734 - 0.000393*T)*sin(M*dr) + 0.0021*sin(2*dr*M)
        C1 = C1 - 0.4068*sin(Mpr*dr) + 0.0161*sin(dr*2*Mpr)
        C1 = C1 - 0.0004*sin(dr*3*Mpr)
        C1 = C1 + 0.0104*sin(dr*2*F) - 0.0051*sin(dr*(M+Mpr))
        C1 = C1 - 0.0074*sin(dr*(M-Mpr)) + 0.0004*sin(dr*(2*F+M))
        C1 = C1 - 0.0004*sin(dr*(2*F-M)) - 0.0006*sin(dr*(2*F+Mpr))
        C1 = C1 + 0.0010*sin(dr*(2*F-Mpr)) + 0.0005*sin(dr*(2*Mpr+M))
        var deltat: Double = 0

        if (T < -11) {
            deltat = 0.001 + 0.000839 * T + 0.0002261 * T2 - 0.00000845 * T3 - 0.000000081 * T * T3
        } else {
            deltat = -0.000278 + 0.000265 * T + 0.000262 * T2
        }

        let JdNew: Double = Jd1 + C1 - deltat

        return JdNew
    }

    func INT(_ d: Double) -> Int {
        return Int(exactly: floor(d))!
    }

    func getSunLongitude(_ dayNumber: Int, _ timeZone: Double) -> Double {
        return SunLongitude(dayNumber - 0.5 - timeZone/24)
    }

    func getNewMoonDay(_ k: Int, _ timeZone: Double) -> Int {
        let jd: Double = NewMoon(k)
        return INT(jd + 0.5 + timeZone/24)
    }

    func getLunarMonth11(_ yy: Int, _ timeZone: Double) -> Int {
        var off: Double = jdFromDate(31, 12, yy) - 2415021.076998695
        var k: Int = INT(off / 29.530588853)
        var nm: Int = getNewMoonDay(k, timeZone)
        var sunLong: Int = INT(getSunLongitude(nm, timeZone)/30)

        if (sunLong >= 9) {
            nm = getNewMoonDay(k-1, timeZone)
        }

        return nm
    }
    func getLeapMonthOffset(_ a11: Int, _ timeZone: Double) -> Int {
        var k: Int = INT(0.5 + (a11 - 2415021.076998695) / 29.530588853)
        var last: Int = 0 // Month 11 contains point of sun longutide 3*PI/2 (December solstice)
        var i: Int = 1 // We start with the month following lunar month 11
        var arc = INT(getSunLongitude(getNewMoonDay(k+i, timeZone), timeZone)/30)

        repeat {
            last = arc
            i = i + 1
            arc = INT(getSunLongitude(getNewMoonDay(k+i, timeZone), timeZone)/30)
        } while (arc != last && i < 14)

        return i - 1
    }

    func convertSolar2Lunar(_ dd: Int, _ mm: Int, _ yy: Int, _ timeZone: Double) -> [Int] {
        var lunarDay: Int = 0
        var lunarMonth: Int = 0
        var lunarYear: Int = 0
        var lunarLeap: Int = 0
        var dayNumber: Int = jdFromDate(dd, mm, yy)
        var k: Int = INT((dayNumber - 2415021.076998695) / 29.530588853)
        var monthStart: Int = getNewMoonDay(k + 1, timeZone)

        if (monthStart > dayNumber) {
            monthStart = getNewMoonDay(k, timeZone)
        }

        var a11: Int = getLunarMonth11(yy, timeZone)
        var b11: Int = a11

        if (a11 >= monthStart) {
            lunarYear = yy
            a11 = getLunarMonth11(yy-1, timeZone)
        } else {
            lunarYear = yy + 1
            b11 = getLunarMonth11(yy + 1, timeZone)
        }

        lunarDay = dayNumber - monthStart + 1
        var diff: Int = INT((monthStart - a11)/29)
        lunarLeap = 0
        lunarMonth = diff + 11

        if (b11 - a11 > 365) {
            var leapMonthDiff: Int = getLeapMonthOffset(a11, timeZone)
            if (diff >= leapMonthDiff) {
                lunarMonth = diff + 10
                if (diff == leapMonthDiff) {
                    lunarLeap = 1
                }
            }
        }
        if (lunarMonth > 12) {
            lunarMonth = lunarMonth - 12
        }
        if (lunarMonth >= 11 && diff < 4) {
            lunarYear = lunarYear - 1
        }
        return [lunarDay, lunarMonth, lunarYear, lunarLeap]
    }

    func convertLunar2Solar(_ lunarDay: Int, _ lunarMonth: Int, _ lunarYear: Int, _ lunarLeap: Int, _ timeZone: Double) -> [Int]{
        var a11: Int = 0
        var b11: Int = 0

        if (lunarMonth < 11) {
            a11 = getLunarMonth11(lunarYear-1, timeZone)
            b11 = getLunarMonth11(lunarYear, timeZone)
        } else {
            a11 = getLunarMonth11(lunarYear, timeZone)
            b11 = getLunarMonth11(lunarYear+1, timeZone)
        }

        var k: Int = INT(0.5 + (a11 - 2415021.076998695) / 29.530588853)
        var off: Int = lunarMonth - 11

        if (off < 0) {
            off = off + 12
        }

        if (b11 - a11 > 365) {
            var leapOff: Int = getLeapMonthOffset(a11, timeZone)
            var leapMonth: Int = leapOff - 2

            if (leapMonth < 0) {
                leapMonth = leapMonth + 12
            }

            if (lunarLeap != 0 && lunarMonth != leapMonth) {
                //debugPrint("Invalid input!")
                return new [0, 0, 0]
            } else if (lunarLeap != 0 || off >= leapOff) {
                off = off + 1
            }
        }

        let monthStart: Int = getNewMoonDay(k + off, timeZone)

        return jdToDate(monthStart+lunarDay-1)
    }
}

类扩展名{
设PI:Double=M_-PI
func jdFromDate（日：整数，月：整数，年：整数）->Int{
设a:Int=（14个月）/12
设y:Int=year+4800-a
设m:Int=month+12*a-3
变量jd:Int=day+（153*m+2）/5+365*y+y/4-y/100+y/400-32045
如果（jd<2299161）{
jd=日+（153*m+2）/5+365*y+y/4-32083
}
返回jd
}
func jdToDate（jd:Int）->[Int]{
变量a:Int=0
变量b:Int=0
变量c:Int=0
如果（jd>2299160）{//1582年10月5日之后，公历
a=jd+32044
b=（4*a+3）/146097
c=a-（b*146097）/4
}否则{
b=0
c=jd+32082
}
设d:Int=（4*c+3）/1461
设e:Int=c-（1461*d）/4
设m:Int=（5*e+2）/153
第二天：Int=e-（153*m+2）/5+1
月份：Int=m+3-12*（m/10）
年份：Int=b*100+d-4800+m/10
报税表[日、月、年]
}
func太阳经度（jdn:Double）->Double{
返回SunLongitudeAA98（jdn）
}
func SunLongitudeAA98（jdn:Double）->Double{
让T:Double=（jdn-2451545.0）/36525//2000-01-01 12:00:00 GMT开始的朱利安世纪时间
设T2:Double=T*T
设dr:Double=PI/180//弧度
设M:Double=357.52910+35999.05030*T-0.0001559*T2-0.00000048*T*T2//平均异常，度
设L0:Double=280.46645+36000.76983*T+0.0003032*T2//平均经度，度
变量DL:Double=（1.914600-0.004817*T-0.000014*T2）*sin（dr*M）
DL=DL+（0.019993-0.000101*T）*sin（dr*2*M）+0.000290*sin（dr*3*M）
变量L:Double=L0+DL//真实经度，度
L=Double（L-360*（INT（L/360））//标准化为（0360）
返回L
}
func NewMoon（k:Int）->Double{
返回新月AA98（k）
}
func NewMoonAA98（k:Int）->Double{
var T:Double=k/1236.85//朱利安世纪的时间，从1900年1月起0.5
变量T2:Double=T*T
变量T3:Double=T2*T
变量dr:Double=PI/180
变量Jd1:Double=Double（2415020.75933+29.53058868*k+0.0001178*T2-0.000000155*T3）
Jd1=Jd1+0.00033*sin（（166.56+132.87*T-0.009173*T2）*dr）//平均新月
var M:Double=Double（359.2242+29.10535608*k-0.0000333*T2-0.00000347*T3）//太阳平均异常
var Mpr:Double=Double（306.0253+385.81691806*k+0.0107306*T2+0.00001236*T3）//月球平均异常
var F:Double=双（21.2964+390.67050646*k-0.0016528*T2-0.00000239*T3）//月球纬度论证
变量C1:Double=（0.1734-0.000393*T）*sin（M*dr）+0.0021*sin（2*dr*M）
C1=C1-0.4068*sin（最大持续功率*dr）+0.0161*sin（最大持续功率*2*Mpr）
C1=C1-0.0004*sin（dr*3*Mpr）
C1=C1+0.0104*sin（dr*2*F）-0.0051*sin（dr*（M+Mpr））
C1=C1-0.0074*sin（dr*（M-Mpr））+0.0004*sin（dr*（2*F+M））
C1=C1-0.0004*sin（dr*（2*F-M））-0.0006*sin（dr*（2*F+Mpr））
C1=C1+0.0010*sin（dr*（2*F-Mpr））+0.0005*sin（dr*（2*Mpr+M））
变量deltat:Double=0
如果（T<-11）{
deltat=0.001+0.000839*T+0.0002261*T2-0.00000845*T3-0.000000081*T*T3
}否则{
deltat=-0.000278+0.000265*T+0.000262*T2
}
让JdNew:Double=Jd1+C1-deltat
返回新的
}
func INT（d:Double）->INT{
返回整数（准确地说：楼层（d））！
}
func getsunLength（uDayNumber:Int，u时区：Double）->Double{
返回太阳经度（日数-0.5-时区/24）
}
func getNewMoonDay（k:Int，u时区：Double）->Int{
让jd:Double=新月（k）
返回整数（jd+0.5+时区/24）
}
func getLunarMonth11（yy:Int，uo时区：Double）->Int{
var off:Double=jdFromDate（31，12，yy）-2415021.076998695
变量k:Int=Int（关闭/29.530588853）
var nm:Int=getNewMoonDay（k，时区）
var sunLong:Int=Int（getSunLongitude（nm，时区）/30）
如果（阳光>=9）{
nm=getNewMoonDay（k-1，时区）
}
返回nm
}
func getLeapMonthOffset（a11:Int，u时区：Double）->Int{
变量k:Int=Int（0.5+（a11-2415021.076998695）/29.530588853）
var last:Int=0//11月包含sun longutide 3*PI/2点（12月至）
var i:Int=1//我们从农历11月的下一个月开始
var arc=INT（getSunLongitude（getNewMoonDay（k+i，时区），时区）/30）
重复{
最后=弧
i=i+1
arc=INT（getSunLongitude（getNewMoonDay（k+i，时区），时区）/30）
}while（弧！=最后一个&i<14）
返回i-1
}
func convertSolar2Lunar（dd:Int，mm:Int，yy:Int，uu时区：Double）->[Int]{
变量lunarDay:Int=0
变量lunarMonth:Int=0
变量lunarYear:Int=0
变量lunarLeap:Int=0
变量日数：Int=jdFromDate（日、月、年）
变量k:Int=Int（（日数-2415021.076998695）/29.530588853）
var monthStart:Int=getNewMoonDay（k+1，时区）
如果（月开始>日数）{
monthStart=getNewMoonDay（k，时区）
}
变量a11:Int=getLunarMonth11（yy，时区）
变量b11:Int=a11
如果（a11>=月开始）{
月牙=yy
a11=getLunarMonth11（yy-1，时区）
}否则{
月牙=yy+1
b11=getLunarMonth11（yy+1，时区
//
//  DateExtensions.swift
//  Sonar2Lunar
//
//  Created by Nguyen Thanh Hai on 5/7/17.
//  Copyright © 2017 Nguyen Thanh Hai. All rights reserved.
//

import Foundation
import SwiftDate

class DateExtensions {
    let PI: Double = M_PI

    func jdFromDate(_ day: Int, _ month: Int, _ year: Int) ->Int {
        let a: Int = (14 - month) / 12
        let y: Int = year + 4800 - a
        let m: Int = month + 12 * a - 3
        var jd: Int = day + (153 * m + 2)/5 + 365 * y + y/4 - y/100 + y/400 - 32045

        if (jd < 2299161) {
            jd = day + (153 * m + 2)/5 + 365 * y + y/4 - 32083
        }

        return jd
    }

    func jdToDate(_ jd: Int) -> [Int] {
        var a: Int = 0
        var b: Int = 0
        var c: Int = 0

        if (jd > 2299160) { // After 5/10/1582, Gregorian calendar
            a = jd + 32044
            b = (4 * a + 3) / 146097
            c = a - (b * 146097) / 4
        } else {
            b = 0
            c = jd + 32082
        }
        let d: Int = (4 * c + 3)/1461
        let e: Int = c - (1461 * d)/4
        let m: Int = (5 * e + 2)/153
        let day: Int = e - (153 * m + 2)/5 + 1
        let month: Int = m + 3 - 12 * (m/10)
        let year: Int = b * 100 + d - 4800 + m/10

        return [day, month, year]
    }

    func INT(_ d: Double) -> Int {
        return Int(exactly: floor(d))!
    }

    func SunLongitude(_ jdn: Double) -> Double {
        return SunLongitudeAA98(jdn)
    }

    func SunLongitudeAA98(_ jdn: Double) -> Double {
        let T: Double = (jdn - 2451545.0 ) / 36525 // Time in Julian centuries from 2000-01-01 12:00:00 GMT
        let T2: Double = T * T
        let dr: Double = PI/180 // degree to radian
        let M: Double = 357.52910 + 35999.05030 * T - 0.0001559 * T2 - 0.00000048 * T * T2 // mean anomaly, degree
        let L0: Double = 280.46645 + 36000.76983 * T + 0.0003032 * T2 // mean longitude, degree
        var DL: Double = (1.914600 - 0.004817 * T - 0.000014 * T2) * sin(dr * M)
        DL = DL + (0.019993 - 0.000101 * T) * sin(dr * 2 * M) + 0.000290 * sin(dr * 3 * M)
        var L: Double = L0 + DL // true longitude, degree
        L = L - Double(360 * (INT(L/360))) // Normalize to (0, 360)

        return L
    }
}

func NewMoonAA98(_ k: Int) -> Double {
    var T: Double = k/1236.85 // Time in Julian centuries from 1900 January 0.5
    var T2: Double = T * T
    var T3: Double = T2 * T
    var dr: Double = PI/180
    var Jd1: Double = Double(2415020.75933 + 29.53058868*k + 0.0001178*T2 - 0.000000155*T3)

    var T: Double = k/1236.85 // Time in Julian centuries from 1900 January 0.5

    var T: Double = Double(k)/1236.85 // Time in Julian centuries from 1900 January 0.5

    var Jd1: Double = Double(2415020.75933 + 29.53058868*k + 0.0001178*T2 - 0.000000155*T3)

    var Jd1: Double = Double(2415020.75933 + 29.53058868*Double(k) + 0.0001178*T2 - 0.000000155*T3)