autodiff Wiki Rss Feed

Updated Wiki: Home

alexshtf — Wed, 19 Jun 2013 22:08:08 GMT

Project Description
A library that provides fast, accurate and automatic differentiation (computes derivative / gradient) of mathematical functions.

Getting AutoDiff
Using NuGet:

Using in research papers
If you like the library and it helps you publish a research paper, please cite the paper I originally wrote the library for geosemantic.bib

What is it for?
AutoDiff provides a simple and intuitive API for computing function gradients/derivatives along with a fast state-of-the-art algorithm for performing the computation. Such computations are mainly useful in numeric optimization scenarios.

Code example

using AutoDiff;

class Program
{
    public static void Main(string[] args)
    {
            // define variables
            var x = new Variable();
            var y = new Variable();
            var z = new Variable();

            // define our function
            var func = (x + y) * TermBuilder.Exp(z + x * y);

            // prepare arrays needed for evaluation/differentiation
            Variable[] vars = { x, y, z };
            double[] values = {1, 2, -3 };

            // evaluate func at (1, 2, -3)
            double value = func.Evaluate(vars, values);

            // calculate the gradient at (1, 2, -3)
            double[] gradient = func.Differentiate(vars, values);

            // print results
            Console.WriteLine("The value at (1, 2, -3) is " + value);
            Console.WriteLine("The gradient at (1, 2, -3) is ({0}, {1}, {2})", gradient[0], gradient[1], gradient[2]);
    }
}

Documentation
In the Documentation tab right now we have some basic tutorials, and some others are under construction. We also have an article on CodeProject. In addition, the binary distribution contains XML comments for all public methods and a help file you can view with your favorite help viewer. And finally, the source control contains some code examples in addition to the library's code.

Motivation
There are many open and commercial .NET libraries that have numeric optimization as one of their features (for example, Microsoft Solver Foundation, AlgLib, Microsoft Research SHO Extreme Optimization, CenterSpace NMath) . Most of them require the user to be able to evaluate the function and the function's gradient. This library tries to save the work in manually developing the function's gradient and coding it.
Once the developer defines his/her function, the AutoDiff library can automatically evaluate and differentiate this function at any point. This allows easy development and prototyping of applications based on numeric optimization.

Features

Fast! See 0.5 vs 0.3 benchmark and 0.3 benchmark.
Composition of functions using arithmetic operators, Exp, Log, Power and user-defined unary and binary functions.
Function gradient evaluation at specified points
Function value evaluation at specified points
Uses Code Contracts for specifying valid parameters and return values
Computes gradients using Reverse-Mode AD algorithm in linear time!
- Yes, it's faster than numeric approximation for multivariate functions
- You get both high accuracy and speed!

Used by

Alex Shtof, Alexander Agathos, Yotam Gingold, Ariel Shamir, Daniel Cohen-Or Geosemantic Snapping for Sketch-Based Modeling Eurographics 2013 proceedings
Hendrik Skubch, Solving non-linear arithmetic constraints in soft realtime environments Proceedings of the 27th Annual ACM Symposium on Applied Computing
AlicaEngine - A cooperative planning engine for robotics. You can see it in action in this video
HeuristicsLab - a framework for heuristic and evolutionary algorithms that is developed by members of the Heuristic and Evolutionary Algorithms Laboratory (HEAL)

Updated Wiki: Home

alexshtf — Sat, 11 May 2013 06:24:00 GMT

Project Description
A library that provides fast, accurate and automatic differentiation (computes derivative / gradient) of mathematical functions.

Getting AutoDiff
Using NuGet:

What is it for?
AutoDiff provides a simple and intuitive API for computing function gradients/derivatives along with a fast state-of-the-art algorithm for performing the computation. Such computations are mainly useful in numeric optimization scenarios.

Code example

using AutoDiff;

