MathEagle is named after the golden eagle, since this is the fastest bird in the world

Last update: Jul 9, 2022

Overview

Swift-MathEagle

MathEagle is named after the golden eagle, since this is the fastest bird in the world (in horizontal flight).

This project is meant to make math easy in swift without losing performance. The syntax is designed to be as simple as possible. Contributors are always welcome, the more the merrier!

Warning!

MathEagle is still in its initial development phase so the syntax still changes frequently.

Installation

The fastest way to add MathEagle to your project is to download it as a zip file and drag all files in the MathEagle/Source folder to your project. Make sure to add them to your target. For Mac applications you can use the generated framework, check the wiki for more information. I'm currently working on an iOS framework.

MathEagle requires gmp (GNU multiple precision arithmetic library) be installed. Install gmp via brew install gmp assuming you have Homebrew installed.

Supported Xcode Versions

MathEagle is fully compatible with:

Xcode 9 and Swift 4

Currently Supported

Basic extensions, operators like power (** operator) and functions like sign and factorial
Prime functions
Complex numbers
Single variable function root solving
Single variable function optimization
Matrix and Vector math
Basic graph algorithms

MathEagle is fully generic, so almost all classes and functions work with any type (even types you define). MathEagle vectors for example can also be of type Int, while the Float and Double type vectors use Accelerate in the background for speed.

Take a look at the Wiki for documentation.

Advantages

The biggest advantage of MathEagle is that it's totally generic. You can create matrices and vectors and use functions like isPrime with all numeric types. You can even create your own type (let's say Quaternion), implement the protocols and everything just works. Of course specific implementations are overloaded to maintain performance. Vector addition for Float vectors for example is overloaded to use the Accelerate framework.

Benchmarking

First benchmarking tests show that MathEagle is as fast as Python's famous numpy. You can check the "Benchmarking Files" folder in MathEagle's tests. (These tests were conducted on an early 2013 15-inch Retina Macbook Pro with a 2.7 GHz Intel Core i7 and 16 GB of RAM.

Here are some plots for Vector addition: ![Vector Addition Float Benchmarking](/MathEagleTests/Benchmarking Files/Plot Images/VectorAdditionFloat.png) ![Vector Addition Double Benchmarking](/MathEagleTests/Benchmarking Files/Plot Images/VectorAdditionDouble.png)

To Do

Documentation
Further General Development
Incorporate Accelerate for all applications

Comments

[Suggestion] Generic approach to Solver

I was trying to use the Solver.newton methods and found that it wasn't generic to handle Double, Float, CGFloat etc. I ended up implementing it this way. Do you think it would be worthwhile to update the code as illustrated?

opened by BenziAhamed 4
Kellyroach/upgrade to xcode941
This pull request upgrades Swift-MathEagle to Xcode 9.4.1 / Swift 4.2 .

Upgrade to Xcode 9.4.1 / Swift 4.2

Improved quadrant, Complex **, BigFloat stringValue, PermutationMatrix row, isPrime

Improved Random.swift

Added 149 new tests for improved test coverage
opened by kellyroach 3

Make numberOfDigits function

This function could use something like this, but then Swifty:

n = 1;
if (i >= 100000000){i /= 100000000; n += 8;}
if (i >= 10000){i /= 10000; n += 4;}
if (i >= 100){i /= 100; n += 2;}
if (i >= 10){i /= 10; n += 1;}

opened by rugheid 0

Add more optimization routines
The only optimization procedure currently implemented is the golden section method. Optimization of functions with more than one variable (most notable Rosenbrock's function) is impossible without other methods.

Some initial suggestions:

nelder-mead

BFGS

For a well-written, high-level, fast and clear example of those (and other) routines, I highly recommend checking out Optim.jl.
opened by anthonyclays 0
Make Complex generic

As the readme states:

The biggest advantage about MathEagle is that it's totally generic. :wink:

Making Complex generic over any real number would be great (especially when you get around to adding arbitrary precision numerics)

opened by anthonyclays 0
Add more benchmarks
Current benchmarks are not entirely representative of the performance, as simple vectorized computations are easily compiled to near-perfect machine code.

Some benchmark suggestions:

Linear algebra routines (SVD, matrix inverse, eigenvalues...)

Number theory functions (primality tests, integer factorization...)

Optimization (test using rosenbrock function, count the number of objective function calls)
opened by anthonyclays 1

Owner

Rugen Heidbuchel

GitHub

A "time ago", "time since", "relative date", or "fuzzy date" category for NSDate and iOS, Objective-C, Cocoa Touch, iPhone, iPad

Migration 2014.04.12 NSDate+TimeAgo has merged with DateTools. DateTools is the parent project and Matthew York is the project head. This project is n