C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/Physics/DoubleRegularPendulumAcceleration.cs

// --------------------------------------------------------
// DoubleRegularPendulumAcceleration.cs
// (A. Schiffler, 2009)
// --------------------------------------------------------

namespace NewGamePhysics.Physics
{
    using System;
    using System.Collections.Generic;
    using System.Text;

    using NewGamePhysics.Mathematics;

    public class DoubleRegularPendulumAcceleration : ISecondDerivative
    {
        private double l1;      // length of rod of top pendulum (constant)
        private double m1;      // mass of top pendulum (constant)
        private double l2;      // length of rod of bottom pendulum (constant)
        private double m2;      // mass of bottom pendulum (constant)
        private double g;       // gravitational constant
       
        public DoubleRegularPendulumAcceleration(double l1, double m1, double l2, double m2, double g)
        {
            this.l1 = l1;
            this.m1 = m1;
            this.l2 = l2;
            this.m2 = m2;
            this.g = g;
        }

        public double L1
        {
            get
            {
                return this.l1;
            }
        }

        public double M1
        {
            get
            {
                return this.m1;
            }
        }

        public double L2
        {
            get
            {
                return this.l2;
            }
        }

        public double M2
        {
            get
            {
                return this.m2;
            }
        }

        public double G
        {
            get
            {
                return this.g;
            }

            set
            {
                this.g = value;
            }
        }

        VectorN ISecondDerivative.GetValue(double t, VectorN theta, VectorN omega)
        {
            double theta1 = theta[0];
            double theta2 = theta[1];
            double omega1 = omega[0];
            double omega2 = omega[1];

            VectorN acceleration = new VectorN(2);
            double theta_diff = theta1 - theta2;
            double mass_sum = m1 + m2;
            double mass_sum2 = mass_sum + m1;
            double denom_part = mass_sum2 - m2 * Math.Cos(2 * theta_diff);
            double sin_theta_diff = Math.Sin(theta_diff);
            double cos_theta_diff = Math.Cos(theta_diff);
            acceleration[0] = (-g * mass_sum2 * Math.Sin(theta1) - m2 * g * Math.Sin(theta_diff - theta2) - 2 * sin_theta_diff * m2 * (omega2 * omega2 * l2 + omega1 * omega1 * l1 * cos_theta_diff)) / (l1 * denom_part);
            acceleration[1] = ( 2 * sin_theta_diff * (omega1 * omega1 * l1 * mass_sum + g * mass_sum * Math.Cos(theta1) + omega2 * omega2 * l2 * m2 * cos_theta_diff) ) / ( l2 * denom_part );

            return acceleration;
        }        
    }
}

---