open var next: UIResponder? { get }
open var canBecomeFirstResponder: Bool { get } // default is NO    
// default is NO
open func becomeFirstResponder() -> Bool
open var canResignFirstResponder: Bool { get } // default is YES    
// default is YES
open func resignFirstResponder() -> Bool
open var isFirstResponder: Bool { get }
open func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?)
open func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?)
open func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?)
open func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?)

func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView?
func point(inside point: CGPoint, with event: UIEvent?) -> Bool

// 模拟原生未干预下的代码
override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
	if !isUserInteractionEnabled || isHidden || alpha<=0.01 { return nil }
	if !self.point(inside: point, with: event) { return nil }
	for subview in subviews.reversed() {
		let convertPoint = subview.convert(point, from: self)
		let subHitTestView = subview.hitTest(convertPoint, with: event)
		if let hitTestView = subHitTestView { return hitTestView }
	}
	return self
}

override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
	let view = super.hitTest(point, with: event)
	return view == self ? nil : view
}

override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
	let view = super.hitTest(point, with: event)
	return view == someBtn ? anotherBtn : view
}

override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
	if someBtn.frame.insetBy(dx: -10, dy: -10).contains(point) {
		return someBtn
	}
	return super.point(inside: point, with: event)
}

// 模拟随机数据
var doubles  = (0...10000).map {_ in Double(arc4random()%10000)}
// 求和
// 常见的加法求和
let reduceSum = doubles.reduce(0) { $0+$1 }
// Accelerate 封装
let accSum = sum(doubles)
// 求最大值（最小值也一样）
let maxOfArr = max(doubles)
let maxOfArr2 = doubles.maxElement
// let maxOfArr2 = doubles.sort(>).first
// 平均值,哈哈大数据统计，可以测试准确率
let meanValue = mean(doubles)
let meanValue2 = doubles.reduce(0) { $0 + $1/Double(doubles.count) }
meanValue2
// 向量加减乘积
let vector1 = [2,4,5] as [Double]
let vector2 = [3,5,2] as [Double]
let sumArrs = add(vector1, y: vector2)

let newReduceSum = (0...1000).reduce(0) { $0+$1 }
newReduceSum

let 函数点阵密度 = 64
let 频率1 = 4.0
let 相位1 = 0.0
let 幅度1 = 1.0
let 正弦函数1 = (0..<函数点阵密度).map {
    幅度1 * sin(2.0 * M_PI / Double(函数点阵密度) * Double($0) * 频率1 + 相位1)
}
let 频率2 = 1.0
let 相位2 = M_PI / 2.0
let 幅度2 = 2.0
let 正弦函数2 = (0..<函数点阵密度).map {
    幅度2 * sin(2.0 * M_PI / Double(函数点阵密度) * Double($0) * 频率2 + 相位2)
}
let 频率3 = 10.0
let 相位3 = M_PI / 3.0
let 幅度3 = 4.0
let 正弦函数3 = (0..<函数点阵密度).map {
    幅度3 * sin(2.0 * M_PI / Double(函数点阵密度) * Double($0) * 频率3 + 相位3)
}
let 新函数1 = add(正弦函数1, y: 正弦函数2)
let 新函数2 = add(新函数1, y: 正弦函数3)
// Xcode 分栏查看图形排布，尤其是新函数的图形
新函数1.forEach { XCPlaygroundPage.currentPage.captureValue($0, withIdentifier:"新函数1") }
新函数2.forEach { XCPlaygroundPage.currentPage.captureValue($0, withIdentifier:"新函数2") }
正弦函数2.forEach { XCPlaygroundPage.currentPage.captureValue($0, withIdentifier:"正弦函数2") }
正弦函数1.forEach { XCPlaygroundPage.currentPage.captureValue($0, withIdentifier:"正弦函数1") }

// 查看图像发现‘新函数2’左右有三对波峰，得出它由三个正弦波组成（可对应得出振幅、频率及相位）
let 快速傅里叶转换 = fft(新函数2)
快速傅里叶转换.forEach { XCPlaygroundPage.currentPage.captureValue($0, withIdentifier:"快速傅里叶转换") }

// 简单矩阵示例
// ⎛ 1  2 ⎞      ⎛ 3  2 ⎞       ⎛ 5  6 ⎞
// ⎢      ⎟  *   ⎢      ⎟   =   ⎢      ⎟
// ⎝ 3 -4 ⎠      ⎝ 1  2 ⎠       ⎝ 5 -2 ⎠
let A = Matrix([[1, 2], [3, -4]])
let B = Matrix([[3, 2], [1, 2]])
let C = A * B
// 利用逆矩阵求解
// ⎛ 1  1 ⎞        ⎛ 3 ⎞           ⎛ 2 ⎞
// ⎢      ⎟ * CC = ⎢   ⎟    CC =   ⎢   ⎟
// ⎝ 1 -1 ⎠        ⎝ 1 ⎠           ⎝ 1 ⎠
let AA = Matrix([[1, 1], [1, -1]])
let BB = Matrix([[3], [1]])
let CC = inv(AA) * BB

