Gradient with CGGradient, Swift 3

func setupGradientBackground() {
        
        let firstColor = UIColor.black.withAlphaComponent(0.6)
        let secondColor = UIColor.black.withAlphaComponent(0.0)
        
        let gradient = CGGradient.with(easing: Cubic.EaseIn, between: firstColor, and: secondColor)
        var updatedSize = self.navigationBar.bounds.size
        updatedSize.height += 20
        
        UIGraphicsBeginImageContextWithOptions(updatedSize, false, 0);
        guard let context = UIGraphicsGetCurrentContext() else {
            return
        }
        
        context.drawLinearGradient(gradient, start: CGPoint.zero, end: CGPoint(x: 0, y: updatedSize.height), options: CGGradientDrawingOptions())
        let image = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        
        self.navigationBar.setBackgroundImage(image, for: UIBarMetrics.default)
    }
    
// Gradients

typealias Easing        = (_ t:CGFloat,_ b:CGFloat,_ c:CGFloat,_ d:CGFloat)-> CGFloat

struct Cubic{
    static var EaseIn :Easing    = { (_t,b,c,d) -> CGFloat in
        let t = _t/d
        return c*t*t*t + b
    }
    
    static var EaseOut :Easing   = { (_t,b,c,d) -> CGFloat in
        let t = _t/d-1
        return c*(t*t*t + 1) + b
    }
    
    static var EaseInOut :Easing = { (_t,b,c,d) -> CGFloat in
        var t = _t/(d/2)
        if t < 1{
            return c/2*t*t*t + b;
        }
        t -= 2
        return c/2*(t*t*t + 2) + b;
    }
}

struct Quad{
    static var EaseIn :Easing    = { (_t,b,c,d) -> CGFloat in
        let t = _t/d
        return c*t*t + b
    }
    
    static var EaseOut :Easing   = { (_t,b,c,d) -> CGFloat in
        let t = _t/d
        return -c * t*(t-2) + b
    }
    
    static var EaseInOut :Easing = { (_t,b,c,d) -> CGFloat in
        var t = _t/(d/2)
        if t < 1{
            return c/2*t*t + b;
        }
        let t1 = t-1
        let t2 = t1-2
        return -c/2 * ((t1)*(t2) - 1) + b;
    }
}

extension CGGradient {
    
    class func with(_ colors:[UIColor],_ locations:[CGFloat]) -> CGGradient{
        return CGGradient(colorsSpace: CGColorSpaceCreateDeviceRGB(), colors: colors.map{$0.cgColor} as CFArray, locations: locations)!
    }
    
    private class func with(_ colors:[CGColor],_ locations:[CGFloat]) -> CGGradient{
        return CGGradient(colorsSpace: CGColorSpaceCreateDeviceRGB(), colors: colors as CFArray, locations: locations)!
    }
    
    class func with(easing:Easing, between:UIColor, and:UIColor) -> CGGradient{
        var colors    = [CGColor]()
        var locations = [CGFloat]()
        let samples = 24
        
        func interpolateColor(at percent:CGFloat) -> CGColor{
            var r1:CGFloat = 0.0,g1:CGFloat = 0.0,b1:CGFloat = 0.0, a1:CGFloat = 0.0
            var r2:CGFloat = 0.0,g2:CGFloat = 0.0,b2:CGFloat = 0.0, a2:CGFloat = 0.0
            
            if 4 == between.cgColor.components?.count{
                between.getRed(&r1, green: &g1, blue: &b1, alpha: &a1)
            }else{
                between.getWhite(&r1, alpha: &a1)
                b1 = r1; g1 = r1
            }
            
            if 4 == and.cgColor.components?.count{
                and.getRed(&r2, green: &g2, blue: &b2, alpha: &a2)
            }else{
                and.getWhite(&r2, alpha: &a2)
                b2 = r2; g2 = r2
            }
            
            let r = BezierCurve(t: percent, p0: r1, p1: r2)
            let g = BezierCurve(t: percent, p0: g1, p1: g2)
            let b = BezierCurve(t: percent, p0: b1, p1: b2)
            let a = BezierCurve(t: percent, p0: a1, p1: a2)
            
            return UIColor(red: r, green: g, blue: b, alpha: a).cgColor
        }
        
        
        for i in 0...24{
            let tt = CGFloat(i)/CGFloat(samples)
            
            // calculate t based on easing function provided
            let t = easing(tt, 0.0, 1, 1)
            
            locations.append(tt)
            colors.append(interpolateColor(at: t))
        }
        return with(colors, locations)
    }
}

func LinearBezierCurveFactors(t:CGFloat) -> (CGFloat,CGFloat){
    return ((1-t),t)
}

// Linear Bezier Curve, Just a Parameterized Line Equation
func BezierCurve(t:CGFloat,p0:CGFloat,p1:CGFloat) -> CGFloat{
    let factors = LinearBezierCurveFactors(t: t)
    return (factors.0*p0) + (factors.1*p1)
}