功能目前工作正常,返回Double
並且已經給出了變量,我需要,即frequency.
最好不要去改變它。我將創建一個新類以添加更多功能(即將頻率映射到MIDI鍵盤的按鍵)。 謝謝羅布和jtbandes的輸入。
編輯
這是更明智的解決這個無增寬問題空間。我發現我的解決方案,一旦我質疑需要返回一個參數的功能,並詢問如何使用只有可用的參數從函數內部呈現數據。該解決方案能夠滿足所確定的accepted answer to another post相關的問題以及其他幾個職位推薦解開可選值,而不會導致運行時錯誤(here,here和here)
值使用可選的鏈接展開並零合併而不是強制解包。根據these rules有效的數字被轉換爲頻率並映射到MIDI鍵盤。標有‘x’
(如these rules指定)的無效調諧值和音符串將生成0.0 Hz的頻率。
該解決方案允許將函數讀取的可選比例值與其他函數調用時返回的頻率進行比較。
例如
Octave map
0 Optional("x")
0 : 0.0
1 Optional("35/32")
1 : 286.1534375
2 Optional("x")
2 : 0.0
3 Optional("x")
3 : 0.0
4 Optional("5/4")
4 : 327.0325
5 Optional("21/16")
5 : 343.384125
6 Optional("x")
6 : 0.0
7 Optional("3/2")
7 : 392.439
8 Optional("x")
8 : 0.0
9 Optional("x")
9 : 0.0
10 Optional("7/4")
10 : 457.8455
11 Optional("15/8")
11 : 490.54875
它還與閱讀頻率有助於其他八度音階
MIDI map
Octave 0
0 0 0.0
1 1 8.942294921875
2 2 0.0
3 3 0.0
4 4 10.219765625
5 5 10.73075390625
6 6 0.0
7 7 12.26371875
8 8 0.0
9 9 0.0
10 10 14.307671875
11 11 15.3296484375
Octave 1
12 0 0.0
13 1 17.88458984375
14 2 0.0
15 3 0.0
16 4 20.43953125
17 5 21.4615078125
18 6 0.0
19 7 24.5274375
20 8 0.0
21 9 0.0
22 10 28.61534375
23 11 30.659296875
Octave 2
24 0 0.0
25 1 35.7691796875
26 2 0.0
etc
Octave 9
108 0 0.0
109 1 4578.455
110 2 0.0
111 3 0.0
112 4 5232.52
113 5 5494.146
114 6 0.0
115 7 6279.024
116 8 0.0
117 9 0.0
118 10 7325.528
119 11 7848.78
Octave 10
120 0 0.0
121 1 9156.91
122 2 0.0
123 3 0.0
124 4 10465.04
125 5 10988.292
126 6 0.0
音樂的開發應用可能會發現這很有用,因爲它顯示瞭如何創建一個重新調校MIDI映射。該解決方案讓我解開包含分數和小數的數字字符串,這些字符串指定音樂音符中音符的調節,這超出了標準音樂鍵盤的範圍。任何訪問this site的人都不會失去它的重要性。
下面是代碼
Tuner.swift
import UIKit
class Tuner {
var tuning = [String]() // .scl
var pitchClassFrequency = Double() // .scl
let centsPerOctave: Double = 1200.0 // .scl mandated by Scala tuning file format
let formalOctave: Double = 2.0 // .kbm/.scl Double for stretched-octave tunings
var octaveMap = [Double]() // .kbm/.scl
var midiMap = [Double]() // .kbm
let sizeOfMap = 12 // .kbm
let firstMIDIKey = 0 // .kbm
let lastMIDIKey = 127 // .kbm
let referenceMIDIKey = 60 // .kbm
let referenceFrequency: Double = 261.626 // .kbm frequency of middle C
var indexMIDIKeys = Int()
var indexOctaveKeys = Int()
var currentKeyOctave = Int()
var index: Int = 0
init(tuning: [String]) {
self.tuning = tuning
// SCL file format - create frequency map of notes for one octave
print("Octave map")
print("")
let _ = tuning.flatMap(scaleToFrequencies)
// KBM file format - create frequency map of MIDI keys 0-127
print("")
print("MIDI map")
let _ = createMIDIMap()
}
func createMIDIMap() {
indexOctaveKeys = firstMIDIKey // set indexOctaveKeys to pitchClass 0
currentKeyOctave = firstMIDIKey // set currentOctave to octave 0
for indexMIDIKeys in firstMIDIKey...lastMIDIKey {
let indexOctaveKeys = indexMIDIKeys % sizeOfMap
currentKeyOctave = Int((indexMIDIKeys)/sizeOfMap)
let frequency = octaveMap[indexOctaveKeys] * 2**Double(currentKeyOctave)
// midiMap[i] = octaveMap[indexMIDIKeys] * 2**Double(currentKeyOctave)
if indexOctaveKeys == 0 {
print("")
print("Octave \(currentKeyOctave)")
}
print(indexMIDIKeys, indexOctaveKeys, frequency)
}
}
func scaleToFrequencies(s: String?) {
var frequency: Double = 0.0
// first process non-numerics.
let numericString = zapAllButNumbersSlashDotAndX(s: s)
print(index, numericString as Any) // eavesdrop on String?
// then process numerics.
frequency = (processNumericsAndMap(numericString: numericString))/Double(2)**Double(referenceMIDIKey/sizeOfMap)
octaveMap.append(frequency)
print(index,":",frequency * 2**Double(referenceMIDIKey/sizeOfMap))
index += 1
}
func processNumericsAndMap(numericString: String?) -> Double {
guard let slashToken = ((numericString?.contains("/")) ?? nil),
let dotToken = ((numericString?.contains(".")) ?? nil),
let xToken = ((numericString?.contains("x")) ?? nil),
slashToken == false,
dotToken == true,
xToken == false
else {
guard let dotToken = ((numericString?.contains(".")) ?? nil),
let xToken = ((numericString?.contains("x")) ?? nil),
dotToken == false,
xToken == false
else {
guard let xToken = ((numericString?.contains("x")) ?? nil),
xToken == false
else {
// then it must be mapping.
let frequency = 0.0
// print("[x] \(frequency) Hz")
return frequency
}
// then process integer.
let frequency = processInteger(s: numericString)
return frequency
}
// then process fractional.
let frequency = processFractional(s: numericString)
return frequency
}
// process decimal.
let frequency = processDecimal(s: numericString)
return frequency
}
func processFractional(s: String?) -> Double {
let parts = s?.components(separatedBy: "/")
guard parts?.count == 2,
let numerator = Double((parts?[0])?.digits ?? "failNumerator"),
let dividend = Double((parts?[1])?.digits ?? "failDenominator"),
dividend != 0
else {
let frequency = 0.0
print("invalid ratio: frequency now being set to \(frequency) Hz")
return frequency
}
let frequency = referenceFrequency * (numerator/dividend)
return frequency
}
func processDecimal(s: String?) -> Double {
let parts = s?.components(separatedBy: ".")
guard parts?.count == 2,
let intervalValue = Double(s ?? "failInterval"),
let _ = Double((parts?[0])?.digits ?? "failDecimal")
else {
let frequency = 0.0
print("invalid cents value: frequency now being forced to \(frequency) Hz ")
return frequency
}
let power = intervalValue/centsPerOctave // value with explicit remainder
let frequency = referenceFrequency * (formalOctave**power)
return frequency
}
func processInteger(s: String?) -> Double {
let frequency = 0.0
print("not cents, not ratio : frequency now being set to \(frequency) Hz ")
return frequency
}
func zapAllButNumbersSlashDotAndX(s: String?) -> String? {
var mixedString = s
if mixedString != nil {
mixedString = mixedString!
}
guard var _ = mixedString?.contains("/"),
var _ = mixedString?.contains(".")
else {
let numberToken = mixedString
return numberToken
}
guard let xToken = mixedString?.contains("x"),
xToken == false
else {
let xToken = "x"
return xToken
}
let notNumberCharacters = NSCharacterSet.decimalDigits.inverted
let numericString = s?.trimmingCharacters(in: notNumberCharacters) ?? "orElse"
return numericString.stringByRemovingWhitespaces
}
}
extension String {
var stringByRemovingWhitespaces: String {
return components(separatedBy: .whitespaces).joined(separator: "")
}
}
extension String {
var digits: String {
return components(separatedBy: CharacterSet.decimalDigits.inverted).joined()
}
}
precedencegroup Exponentiative {
associativity: left
higherThan: MultiplicationPrecedence
}
infix operator ** : Exponentiative
func ** (num: Double, power: Double) -> Double {
return pow(num, power)
}
func pitchClass(pitchClass: Int, _ frequency: Double) -> Int {
return pitchClass
}
func frequency(pitchClass: Int, _ frequency: Double) -> Double {
return frequency
}
ViewController.swift
import UIKit
class ViewController: UIViewController {
// Hexany: 6-note scale of Erv Wilson
let tuning = ["x", "35/32", "x", "x", "5/4", "21/16", "x", "3/2", "x", "x", "7/4", "15/8"]
// Diatonic scale: rational fractions
// let tuning = [ "1/1", "9/8", "5/4", "4/3", "3/2", "27/16", "15/8", "2/1"]
// Mohajira: rational fractions
// let tuning = [ "21/20", "9/8", "6/5", "49/40", "4/3", "7/5", "3/2", "8/5", "49/30", "9/5", "11/6", "2/1"]
// Diatonic scale: 12-tET
// let tuning = [ "0.0", "200.0", "400.0", "500", "700.0", "900.0", "1100.0", "1200.0"]
override func viewDidLoad() {
super.viewDidLoad()
_ = Tuner(tuning: tuning)
}
}
什麼是'tuning'?什麼是「scaleFrequencies」?你爲什麼期望'tuning.flatMap(scaleFrequencies)'產生一個可以分配給'notes'的元組? – jtbandes
您是否想要像'scaleFrequencies(tuning)'中那樣將'tuning'傳遞給您的函數? – jtbandes
'tuning'的每個元素依次傳遞給'scaleFrequencies.'從那裏傳遞給另一個函數'processNumerics',在這裏函數展開(使用guard和nil合併,即不強制展開) - 計算frequency和頻率返回 – Greg