class Program
{
    public static void Main(string[] args)
    {
            // define variables
            var x = new Variable();
            var y = new Variable();
            var z = new Variable();

            // define our function
            var func = (x + y) * TermBuilder.Exp(z + x * y);

            // prepare arrays needed for evaluation/differentiation
            Variable[] vars = { x, y, z };
            double[] values = {1, 2, -3 };

            // evaluate func at (1, 2, -3)
            double value = func.Evaluate(vars, values);

            // calculate the gradient at (1, 2, -3)
            double[] gradient = func.Differentiate(vars, values);

            // print results
            Console.WriteLine("The value at (1, 2, -3) is " + value);
            Console.WriteLine("The gradient at (1, 2, -3) is ({0}, {1}, {2})", gradient[0], gradient[1], gradient[2]);
    }
}

Fast! See 0.5 vs 0.3 benchmark and 0.3 benchmark.
Composition of functions using arithmetic operators, Exp, Log, Power and user-defined unary and binary functions.
Function gradient evaluation at specified points
Function value evaluation at specified points
Uses Code Contracts for specifying valid parameters and return values
Computes gradients using Reverse-Mode AD algorithm in linear time!
- Yes, it's faster than numeric approximation for multivariate functions
- You get both high accuracy and speed!

Used by

Alex Shtof, Alexander Agathos, Yotam Gingold, Ariel Shamir, Daniel Cohen-Or Geosemantic Snapping for Sketch-Based Modeling Eurographics 2013 proceedings
Hendrik Skubch, Solving non-linear arithmetic constraints in soft realtime environments Proceedings of the 27th Annual ACM Symposium on Applied Computing
AlicaEngine - A cooperative planning engine for robotics. You can see it in action in this video
HeuristicsLab - a framework for heuristic and evolutionary algorithms that is developed by members of the Heuristic and Evolutionary Algorithms Laboratory (HEAL)

Updated Wiki: Home

alexshtf — Mon, 04 Feb 2013 09:49:28 GMT

Project Description
A library that provides fast, accurate and automatic differentiation (computes derivative / gradient) of mathematical functions.

Getting AutoDiff
Using NuGet:

What is it for?
AutoDiff provides a simple and intuitive API for computing function gradients/derivatives along with a fast state-of-the-art algorithm for performing the computation. Such computations are mainly useful in numeric optimization scenarios.

Code example

using AutoDiff;

class Program
{
    public static void Main(string[] args)
    {
            // define variables
            var x = new Variable();
            var y = new Variable();
            var z = new Variable();

            // define our function
            var func = (x + y) * TermBuilder.Exp(z + x * y);

            // prepare arrays needed for evaluation/differentiation
            Variable[] vars = { x, y, z };
            double[] values = {1, 2, -3 };

            // evaluate func at (1, 2, -3)
            double value = func.Evaluate(vars, values);

            // calculate the gradient at (1, 2, -3)
            double[] gradient = func.Differentiate(vars, values);

            // print results
            Console.WriteLine("The value at (1, 2, -3) is " + value);
            Console.WriteLine("The gradient at (1, 2, -3) is ({0}, {1}, {2})", gradient[0], gradient[1], gradient[2]);
    }
}

Fast! See 0.5 vs 0.3 benchmark and 0.3 benchmark.
Composition of functions using arithmetic operators, Exp, Log, Power and user-defined unary and binary functions.
Function gradient evaluation at specified points
Function value evaluation at specified points
Uses Code Contracts for specifying valid parameters and return values
Computes gradients using Reverse-Mode AD algorithm in linear time!
- Yes, it's faster than numeric approximation for multivariate functions
- You get both high accuracy and speed!

Used by

Alex Shtof, Alexander Agathos, Yotam Gingold, Ariel Shamir, Daniel Cohen-Or Geosemantic Snapping for Sketch-Based Modeling Proceedings of Eurographics 2013
Hendrik Skubch, Solving non-linear arithmetic constraints in soft realtime environments Proceedings of the 27th Annual ACM Symposium on Applied Computing
AlicaEngine - A cooperative planning engine for robotics. You can see it in action in this video
HeuristicsLab - a framework for heuristic and evolutionary algorithms that is developed by members of the Heuristic and Evolutionary Algorithms Laboratory (HEAL)

