Funções matemáticas em Swift

Como faço para usar funções matemáticas, como sqrt(), floor(), round(), sin(), etc?

Ao fazer:

_ = floor(2.0)
_ = sqrt(2.0)

Eu recebo:

erro: uso do identificador não resolvido 'floor'
erro: uso do identificador não resolvido 'sqrt'

Como outro notado, você tem várias opções. Se você quiser apenas funções matemáticas. Você pode importar apenas Darwin.

import Darwin

Se você deseja funções matemáticas e outras classes e funções padrão. Você pode importar Foundation.

import Foundation

Se você quer tudo e também aulas para interface de usuário, depende se seu playground é para OS X ou iOS.

Para OS X, você precisa importar o Cocoa.

import Cocoa

Para iOS, você precisa importar o UIKit.

import UIKit

Você pode descobrir facilmente sua plataforma de playground abrindo o Inspetor de Arquivos (⌥⌘1).

Para ser perfeitamente preciso, Darwin é o suficiente. Não há necessidade de importar todo o framework Cocoa.

import Darwin

Claro, se você precisa de elementos Cocoa ou Foundation ou outros frameworks de nível superior, você pode importá-los

Para pessoas que usam swift [2.2] no Linux, ou seja, no Ubuntu, a importação é diferente!

A maneira correta de fazer isso é usando Glibc. Isso ocorre porque no OS X e no iOS, as APIs básicas do tipo Unix estão no Darwin, mas no Linux, elas estão localizadas no Glibc. O Importing Foundation não ajudará você aqui porque não faz a distinção por si só. Para fazer isso, você deve importá-lo explicitamente:

#if os(macOS) || os(iOS)
import Darwin
#elseif os(Linux) || CYGWIN
import Glibc
#endif

Você pode acompanhar o desenvolvimento da estrutura da Fundação aqui para saber mais

EDITAR: 26 de dezembro de 2018

Como apontado por @ Cœur , a partir do swift 3.0, algumas funções matemáticas agora fazem parte dos próprios tipos. Por exemplo, Double agora tem uma função squareRoot . Da mesma forma, ceil, floor, round, tudo pode ser conseguido com Double.rounded(FloatingPointRoundingRule) -> Double.

Além disso, acabei de baixar e instalar a última versão estável do swift no Ubuntu 18.04, e parece que o Foundationframework é tudo que você precisa importar para ter acesso às funções matemáticas agora. Tentei encontrar documentação para isso, mas não apareceu nada.

➜ swift          
Welcome to Swift version 4.2.1 (swift-4.2.1-RELEASE). Type :help for assistance.
  1> sqrt(9)
error: repl.swift:1:1: error: use of unresolved identifier 'sqrt'
sqrt(9)
^~~~


  1> import Foundation
  2> sqrt(9)
$R0: Double = 3
  3> floor(9.3)
$R1: Double = 9
  4> ceil(9.3) 
$R2: Double = 10

Você pode usá-los diretamente em linha:

var square = 9.4
var floored = floor(square)
var root = sqrt(floored)

println("Starting with \(square), we rounded down to \(floored), then took the square root to end up with \(root)")

Para usar as funções matemáticas, você deve import Cocoa

Você pode ver as outras funções matemáticas definidas da seguinte maneira. Faça um Cmd-Click no nome da função sqrte insira o arquivo com todas as outras funções matemáticas globais e constantes.

Um pequeno trecho do arquivo

...
func pow(_: CDouble, _: CDouble) -> CDouble

func sqrtf(_: CFloat) -> CFloat
func sqrt(_: CDouble) -> CDouble

func erff(_: CFloat) -> CFloat
...
var M_LN10: CDouble { get } /* loge(10)       */
var M_PI: CDouble { get } /* pi             */
var M_PI_2: CDouble { get } /* pi/2           */
var M_SQRT2: CDouble { get } /* sqrt(2)        */
...

Para a maneira Swift de fazer as coisas, você pode experimentar e usar as ferramentas disponíveis na Biblioteca Padrão do Swift. Eles devem funcionar em qualquer plataforma capaz de executar o Swift.

Em vez de floor(), round()e o resto das rotinas de arredondamento, você pode usar rounded(_:):

let x = 6.5

// Equivalent to the C 'round' function:
print(x.rounded(.toNearestOrAwayFromZero))
// Prints "7.0"

// Equivalent to the C 'trunc' function:
print(x.rounded(.towardZero))
// Prints "6.0"

// Equivalent to the C 'ceil' function:
print(x.rounded(.up))
// Prints "7.0"

// Equivalent to the C 'floor' function:
print(x.rounded(.down))
// Prints "6.0"

Eles estão disponíveis atualmente em Floate Doubledeve ser fácil o suficiente para converter para um, CGFloatpor exemplo.

Em vez disso, sqrt()há o squareRoot()método no protocolo FloatingPoint. Novamente, ambos Floate Doubleestão em conformidade com o FloatingPointprotocolo:

let x = 4.0
let y = x.squareRoot()

Para as funções trigonométricas, a biblioteca padrão não pode ajudar, então é melhor importar Darwin nas plataformas Apple ou Glibc no Linux. Dedos cruzados, eles serão uma maneira mais organizada no futuro.

#if os(OSX) || os(iOS)
import Darwin
#elseif os(Linux)
import Glibc
#endif

let x = 1.571
print(sin(x))
// Prints "~1.0"