Popularity
2.0
Growing
Activity
0.0
Stable
65
4
10

Code Quality Rank: L5
Programming language: Swift
License: MIT License
Tags: Math    
Latest version: v4.2.0

Arithmosophi alternatives and similar libraries

Based on the "Math" category.
Alternatively, view Arithmosophi alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of Arithmosophi or a related project?

Add another 'Math' Library

README

Arithmosophi - Arithmosoϕ

Join the chat at https://gitter.im/phimage/Arithmosophi License Platform Language Issues Cocoapod Carthage compatible

Arithmosophi is a set of missing protocols that simplify arithmetic and statistics on generic objects or functions. As Equatable define the == operator , Addable will define the + operator.

protocol Addable {
    func + (lhs: Self, rhs: Self) -> Self
}
[1, 2, 3, 4].sum //  1 + 2 + 3 + 4
[0, 1, 2, 3, 4].average // 2
[13, 2.4, 3, 4].varianceSample
  • As you might guess Substractable define - operator, Multiplicatable define * operator, etc..., all defined in [Arithmosophi.swift](Sources/Arithmosophi.swift)

Contents

Generic functions

Take a look at sumOf function

func sumOf<T where T:Addable, T:Initializable>(input : [T]) -> T {
    return reduce(input, T()) {$0 + $1}
}

Array of Int, Double and even String could be passed as argument to this function. Any Addable objects.

No need to implement a function for Double, one for Float, one more for Int, etc...

sumOf and productOf functions are available in [Arithmosophi.swift](Arithmosophi.swift)

CollectionType

This framework contains some useful extensions on CollectionType

[1, 2, 3, 4].sum //  1 + 2 + 3 + 4
[1, 2, 3, 4].product //  1 * 2 * 3 * 4

["a","b","c","d"].sum // "abcd" same as joinWithSeparator("")
[["a","b"],["c"],["d"]].sum // ["a","b","c","d"] same as flatMap{$0}

Average

with [MesosOros.swift](Sources/MesosOros.swift)

Computes arithmetic average/mean

[1, 2, 3, 4].average //  (1 + 2 + 3 + 4) / 4

A type is Averagable if it can be dividable by an Int and define an operator to do that

func /(lhs: Self, rhs: Int) -> Self

All arithmetic type conform to this protocol and you can get an average for a CollectionType

P.S. You can conform to this protocol and Addable to make a custom average.

Median

with [MesosOros.swift](Sources/MesosOros.swift)

Get the median value from the array

  • Returns the average of the two middle values if there is an even number of elements in the CollectionType. swift [1, 11, 19, 4, -7].median // 4
  • Returns the lower of the two middle values if there is an even number of elements in the CollectionType. swift [1.0, 11, 19.5, 4, 12, -7].medianLow // 4
  • Returns the higher of the two middle values if there is an even number of elements in the CollectionType. swift [1, 11, 19, 4, 12, -7].medianHigh // 11

Variance

with [Sigma.swift](Sources/Sigma.swift)

Computes variance.

[1.0, 11, 19.5, 4, 12, -7].varianceSample
[1.0, 11, 19.5, 4, 12, -7].variancePopulation

Standard deviation

with [Sigma.swift](Sources/Sigma.swift)