Updated Wiki: Home

alexshtf — Mon, 04 Feb 2013 09:48:38 GMT

Project Description
A library that provides fast, accurate and automatic differentiation (computes derivative / gradient) of mathematical functions.

Getting AutoDiff
Using NuGet:

What is it for?
AutoDiff provides a simple and intuitive API for computing function gradients/derivatives along with a fast state-of-the-art algorithm for performing the computation. Such computations are mainly useful in numeric optimization scenarios.

Code example

using AutoDiff;

class Program
{
    public static void Main(string[] args)
    {
            // define variables
            var x = new Variable();
            var y = new Variable();
            var z = new Variable();

            // define our function
            var func = (x + y) * TermBuilder.Exp(z + x * y);

            // prepare arrays needed for evaluation/differentiation
            Variable[] vars = { x, y, z };
            double[] values = {1, 2, -3 };

            // evaluate func at (1, 2, -3)
            double value = func.Evaluate(vars, values);

            // calculate the gradient at (1, 2, -3)
            double[] gradient = func.Differentiate(vars, values);

            // print results
            Console.WriteLine("The value at (1, 2, -3) is " + value);
            Console.WriteLine("The gradient at (1, 2, -3) is ({0}, {1}, {2})", gradient[0], gradient[1], gradient[2]);
    }
}

Fast! See 0.5 vs 0.3 benchmark and 0.3 benchmark.
Composition of functions using arithmetic operators, Exp, Log, Power and user-defined unary and binary functions.
Function gradient evaluation at specified points
Function value evaluation at specified points
Uses Code Contracts for specifying valid parameters and return values
Computes gradients using Reverse-Mode AD algorithm in linear time!
- Yes, it's faster than numeric approximation for multivariate functions
- You get both high accuracy and speed!

Users

Alex Shtof, Alexander Agathos, Yotam Gingold, Ariel Shamir, Daniel Cohen-Or Geosemantic Snapping for Sketch-Based Modeling Proceedings of Eurographics 2013
Hendrik Skubch, Solving non-linear arithmetic constraints in soft realtime environments Proceedings of the 27th Annual ACM Symposium on Applied Computing
AlicaEngine - A cooperative planning engine for robotics. You can see it in action in this video
HeuristicsLab - a framework for heuristic and evolutionary algorithms that is developed by members of the Heuristic and Evolutionary Algorithms Laboratory (HEAL)

Updated Wiki: Home

alexshtf — Mon, 26 Nov 2012 11:11:29 GMT

Project Description
A library that provides fast, accurate and automatic differentiation (computes derivative / gradient) of mathematical functions.

Getting AutoDiff
Using NuGet:

What is it for?
AutoDiff provides a simple and intuitive API for computing function gradients/derivatives along with a fast state-of-the-art algorithm for performing the computation. Such computations are mainly useful in numeric optimization scenarios.

Code example

using AutoDiff;

class Program
{
    public static void Main(string[] args)
    {
            // define variables
            var x = new Variable();
            var y = new Variable();
            var z = new Variable();

            // define our function
            var func = (x + y) * TermBuilder.Exp(z + x * y);

            // prepare arrays needed for evaluation/differentiation
            Variable[] vars = { x, y, z };
            double[] values = {1, 2, -3 };

            // evaluate func at (1, 2, -3)
            double value = func.Evaluate(vars, values);

            // calculate the gradient at (1, 2, -3)
            double[] gradient = func.Differentiate(vars, values);

            // print results
            Console.WriteLine("The value at (1, 2, -3) is " + value);
            Console.WriteLine("The gradient at (1, 2, -3) is ({0}, {1}, {2})", gradient[0], gradient[1], gradient[2]);
    }
}