import Accelerate
public func sum(x: [Double]) -> Double {
    var result: Double = 0.0
    vDSP_sveD(x, 1, &result, vDSP_Length(x.count))
    return result
}
public func max(x: [Double]) -> Double {
    var result: Double = 0.0
    vDSP_maxvD(x, 1, &result, vDSP_Length(x.count))
    return result
}
public func mean(x: [Double]) -> Double {
    var result: Double = 0.0
    vDSP_meanvD(x, 1, &result, vDSP_Length(x.count))
    return result
}
public func add(x: [Double], y: [Double]) -> [Double] {
    var results = [Double](y)
    cblas_daxpy(Int32(x.count), 1.0, x, 1, &results, 1)
    return results
}
public func fft(input: [Double]) -> [Double] {
    var real = [Double](input)
    var imaginary = [Double](count: input.count, repeatedValue: 0.0)
    var splitComplex = DSPDoubleSplitComplex(realp: &real, imagp: &imaginary)
    let length = vDSP_Length(floor(log2(Float(input.count))))
    let radix = FFTRadix(kFFTRadix2)
    let weights = vDSP_create_fftsetupD(length, radix)
    vDSP_fft_zipD(weights, &splitComplex, 1, length, FFTDirection(FFT_FORWARD))
    var magnitudes = [Double](count: input.count, repeatedValue: 0.0)
    vDSP_zvmagsD(&splitComplex, 1, &magnitudes, 1, vDSP_Length(input.count))
    var normalizedMagnitudes = [Double](count: input.count, repeatedValue: 0.0)
    vDSP_vsmulD(sqrt(magnitudes), 1, [2.0 / Double(input.count)], &normalizedMagnitudes, 1, vDSP_Length(input.count))
    vDSP_destroy_fftsetupD(weights)
    return normalizedMagnitudes
}

/**
    It calculates and returns the outcome of the division of the two parameters.
    ## Important Notes ##
    1. Both parameters are **double** numbers.
    2. For a proper result the second parameter *must be other than 0*.
    3. If the second parameter is 0 then the function will return nil.
*/
func performDivision（number1: Double, number2: Double） -> Double! {
    if number2 != 0 {
        return number1 / number2
    }
    else {
        return nil
    }
}

/**
    Another complicated function.
    - Parameter fullname: The fullname that will be broken into its parts.
    - Returns: A *tuple* with the first and last name.
    - Remark:
        There's a counterpart function that concatenates the first and last name into a full name.
    - SeeAlso:  `createFullName（_:lastname:）`
    - Precondition: `fullname` should not be nil.
    - Requires: Both first and last name should be parts of the full name, separated with a *space character*.
    - Todo: Support middle name in the next version.
    - Warning: A wonderful **crash** will be the result of a `nil` argument.
    - Version: 1.1
    - Author: Myself Only
    - Note: Too much documentation for such a small function.
 */
func breakFullName（fullname: String) -> （firstname: String, lastname: String) {
    let fullnameInPieces = fullname.componentsSeparatedByString（" "）
    return （fullnameInPieces[0], fullnameInPieces[1]）
}

enum AnimationPeriod: UInt {
    // 动画执行的五个阶段
    case Start,First,Second,Third,End
    
    func description() -> String {
        switch self {
        case .Start, .First:    return "正在提取学校最新\n录取条件"
        case .Second:           return "正在与学校进行匹配"
        case .Third, .End:      return "正在根据匹配结果\n生成选校方案"
        }
    }
    
    func duration() -> NSTimeInterval {
        switch self {
        case .Start:    return 0.8
        case .First:    return 1
        case .Second:   return 2
        case .Third:    return 0.5
        case .End:      return 0.25
        }
    }
}
extension AnimationPeriod {
    mutating func next() {
        switch self {
        case .Start:    self = .First
        case .First:    self = .Second
        case .Second:   self = .Third
        case .Third:    self = .End
        default:        self = .End
        }
    }
}

enum FamilyType {
    