Computes standard deviation.

  • sample based swift [1.0, 11, 19.5, 4, 12, -7].standardDeviationSample
  • population based swift [[1.0, 11, 19.5, 4, 12, -7].standardDeviationPopulation

Skewness

with [Sigma.swift](Sources/Sigma.swift)

Computes skewness.

[1.0, 11, 19.5, 4, 12, -7].skewness // or .moment.skewness

Kurtosis

with [Sigma.swift](Sources/Sigma.swift)

Computes kurtosis.

[1.0, 11, 19.5, 4, 12, -7].kurtosis // or .moment.kurtosis

Covariance

with [Sigma.swift](Sources/Sigma.swift)

Computes covariance with another CollectionType

Complex

with [Complex.swift](Sources/Complex.swift) Complex is a struct of two ArithmeticType, the real and the imaginary component

var complex = Complex(real: 12, imaginary: 9)
complex = 12 + 9.i

You can apply operation on it (+, -, *, /, ++, --, -)

result = complex + 8 // Complex(real: 20, imaginary: 9)

Complex(real: 12, imaginary: 9) + Complex(real: 8, imaginary: 1)
 // Complex(real: 20, imaginary: 10)

Object attributes

The power of this simple arithmetic protocols are released when using operators

If we implement a box object containing a generic T value

class Box<T> {
    var value: T
}

we can define some operators on it, in a generic way, like we can do with Equatable or Comparable

func +=<T where T:Addable> (inout box: Box<T>, addend: T) {
    box.value = box.value + addend
}
func -=<T where T:Substractable> (inout box: Box<T>, addend: T) {
    box.value = box.value - addend
}

how to use this operator:

var myInt: Box<Int>(5)
myInt += 37

For a full example, see Prephirence file from Prephirences framework, or sample [Box.swift](Samples/Box.swift)

Optional trick

For optional attribute you can use Initializable or any protocol which define a way to get a value

class Box<T> {
    var value: T?
}
func +=<T where T:Addable, T:Initializable> (inout box: Box<T>, addend: T) {
    box.value = (box.value ?? T()) + addend
}

Logical operations

[LogicalOperationsType](Sources/LogicalOperationsType.swift) is a missing protocol for Bool inspired from BitwiseOperationsType (or IntegerArithmeticType)

The purpose is the same, implement functions without knowing the base type

You can for instance implement your own [Boolean enum](Samples/Boolean.swift) and implement the protocol

enum Boolean: LogicalOperationsType {case True, False}
func && (left: Boolean, @autoclosure right:  () -> Boolean) -> Boolean {
    switch left {
    case .False: return .False
    case .True:  return right()
    }
}
...

then create only one operator on Box for Bool, Boolean and any LogicalOperationsType

func &&=<T:LogicalOperationsType> (inout box: Box<T>, @autoclosure right:  () -> TT) {
    box.value = box.value && right()
}

Take a look at a more complex enum [Optional](Samples/Optional.swift) which implement also LogicalOperationsType

Geometry

with Arithmos(number) & Statheros(constant)

[Arithmos](Sources/Arithmos.swift) and [Statheros](Sources/Statheros.swift) add respectively functions and mathematical constants for Double, Float and CGFloat, allowing to implement generic functions without taking care of type

func distance<T: Arithmos>(#x: T, y: T) -> T {
    return x.hypot(y)
}

func radiansFromDegrees<T where T: Multiplicable, Dividable, T: Arithmos, T: Statheros>(degrees: T) -> T {
    return degrees * T.PI / T(180.0)
}

Take a look at [Geometry.swift](Samples/Geometry.swift) for more examples

Setup

Using cocoapods

pod 'Arithmosophi'

Not interested in full framework ? install a subset with:

pod 'Arithmosophi/Core' # Arithmosophi.swift
pod 'Arithmosophi/Logical' # LogicalOperationsType.swift
pod 'Arithmosophi/Complex' # Complex.swift
pod 'Arithmosophi/MesosOros' # MesosOros.swift
pod 'Arithmosophi/Arithmos' # Arithmos.swift
pod 'Arithmosophi/Sigma' # Sigma.swift
pod 'Arithmosophi/Statheros' # Statheros.swift

pod 'Arithmosophi/Samples' # Samples/*.swift (not installed by default)

Add use_frameworks! to the end of the Podfile.

Make your own framework dependent

In podspec file

s.dependency 'Arithmosophi'

or define only wanted targets

s.dependency 'Arithmosophi/Core'
s.dependency 'Arithmosophi/Logical'

Using xcode

Drag files to your projects


*Note that all licence references and agreements mentioned in the Arithmosophi README section above are relevant to that project's source code only.