Fast! See 0.5 vs 0.3 benchmark and 0.3 benchmark.
Composition of functions using arithmetic operators, Exp, Log, Power and user-defined unary and binary functions.
Function gradient evaluation at specified points
Function value evaluation at specified points
Uses Code Contracts for specifying valid parameters and return values
Computes gradients using Reverse-Mode AD algorithm in linear time!
- Yes, it's faster than numeric approximation for multivariate functions
- You get both high accuracy and speed!

Users

Hendrik Skubch, Solving non-linear arithmetic constraints in soft realtime environments Proceedings of the 27th Annual ACM Symposium on Applied Computing
AlicaEngine - A cooperative planning engine for robotics. You can see it in action in this video
HeuristicsLab - a framework for heuristic and evolutionary algorithms that is developed by members of the Heuristic and Evolutionary Algorithms Laboratory (HEAL)

Updated Wiki: Home

alexshtf — Fri, 23 Nov 2012 20:08:13 GMT

Project Description
A library that provides fast, accurate and automatic differentiation (computes derivative / gradient) of mathematical functions.

Getting AutoDiff
Using NuGet:

What is it for?
AutoDiff provides a simple and intuitive API for computing function gradients/derivatives along with a fast state-of-the-art algorithm for performing the computation. Such computations are mainly useful in numeric optimization scenarios.

Code example

using AutoDiff;

class Program
{
    public static void Main(string[] args)
    {
            // define variables
            var x = new Variable();
            var y = new Variable();
            var z = new Variable();

            // define our function
            var func = (x + y) * TermBuilder.Exp(z + x * y);

            // prepare arrays needed for evaluation/differentiation
            Variable[] vars = { x, y, z };
            double[] values = {1, 2, -3 };

            // evaluate func at (1, 2, -3)
            double value = func.Evaluate(vars, values);

            // calculate the gradient at (1, 2, -3)
            double[] gradient = func.Differentiate(vars, values);

            // print results
            Console.WriteLine("The value at (1, 2, -3) is " + value);
            Console.WriteLine("The gradient at (1, 2, -3) is ({0}, {1}, {2})", gradient[0], gradient[1], gradient[2]);
    }
}

Fast! See 0.5 vs 0.3 benchmark and 0.3 benchmark.
Composition of functions using arithmetic operators, Exp, Log, Power and user-defined unary and binary functions.
Function gradient evaluation at specified points
Function value evaluation at specified points
Uses Code Contracts for specifying valid parameters and return values
Computes gradients using Reverse-Mode AD algorithm in linear time!
- Yes, it's faster than numeric approximation for multivariate functions
- You get both high accuracy and speed!

Users

Hendrik Skubch, Solving non-linear arithmetic constraints in soft realtime environments Proceedings of the 27th Annual ACM Symposium on Applied Computing
AlicaEngine - A cooperative planning engine for robotics. You can see it in action in this video

Updated Wiki: Home

alexshtf — Fri, 23 Nov 2012 10:26:40 GMT

Project Description
A library that provides fast, accurate and automatic differentiation (computes derivative / gradient) of mathematical functions.

Getting AutoDiff
Using NuGet:

What is it for?
AutoDiff provides a simple and intuitive API for computing function gradients/derivatives along with a fast state-of-the-art algorithm for performing the computation. Such computations are mainly useful in numeric optimization scenarios.

Code example

using AutoDiff;

class Program
{
    public static void Main(string[] args)
    {
            // define variables
            var x = new Variable();
            var y = new Variable();
            var z = new Variable();

            // define our function
            var func = (x + y) * TermBuilder.Exp(z + x * y);

            // prepare arrays needed for evaluation/differentiation
            Variable[] vars = { x, y, z };
            double[] values = {1, 2, -3 };

            // evaluate func at (1, 2, -3)
            double value = func.Evaluate(vars, values);

            // calculate the gradient at (1, 2, -3)
            double[] gradient = func.Differentiate(vars, values);

            // print results
            Console.WriteLine("The value at (1, 2, -3) is " + value);
            Console.WriteLine("The gradient at (1, 2, -3) is ({0}, {1}, {2})", gradient[0], gradient[1], gradient[2]);
    }
}

