Algorithm to match up grid lines. The maximum value for the left axis starts off in a double called maximumLeft and the value for the right starts off in maximumRight. At the end, they have been increased so that they can be used to produce matching ranges.

gistfile1.m

    NSInteger numberOfIntervals;
    double leftPowerOfTen = pow(10, floor(log10(maximumLeft)));
    double leftMultipleOfPowerOfTen = maximumLeft / leftPowerOfTen;
    
    // round the maximum left up to something nice

    if (leftMultipleOfPowerOfTen < 1.25)
    {
        maximumLeft = leftPowerOfTen * 1.25;
        numberOfIntervals = 5;
    }
    else if (leftMultipleOfPowerOfTen < 1.5)
    {
        maximumLeft = leftPowerOfTen * 1.5;
        numberOfIntervals = 6;
    }
    else if (leftMultipleOfPowerOfTen < 2)
    {
        maximumLeft = leftPowerOfTen * 2;
        numberOfIntervals = 4;
    }
    else if (leftMultipleOfPowerOfTen < 2.5)
    {
        maximumLeft = leftPowerOfTen * 2.5;
        numberOfIntervals = 5;
    }
    else if (leftMultipleOfPowerOfTen < 3)
    {
        maximumLeft = leftPowerOfTen * 3;
        numberOfIntervals = 6;
    }
    else if (leftMultipleOfPowerOfTen < 4)
    {
        maximumLeft = leftPowerOfTen * 4;
        numberOfIntervals = 4;
    }
    else if (leftMultipleOfPowerOfTen < 5)
    {
        maximumLeft = leftPowerOfTen * 5;
        numberOfIntervals = 5;
    }
    else if (leftMultipleOfPowerOfTen < 6)
    {
        maximumLeft = leftPowerOfTen * 6;
        numberOfIntervals = 6;
    }
    else if (leftMultipleOfPowerOfTen < 8)
    {
        maximumLeft = leftPowerOfTen * 8;
        numberOfIntervals = 4;
    }
    else
    {
        maximumLeft = leftPowerOfTen * 10;
        numberOfIntervals = 5;
    }
    
    // Now round up the right such that we get the same number of intervals
    
    double rightPowerOfTen = pow(10, floor(log10(maximumRight)));
    double rightMultipleOfPowerOfTen = maximumRight / rightPowerOfTen;
    
    switch (numberOfIntervals)
    {
        case 4:
        {
            if (rightMultipleOfPowerOfTen < 2)
            {
                maximumRight = rightPowerOfTen * 2;
            }
            else if (rightMultipleOfPowerOfTen < 4)
            {
                maximumRight = rightPowerOfTen * 4;
            }
            else if (rightMultipleOfPowerOfTen < 8)
            {
                maximumRight = rightPowerOfTen * 8;
            }
            else
            {
                maximumRight = rightPowerOfTen * 12;
            }
            
            break;
        }
            
        case 5:
        {
            if (rightMultipleOfPowerOfTen < 1.25)
            {
                maximumRight = rightPowerOfTen * 1.25;
            }
            else if (rightMultipleOfPowerOfTen < 2.5)
            {
                maximumRight = rightPowerOfTen * 2.5;
            }
            else if (rightMultipleOfPowerOfTen < 5)
            {
                maximumRight = rightPowerOfTen * 5;
            }
            else
            {
                maximumRight = rightPowerOfTen * 10;
            }
            
            break;
        }
            
        case 6:
        {
            if (rightMultipleOfPowerOfTen < 1.5)
            {
                maximumRight = rightPowerOfTen * 1.5;
            }
            else if (rightMultipleOfPowerOfTen < 3)
            {
                maximumRight = rightPowerOfTen * 3;
            }
            else if (rightMultipleOfPowerOfTen < 6)
            {
                maximumRight = rightPowerOfTen * 6;
            }
            else if (rightMultipleOfPowerOfTen < 9)
            {
                maximumRight = rightPowerOfTen * 9;
            }
            else
            {
                maximumRight = rightPowerOfTen * 12;
            }
            
            break;
        }
    }
    
    double leftIntervalLength = maximumLeft / numberOfIntervals;
    double rightIntervalLength = maximumRight / numberOfIntervals;