    case Father(age: Int)
    case Mother(age: Int)
    case Sister(age: Int)
    func gift() -> String {
        switch(self) {
        case .Sister(let age):
            if age > 15 {
                return "iphone"
            } else {
                return "toy"
            }
        case .Mother(let age) where age < 40:
            return "cloth"
        default:
            return "book"
        }
    }
}
let someone = FamilyType.Sister(age: 11)
let somebody = FamilyType.Mother(age: 40)
// swift的枚举技巧
let someoneGift = someone.gift()     // print toy
let somebodyGift = somebody.gift()	 // book

switch someone {
case .Father(let age):
    age
case .Sister(let age):
    age
default:()
}

if case .Sister(let age) = someone {
    age
}

enum Colleague {
    enum Weight: Int {
        case Light
        case Mid
        case Heavy
    }
    case iOS(weight: Weight)
    case Android(weight: Weight)
    case HTML(weight: Weight)
}
let woodenHelmet = Colleague.iOS(weight: .Mid)

// 根据自身赋值
enum Device {
    case iPad, iPhone
    var year: Int {
        switch self {
        case iPhone: return 2007
        case iPad: return 2010
        }
    }
}
// set get 方法对于枚举的成员变量是无效的，允许get调用但set不可执行
enum Book {
    case Story, News
    var year: Int {
        set{
            year = newValue
        }
        get{
            return self.year
        }
    }
}
let myIpad = Device.iPad
myIpad.year
var storyBook = Book.Story
//storyBook.year = 2010	 // set 方法此处报错
//storyBook.year			 // get 无效

enum AppleDevice {
    case iMac(price:Int)
    case iPod(price:Int)
    case iPhone(price:Int)
    init (costMoney: Int) {
        if costMoney > 10000 {
            self = .iMac(price: costMoney)
        } else if costMoney > 2500 {
            self = .iPhone(price: costMoney)
        } else {
            self = .iPod(price: costMoney)
        }
    }
}
let myDevice = AppleDevice(costMoney: 6000)

enum HumanHabit {
    case Reading
    case PlayGame
    case Traveling
}
typealias HumanInfo = (age: Int, name: String, habit: HumanHabit)
func selectRAM(humanInfo: HumanInfo) -> HumanInfo {return (age: 32, name: humanInfo.name, habit: humanInfo.habit)}
func selectCPU(humanInfo: HumanInfo) -> HumanInfo {return (age: humanInfo.age, name: "3.2GHZ", habit: humanInfo.habit)}
func selectGPU(humanInfo: HumanInfo) -> HumanInfo {return (age: humanInfo.age, name: "3.2GHZ", habit: .Reading)}
enum Desktop {
    case Cube(HumanInfo)
    case Tower(HumanInfo)
    case Rack(HumanInfo)
}
let aTower = Desktop.Tower(selectGPU(selectCPU(selectRAM((0, "", .Traveling) as HumanInfo))))

var name = "杨志"
name += "平"
// playground下预览
var graph = 0.0
for i in 0...100 {
    graph = sin(Double(i)/10.0)
    // playground下预览
}

let redView = UIView(frame:CGRectMake(0,0,100,100))
redView.backgroundColor = UIColor.redColor()
redView.layer.cornerRadius = 20
redView.layer.borderWidth = 3
redView.layer.borderColor = UIColor.whiteColor().CGColor
let circle = UIView(frame:CGRectMake(25,25,50,50))
circle.backgroundColor = UIColor.yellowColor()
circle.layer.cornerRadius = 80
redView.addSubview(circle)
// playground下预览

// 这个库需要import
import XCPlayground
let containerView = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 480))
containerView.backgroundColor = UIColor.yellowColor()
XCPlaygroundPage.currentPage.liveView = containerView
let view = UIView(frame: CGRect(x: 0, y: 0, width: 100, height: 100))
view.center = CGPoint(x: containerView.center.x, y: containerView.center.y-100)
view.backgroundColor = UIColor.redColor()
containerView.addSubview(view)
// playground下预览
UIView.animateWithDuration(3, delay: 0, usingSpringWithDamping: 0.1, initialSpringVelocity: 6, options: UIViewAnimationOptions.CurveEaseInOut, animations: {
        view.center.y += 100
    }, completion:{ (animation: Bool) in
        view.center.y -= 100
    }
)
// 异步操作：网络在家图片
// 旧接口：XCPSetExecutionShouldContinueIndefinitely(true)
XCPlaygroundPage.currentPage.needsIndefiniteExecution = true
let url = NSURL(string: "https://avatars1.githubusercontent.com/u/5317671?v=3&s=460")!
let task = NSURLSession.sharedSession().dataTaskWithURL(url) {
    data, _, _ in
    let image = UIImage(data: data!)
    // playground下预览
}
task.resume()
// 快速检查API接口
let url2 = NSURL(string: "http://www.test.51offer.com/mobile/abroad/query_school_by_name?name=%E4%B8%80")!
let task2 = NSURLSession.sharedSession().dataTaskWithURL(url2) {
    data, _, _ in
    let str = String(NSString(data: data!, encoding: NSUTF8StringEncoding))
    // playground下预览
}
task2.resume()