Fast! See 0.5 vs 0.3 benchmark and 0.3 benchmark.
Composition of functions using arithmetic operators, Exp, Log, Power and user-defined unary and binary functions.
Function gradient evaluation at specified points
Function value evaluation at specified points
Uses Code Contracts for specifying valid parameters and return values
Computes gradients using Reverse-Mode AD algorithm in linear time!
- Yes, it's faster than numeric approximation for multivariate functions
- You get both high accuracy and speed!

Users

Solving non-linear arithmetic constraints in soft realtime environments Proceedings of the 27th Annual ACM Symposium on Applied Computing

Updated Wiki: Home

alexshtf — Fri, 23 Nov 2012 09:40:50 GMT

Project Description
A library that provides fast, accurate and automatic differentiation (computes derivative / gradient) of mathematical functions.

Getting AutoDiff
Using NuGet:

What is it for?
AutoDiff provides a simple and intuitive API for computing function gradients/derivatives along with a fast state-of-the-art algorithm for performing the computation. Such computations are mainly useful in numeric optimization scenarios.

Code example

using AutoDiff;

class Program
{
    public static void Main(string[] args)
    {
            // define variables
            var x = new Variable();
            var y = new Variable();
            var z = new Variable();

            // define our function
            var func = (x + y) * TermBuilder.Exp(z + x * y);

            // prepare arrays needed for evaluation/differentiation
            Variable[] vars = { x, y, z };
            double[] values = {1, 2, -3 };

            // evaluate func at (1, 2, -3)
            double value = func.Evaluate(vars, values);

            // calculate the gradient at (1, 2, -3)
            double[] gradient = func.Differentiate(vars, values);

            // print results
            Console.WriteLine("The value at (1, 2, -3) is " + value);
            Console.WriteLine("The gradient at (1, 2, -3) is ({0}, {1}, {2})", gradient[0], gradient[1], gradient[2]);
    }
}

Users

Solving non-linear arithmetic constraints in soft realtime environments Proceedings of the 27th Annual ACM Symposium on Applied Computing

Fast! See 0.5 vs 0.3 benchmark and 0.3 benchmark.
Composition of functions using arithmetic operators, Exp, Log, Power and user-defined unary and binary functions.
Function gradient evaluation at specified points
Function value evaluation at specified points
Uses Code Contracts for specifying valid parameters and return values
Computes gradients using Reverse-Mode AD algorithm in linear time!
- Yes, it's faster than numeric approximation for multivariate functions
- You get both high accuracy and speed!

Updated Wiki: Home

alexshtf — Fri, 23 Nov 2012 09:34:49 GMT

Project Description
A library that provides fast, accurate and automatic differentiation (computes derivative / gradient) of mathematical functions.

Getting AutoDiff
Using NuGet:

What is it for?
AutoDiff provides a simple and intuitive API for computing function gradients/derivatives along with a fast state-of-the-art algorithm for performing the computation. Such computations are mainly useful in numeric optimization scenarios.

Code example

using AutoDiff;

class Program
{
    public static void Main(string[] args)
    {
            // define variables
            var x = new Variable();
            var y = new Variable();
            var z = new Variable();

            // define our function
            var func = (x + y) * TermBuilder.Exp(z + x * y);

            // prepare arrays needed for evaluation/differentiation
            Variable[] vars = { x, y, z };
            double[] values = {1, 2, -3 };

            // evaluate func at (1, 2, -3)
            double value = func.Evaluate(vars, values);

            // calculate the gradient at (1, 2, -3)
            double[] gradient = func.Differentiate(vars, values);

            // print results
            Console.WriteLine("The value at (1, 2, -3) is " + value);
            Console.WriteLine("The gradient at (1, 2, -3) is ({0}, {1}, {2})", gradient[0], gradient[1], gradient[2]);
    }
}

Users

Academic research
- Solving non-linear arithmetic constraints in soft realtime environments

Fast! See 0.5 vs 0.3 benchmark and 0.3 benchmark.
Composition of functions using arithmetic operators, Exp, Log, Power and user-defined unary and binary functions.
Function gradient evaluation at specified points
Function value evaluation at specified points
Uses Code Contracts for specifying valid parameters and return values
Computes gradients using Reverse-Mode AD algorithm in linear time!
- Yes, it's faster than numeric approximation for multivariate functions
- You get both high accuracy and speed!

Updated Wiki: Home

alexshtf — Sat, 08 Sep 2012 15:46:13 GMT

Project Description
High-performance and high-accuracy automatic function-differentiation library suitable for optimization and numeric computing.

Getting AutoDiff
Using NuGet:

What is it for?
AutoDiff provides a simple and intuitive API for computing function gradients/derivatives along with a fast state-of-the-art algorithm for performing the computation. Such computations are mainly useful in numeric optimization scenarios.

Code example

using AutoDiff;

class Program
{
    public static void Main(string[] args)
    {
            // define variables
            var x = new Variable();
            var y = new Variable();
            var z = new Variable();

            // define our function
            var func = (x + y) * TermBuilder.Exp(z + x * y);

            // prepare arrays needed for evaluation/differentiation
            Variable[] vars = { x, y, z };
            double[] values = {1, 2, -3 };

            // evaluate func at (1, 2, -3)
            double value = func.Evaluate(vars, values);

            // calculate the gradient at (1, 2, -3)
            double[] gradient = func.Differentiate(vars, values);

            // print results
            Console.WriteLine("The value at (1, 2, -3) is " + value);
            Console.WriteLine("The gradient at (1, 2, -3) is ({0}, {1}, {2})", gradient[0], gradient[1], gradient[2]);
    }
}

Fast! See 0.5 vs 0.3 benchmark and 0.3 benchmark.
Composition of functions using arithmetic operators, Exp, Log, Power and user-defined unary and binary functions.
Function gradient evaluation at specified points
Function value evaluation at specified points
Uses Code Contracts for specifying valid parameters and return values
Computes gradients using Reverse-Mode AD algorithm in linear time!
- Yes, it's faster than numeric approximation for multivariate functions
- You get both high accuracy and speed!

Updated Wiki: Home

alexshtf — Sat, 08 Sep 2012 15:46:00 GMT

Project Description
High-performance and high-accuracy automatic function-differentiation library suitable for optimization and numeric computing.

Getting AutoDiff

What is it for?
AutoDiff provides a simple and intuitive API for computing function gradients/derivatives along with a fast state-of-the-art algorithm for performing the computation. Such computations are mainly useful in numeric optimization scenarios.

Code example

using AutoDiff;

class Program
{
    public static void Main(string[] args)
    {
            // define variables
            var x = new Variable();
            var y = new Variable();
            var z = new Variable();

            // define our function
            var func = (x + y) * TermBuilder.Exp(z + x * y);

            // prepare arrays needed for evaluation/differentiation
            Variable[] vars = { x, y, z };
            double[] values = {1, 2, -3 };

            // evaluate func at (1, 2, -3)
            double value = func.Evaluate(vars, values);

            // calculate the gradient at (1, 2, -3)
            double[] gradient = func.Differentiate(vars, values);

            // print results
            Console.WriteLine("The value at (1, 2, -3) is " + value);
            Console.WriteLine("The gradient at (1, 2, -3) is ({0}, {1}, {2})", gradient[0], gradient[1], gradient[2]);
    }
}

Fast! See 0.5 vs 0.3 benchmark and 0.3 benchmark.
Composition of functions using arithmetic operators, Exp, Log, Power and user-defined unary and binary functions.
Function gradient evaluation at specified points
Function value evaluation at specified points
Uses Code Contracts for specifying valid parameters and return values
Computes gradients using Reverse-Mode AD algorithm in linear time!
- Yes, it's faster than numeric approximation for multivariate functions
- You get both high accuracy and speed!