// 直接使用PicButton 这个class.
// 注意点：PicButton的类及初始化方法必须是public的
let btn = PicButton(frame: CGRectMake(0,0,200,100))
// playground下预览
// 如上述：在resources中放入jpg图片，加载本地资源
if let path = NSBundle.mainBundle().pathForResource("swift-playground", ofType: "jpg") {
    let image = UIImage(contentsOfFile:path)
    let imageView = UIImageView(image: image)
        // playground下预览
}

let normalFunc = {
    () -> Int in
    return 10086
}
let normalResult = normalFunc()
// normalResult = 10086

// 以数组排序函数为例：
var numberArr = [1,7,4,6,3,2,5]
let res1 = numberArr.sort()
let res2 = numberArr.sort {
    (num1: Int, num2: Int) -> Bool in
    return num1>num2
}
let res3 = numberArr.sort {
    (num1: Int, num2: Int) in
    return num1>num2
}
let res4 = numberArr.sort {
    (num1, num2) in
    return num1>num2
}
let res5 = numberArr.sort {
    return $0 > $1
}
let res6 = numberArr.sort {
    $0 > $1
}
let res7 = numberArr.sort(>)

func square(a:Float) -> Float {
    return a * a
}
func cube(a:Float) -> Float {
    return a * a * a
}
func averageSumOfSquares(a:Float,b:Float) -> Float {
    return (square(a) + square(b)) / 2.0
}
func averageSumOfCubes(a:Float,b:Float) -> Float {
    return (cube(a) + cube(b)) / 2.0
}
// 像Swift的Currying（柯里化），可以灵活调配使用
func averageOfFunction(a a:Float,b:Float,f:(Float -> Float)) -> Float {
    return (f(a) + f(b)) / 2
}
let squareResult1 = averageOfFunction(a: 2, b: 4, f: square)
let squareResult2 = averageOfFunction(a: 2, b: 4, f: {
                                                        (a: Float) -> Float in
                                                            return a * a
                                                     })
//{(x: Float) -> Float in return x * x}
//{x in return x * x}
//{x in x * x}
//{$0 * $0}
let squareResult3 = averageOfFunction(a: 2, b: 4, f: {$0 * $0})

// 正统高阶函数样式
func sum1(value: Int) -> (Int -> Int) {
    func adder(otherValue: Int) -> Int {
        return otherValue + value
    }
    return adder
}
// 省略后
func sum2(value: Int) -> (Int -> Int) {
    return { $0 + value }
}
let result1 = sum1(2)(3)
let result2 = sum2(5)(3)
// 改造函数完毕
func funcMathMethod1(first: Int -> Int, _/*起到变量匿名作用*/ second: Int -> Int) -> Int -> Int {
    return { second(first($0)) }
}
let f1 = funcMathMethod1({$0 + 2}, {$0 / 3})
f1(7)
let f2 = funcMathMethod1({$0 * $0}, {$0 / 4})
f2(10)
// Tip: 使用函数式编程，要是用得不好容易造成可读性很差，那优化如下
typealias MathFunc = Int -> Int
func funcMathMethod2(f: MathFunc, _ s: MathFunc) -> MathFunc {
    return { s(f($0)) }
}
let readability = funcMathMethod1({$0 + 2}, {$0 / 3})
readability(7)

// map
var numberArr = [1,7,4,6,3,2,5]
let mapArray = numberArr.map { (num: Int) -> String in
     return "第\(num)名"
}
let mapArray2 = numberArr.map({"第\($0)名"})
mapArray2
// 可选型随意解包 str 可以为 nil
let str: String? = "1234567890"
let mapStr = str.map({"第\($0)名"})
mapStr
// filter
let filArr = numberArr.filter { (num: Int) -> Bool in
    return num > 4
}
let filArr2 = numberArr.filter({ $0 > 4 })
filArr2
// reduce
let sum = numberArr.reduce(0) { (presum:Int, num:Int) -> Int in
    return presum + num
}
let sum2 = numberArr.reduce(10, combine: {$0 + $1})
sum2
let sumToStr = numberArr.reduce("") { (str: String, num: Int) -> String in
    str + String(num)
}
// 求一个数组中偶数的平方和（一口气使用swift提供的三个高阶函数）
//[1,2,3,4,5,6,7] -> [2,4,6] -> 4+16+36 = 56
let result = numberArr.filter({$0%2==0}).map({$0*$0}).reduce(0, combine: {$0+$1})
result // result = 56