Updated Wiki: Home

alexshtf — Sat, 08 Sep 2012 15:45:47 GMT

Project Description
High-performance and high-accuracy automatic function-differentiation library suitable for optimization and numeric computing.

Getting AutoDiff

What is it for?
AutoDiff provides a simple and intuitive API for computing function gradients/derivatives along with a fast state-of-the-art algorithm for performing the computation. Such computations are mainly useful in numeric optimization scenarios.

Code example

using AutoDiff;

class Program
{
    public static void Main(string[] args)
    {
            // define variables
            var x = new Variable();
            var y = new Variable();
            var z = new Variable();

            // define our function
            var func = (x + y) * TermBuilder.Exp(z + x * y);

            // prepare arrays needed for evaluation/differentiation
            Variable[] vars = { x, y, z };
            double[] values = {1, 2, -3 };

            // evaluate func at (1, 2, -3)
            double value = func.Evaluate(vars, values);

            // calculate the gradient at (1, 2, -3)
            double[] gradient = func.Differentiate(vars, values);

            // print results
            Console.WriteLine("The value at (1, 2, -3) is " + value);
            Console.WriteLine("The gradient at (1, 2, -3) is ({0}, {1}, {2})", gradient[0], gradient[1], gradient[2]);
    }
}

Fast! See 0.5 vs 0.3 benchmark and 0.3 benchmark.
Composition of functions using arithmetic operators, Exp, Log, Power and user-defined unary and binary functions.
Function gradient evaluation at specified points
Function value evaluation at specified points
Uses Code Contracts for specifying valid parameters and return values
Computes gradients using Reverse-Mode AD algorithm in linear time!
- Yes, it's faster than numeric approximation for multivariate functions
- You get both high accuracy and speed!

Updated Wiki: Home

alexshtf — Sat, 08 Sep 2012 15:43:48 GMT

Project Description
High-performance and high-accuracy automatic function-differentiation library suitable for optimization and numeric computing.

Getting AutoDiff

What is it for?
AutoDiff provides a simple and intuitive API for computing function gradients/derivatives along with a fast state-of-the-art algorithm for performing the computation. Such computations are mainly useful in numeric optimization scenarios.

Code example

using AutoDiff;

class Program
{
    public static void Main(string[] args)
    {
            // define variables
            var x = new Variable();
            var y = new Variable();
            var z = new Variable();

            // define our function
            var func = (x + y) * TermBuilder.Exp(z + x * y);

            // prepare arrays needed for evaluation/differentiation
            Variable[] vars = { x, y, z };
            double[] values = {1, 2, -3 };

            // evaluate func at (1, 2, -3)
            double value = func.Evaluate(vars, values);

            // calculate the gradient at (1, 2, -3)
            double[] gradient = func.Differentiate(vars, values);

            // print results
            Console.WriteLine("The value at (1, 2, -3) is " + value);
            Console.WriteLine("The gradient at (1, 2, -3) is ({0}, {1}, {2})", gradient[0], gradient[1], gradient[2]);
    }
}

Fast! See 0.5 vs 0.3 benchmark and 0.3 benchmark.
Composition of functions using arithmetic operators, Exp, Log, Power and user-defined unary and binary functions.
Function gradient evaluation at specified points
Function value evaluation at specified points
Uses Code Contracts for specifying valid parameters and return values
Computes gradients using Reverse-Mode AD algorithm in linear time!
- Yes, it's faster than numeric approximation for multivariate functions
- You get both high accuracy and speed!

Updated Wiki: Temporary Post Used For Theme Detection (73ae7c2f-5080-4eb7-a0ae-68067fbb2d27 - 3bfe001a-32de-4114-a6b4-4005b770f6d7)

alexshtf — Mon, 07 May 2012 12:21:54 GMT

This is a temporary post that was not deleted. Please delete this manually. (40940c7f-4b23-4fda-a5e5-0a6c8ab29afa - 3bfe001a-32de-4114-a6b4-4005b770f6d7)

Updated Wiki: Vector math

alexshtf — Mon, 07 May 2012 12:18:03 GMT

Short intro

Creating vectors

Vector operations

Updated Wiki: Temporary Post Used For Theme Detection (a949b0db-7244-4c9e-a857-f7f34fb2737e - 3bfe001a-32de-4114-a6b4-4005b770f6d7)

alexshtf — Mon, 07 May 2012 12:14:19 GMT

This is a temporary post that was not deleted. Please delete this manually. (ed9443c4-70ab-4521-84ce-2762a87b0000 - 3bfe001a-32de-4114-a6b4-4005b770f6d7)

Updated Wiki: Supported functions survey

alexshtf — Mon, 07 May 2012 12:09:37 GMT

Basic arithmetic

var x = new Variable();
var y = new Variable();
var z = new Variable();

var func = (x + y) * z;

Large sums

Powers

Special functions

Updated Wiki: Documentation

alexshtf — Mon, 07 May 2012 11:58:08 GMT

Benchmarks

AutoDiff tutorial

Your first AutoDiff application
AutoDiff revisited - Compiled terms
Solving equations - Newton-Raphson sample
Optimization - simple gradient descent
Optimization - integration with AlgLib
Optimization - integration with ExtremeOptimization
User-defined functions
Supported functions survey (under construction)
Vector math (under construction)

Updated Wiki: Home

alexshtf — Fri, 13 Apr 2012 11:14:03 GMT

Project Description
High-performance and high-accuracy automatic function-differentiation library suitable for optimization and numeric computing.

What is it for?
AutoDiff provides a simple and intuitive API for computing function gradients/derivatives along with a fast state-of-the-art algorithm for performing the computation. Such computations are mainly useful in numeric optimization scenarios. Numeric programming in .NET has never been simpler.

Getting AutoDiff
You can download the library either from this site's download section, or you can use NuGet to install the package in your solution.

Code example

using AutoDiff;

class Program
{
    public static void Main(string[] args)
    {
            // define variables
            var x = new Variable();
            var y = new Variable();
            var z = new Variable();

            // define our function
            var func = (x + y) * TermBuilder.Exp(z + x * y);

            // prepare arrays needed for evaluation/differentiation
            Variable[] vars = { x, y, z };
            double[] values = {1, 2, -3 };

            // evaluate func at (1, 2, -3)
            double value = func.Evaluate(vars, values);

            // calculate the gradient at (1, 2, -3)
            double[] gradient = func.Differentiate(vars, values);

            // print results
            Console.WriteLine("The value at (1, 2, -3) is " + value);
            Console.WriteLine("The gradient at (1, 2, -3) is ({0}, {1}, {2})", gradient[0], gradient[1], gradient[2]);
    }
}

Fast! See 0.5 vs 0.3 benchmark and 0.3 benchmark.
Composition of functions using arithmetic operators, Exp, Log, Power and user-defined unary and binary functions.
Function gradient evaluation at specified points
Function value evaluation at specified points
Uses Code Contracts for specifying valid parameters and return values
Computes gradients using Reverse-Mode AD algorithm in linear time!
- Yes, it's faster than numeric approximation for multivariate functions
- You get both high accuracy and speed!

Updated Wiki: 0.5 vs 0.3 benchmark

alexshtf — Fri, 13 Apr 2012 11:11:58 GMT

We used the same benchmark program as in the 0.3 benchmark page, but replaced the AutoDiff library with the newer version. Here are the results. We have a substantial improvement of compilation and differentiation time. However evaluation time is a bit slower.
In the following charts, the X axis is the number of terms and the Y axis is the time, in milliseconds.

The charts were constructed using the following excel file: benchmark-0.5.xlsx.