// 面试题：用数组的 reduce 方法实现 map 的功能。
let arr = [1, 3, 2]
// map简易实现
let res = arr.map({$0*2})
// Array.reduce(<#T##initial: T##T#>, combine: <#T##(T, Int) throws -> T#>)
// 输出数据类型与初始化占位数据类型（initial）一致
let res2 = arr.reduce([]) {
    (a: [Int], element: Int) -> [Int] in
    var t = Array(a)
    t.append(element * 2)
    return t
}

// 面试题：用 reduce 方法一次求出数组中奇数的和、以及偶数乘积
// 使用元组，注意占位数据(0, 1)，第一联合数据a :(Int, Int)，函数输出数据(Int, Int) 三者类型一致
let arr2 = [1, 3, 2, 4]
let res3: (Int, Int) = arr2.reduce((0, 1)) {
    (a :(Int, Int), element: Int) -> (Int, Int) in
    if element % 2 == 0 {
        return (a.0, a.1 * element)
    } else {
        return (a.0 + element, a.1)
    }
}

// 原始方法 (强解包可能会出现问题)
func tranIntToString1(x: Int?) -> String {
    if x == nil || x! <= 0 {
  	    // 不符合值的要求时，写点代码
        return ""
    }
    // 使用x
    return x!.description
}
// 改进
func tranIntToString2(x: Int?) -> String {
    if let x = x where x>0 {
        return x.description
    }
    return ""
}
// 保镖模式
// 和上面写法对比
func tranIntToString3(x: Int?) -> String {
    guard let x = x where x > 0 else {
        return ""
    }
    // 变量不符合条件判断时，执行下面代码
    return x.description
}
// 非可选型
func tranIntToString4(x: Int) -> String {
    guard x > 0 else {
        return ""
    }
    return x.description
}
// 常常用于条件判断拦截
var view = UIView(frame: CGRectMake(0,0,80,80))
view.backgroundColor = UIColor.redColor()
UIView.animateWithDuration(0.3) { [weak view]() -> Void in
    guard let view = view where view.alpha>0 else {return}
    view.alpha = 0
}

//1.分析 NSArray 是一个闭包的返回值，而这是一个没有参数的闭包 
lazy var dataArray:NSArray = { [] }() 
//2.也可以写成这样 
lazy var dataArray:NSArray = { return NSArray() }()
//3.从plist文件加载 
lazy var dataArray:Array<XWWine> = {
    let winePath = NSBundle.mainBundle().pathForResource("wine.plist", ofType: nil)!
    let winesM = NSMutableArray(contentsOfFile: winePath);
    var tmpArray:Array<XWWine>! = []
    for tmpWineDict in winesM! {
        var wine:XWWine = XWWine.wineWithDict(tmpWineDict as! NSDictionary)
        tmpArray.append(wine)
    }
    //lazy闭包里就运行一次
    return tmpArray
}()

lazy private var underlineView: UIView = {
    let view = UIView(frame: .zero)
    return view
}()

/*
    defer 关键字
*/
postfix func ++(inout x: Int) -> Int {
    defer {
        x = x/2
        defer {
            x += 100
        }
    }
    return x
}
//
//postfix func ++(inout x: Int) -> Int {
//    let current = x
//    x += 2
//    return current
//}
var num = 100
let num2 = num++
num		//150
num2	//100
prefix func ++(inout x:Int) -> Int {
    x += 2
    return x
}
var number = 100
let number2 = ++number
number 		// 102
number2		// 102

public enum MenuScrollingMode {
    case ScrollEnabled
    case ScrollEnabledAndBouces
    case PagingEnabled
}
public enum MenuItemWidthMode {
    case Flexible
    case Fixed(width: CGFloat)
}
public enum MenuDisplayMode {
    case Standard(widthMode: MenuItemWidthMode, centerItem: Bool, scrollingMode: MenuScrollingMode)
    case SegmentedControl
    case Infinite(widthMode: MenuItemWidthMode)
}
// 初始化：用来携带信息很不错
public var menuDisplayMode = MenuDisplayMode.Standard(widthMode: PagingMenuOptions.MenuItemWidthMode.Fixed(width: 44), centerItem: false, scrollingMode: PagingMenuOptions.MenuScrollingMode.PagingEnabled)
// 实例
func labelWidth(size size: CGSize, widthMode: PagingMenuOptions.MenuItemWidthMode) -> CGFloat {
    switch widthMode {
    case .Flexible: return ceil(size.width)
    case let .Fixed(width): return width
    }
}