New Math Functions in C++

Posted
Comments None

The C++ code for the 39 new functions that will be added to the built-in math functions of GeneXproTools is shown below. This code is being generated automatically by GeneXproTools using a custom tailored Karva program composed of all the 39 new functions and the C++ Grammar of GeneXproTools.

As explained in the previous post "Function Design: Programming Languages", the C++ Grammar is our reference language as it corresponds to the endogenous calculator of GeneXproTools, which is also in C++. All the code for the other programming languages supported by GeneXproTools is derived from the C++ Grammar or its descendants through a series of small transformations. Over the next posts I'll try and offer some comments that may be useful for creating Custom Grammars using the Built-in Grammars of GeneXproTools as a starting point.

double gepRamp1(double x)
{
    if (x > 0.0)
        return x;
    else
        return 0.0;
}

double gepRamp2(double x)
{
    if (x > 0.0)
        return 0.0;
    else
        return x;
}

double gepRamp3(double x)
{
    if (x > 0.0)
        return 0.0;
    else
        return -x;
}

double gepRamp4(double x)
{
    if (x > 0.0)
        return -x;
    else
        return 0.0;
}

double gepStep1(double x)
{
    if (x > 0.0)
        return 1.0;
    else
        return -1.0;
}

double gepStep2(double x)
{
    if (x > 0.0)
        return 1.0;
    else
        return 0.0;
}

double gepStep3(double x)
{
    if (x >= 1.0)
        return 1.0;
    else
        if (x <= -1.0)
            return -1.0;
        else
            return x;
}

double gepStep4(double x)
{
    if (x >= 1.0)
        return 1.0;
    else
        if (x <= 0.0)
            return 0.0;
        else
            return x;
}

double gepCL2A(double x, double y)
{
    if (x > 0.0 && y > 0.0)
        return 1.0;
    else
        return -1.0;
}

double gepCL2B(double x, double y)
{
    if (x >= 0.0 && y < 0.0)
        return -1.0;
    else
        return 1.0;
}

double gepCL2C(double x, double y)
{
    if (x > 1.0 && y < -1.0)
        return -1.0;
    else
        return 1.0;
}

double gepCL2D(double x, double y)
{
    if (x > 0.0 && y > 0.0)
        return 1.0;
    else
        return 0.0;
}

double gepCL2E(double x, double y)
{
    if (x >= 0.0 && y <= 0.0)
        return 0.0;
    else
        return 1.0;
}

double gepCL2F(double x, double y)
{
    if (x > 1.0 && y < -1.0)
        return 0.0;
    else
        return 1.0;
}

double gepCL3A(double x, double y)
{
    if (x > 0.0 && y < 0.0)
        return 1.0;
    else
        if (x < 0.0 && y > 0.0)
            return -1.0;
        else
            return 0.0;
}

double gepCL3B(double x, double y)
{
    if (x >= 1.0 && y >= 1.0)
        return 1.0;
    else
        if (x <= -1.0 && y <= -1.0)
            return -1.0;
        else
            return 0.0;
}

double gepCL3C(double x, double y)
{
    if (x > 0.0 && y > 0.0)
        return 1.0;
    else
        if (x < 0.0 && y < 0.0)
            return -1.0;
        else
            return 0.0;
}

double gepMap3A(double x, double y)
{
    const double SLACK = 10.0;
    double outVal = 0.0;
    if (y < (x - SLACK))
        outVal = -1.0;
    else if (y > (x + SLACK))
        outVal = 1.0;
    return outVal;
}

double gepMap3B(double x, double y, double z)
{
    // evaluate minValue(x,y) and maxValue(x,y)
    double minValue = x;
    double maxValue = y;
    if (minValue > y)
    {
        minValue = y;
        maxValue = x;
    }
    
    double outVal = 0.0;
    if (z < minValue)
        outVal = -1.0;
    else if (z > maxValue)
        outVal = 1.0;
    return outVal;
}

double gepMap3C(double a, double b, double c, double d)
{
    // evaluate minValue(a,b,c) and maxValue(a,b,c)
    //
    // evaluate minValue(a,b,c)
    double minValue = a;
    if (minValue > b)
        minValue = b;
    if (minValue > c)
        minValue = c;
    // evaluate maxValue(a,b,c)
    double maxValue = a;
    if (maxValue < b)
        maxValue = b;
    if (maxValue < c)
        maxValue = c;

    double outVal = 0.0;
    if (d < minValue)
        outVal = -1.0;
    else if (d > maxValue)
        outVal = 1.0;
    return outVal;
}

double gepMap4A(double x, double y)
{
    const double SLACK = 10.0;
    double outVal = 0.0;
    if (y < (x - SLACK))
        outVal = 0.0;
    else if (y >= (x - SLACK) && y < x)
        outVal = 1.0;
    else if (y >= x && y < (x + SLACK))
        outVal = 2.0;
    else if (y >= (x + SLACK))
        outVal = 3.0;
    return outVal;
}

double gepMap4B(double x, double y, double z)
{
    // evaluate minValue(x,y), maxValue(x,y) and midrange
    double minValue = x;
    double maxValue = y;
    if (minValue > y)
    {
        minValue = y;
        maxValue = x;
    }
    double midrange = (maxValue + minValue)/2.0;
    
    double outVal = 0.0;
    if (z < minValue)
        outVal = 0.0;
    else if (z >= minValue && z < midrange)
        outVal = 1.0;
    else if (z >= midrange && z < maxValue)
        outVal = 2.0;
    else if (z >= maxValue)
        outVal = 3.0;
    return outVal;
}

double gepMap4C(double a, double b, double c, double d)
{
    // evaluate minValue(a,b,c), maxValue(a,b,c) and midleValue(a,b,c)
    //
    // evaluate minValue(a,b,c)
    double minValue = a;
    int argMin = 0;
    if (minValue > b)
    {
        minValue = b;
        argMin = 1;
    }
    if (minValue > c)
    {
        minValue = c;
        argMin = 2;
    }
    // evaluate maxValue(a,b,c)
    double maxValue = a;
    int argMax = 0;
    if (maxValue < b)
    {
        maxValue = b;
        argMax = 1;
    }
    if (maxValue < c)
    {
        maxValue = c;
        argMax = 2;
    }
    // evaluate midleValue(a,b,c)
    double midleValue = c;
    if (0 != argMin && 0 != argMax)
        midleValue = a;
    if (1 != argMin && 1 != argMax)
        midleValue = b;

    double outVal = 0.0;
    if (d < minValue)
        outVal = 0.0;
    else if (d >= minValue && d < midleValue)
        outVal = 1.0;
    else if (d >= midleValue && d < maxValue)
        outVal = 2.0;
    else if (d >= maxValue)
        outVal = 3.0;
    return outVal;
}

double gepMap5A(double x, double y)
{
    const double SLACK = 15.0;
    double outVal = 0.0;
    if (y < (x - SLACK))
        outVal = 0.0;
    else if (y >= (x - SLACK) && y < (x - SLACK/3.0))
        outVal = 1.0;
    else if (y >= (x - SLACK/3.0) && y < (x + SLACK/3.0))
        outVal = 2.0;
    else if (y >= (x + SLACK/3.0) && y < (x + SLACK))
        outVal = 3.0;
    else if (y >= (x + SLACK))
        outVal = 4.0;
    return outVal;
}

double gepMap5B(double x, double y, double z)
{
    // evaluate minValue(x,y), maxValue(x,y), midpoint1, midpoint2
    double minValue = x;
    double maxValue = y;
    if (minValue > y)
    {
        minValue = y;
        maxValue = x;
    }
    double intervalLength = (maxValue - minValue)/3.0;
    double midpoint1 = minValue + intervalLength;
    double midpoint2 = minValue + 2.0*intervalLength;
    
    double outVal = 0.0;
    if (z < minValue)
        outVal = 0.0;
    else if (z >= minValue && z < midpoint1)
        outVal = 1.0;
    else if (z >= midpoint1 && z < midpoint2)
        outVal = 2.0;
    else if (z >= midpoint2 && z < maxValue)
        outVal = 3.0;
    else if (z >= maxValue)
        outVal = 4.0;
    return outVal;
}

double gepMap5C(double a, double b, double c, double d)
{
    // evaluate minValue(a,b,c), maxValue(a,b,c), midleValue(a,b,c), midrange1, midrange2
    //
    // evaluate minValue(a,b,c)
    double minValue = a;
    int argMin = 0;
    if (minValue > b)
    {
        minValue = b;
        argMin = 1;
    }
    if (minValue > c)
    {
        minValue = c;
        argMin = 2;
    }
    // evaluate maxValue(a,b,c)
    double maxValue = a;
    int argMax = 0;
    if (maxValue < b)
    {
        maxValue = b;
        argMax = 1;
    }
    if (maxValue < c)
    {
        maxValue = c;
        argMax = 2;
    }
    // evaluate midleValue(a,b,c)
    double midleValue = c;
    if (0 != argMin && 0 != argMax)
        midleValue = a;
    if (1 != argMin && 1 != argMax)
        midleValue = b;
    // evaluate midrange1 and midrange2
    double midrange1 = (minValue + midleValue)/2.0;
    double midrange2 = (midleValue + maxValue)/2.0;

    double outVal = 0.0;
    if (d < minValue)
        outVal = 0.0;
    else if (d >= minValue && d < midrange1)
        outVal = 1.0;
    else if (d >= midrange1 && d < midrange2)
        outVal = 2.0;
    else if (d >= midrange2 && d < maxValue)
        outVal = 3.0;
    else if (d >= maxValue)
        outVal = 4.0;
    return outVal;
}

double gepMap6A(double x, double y)
{
    const double SLACK = 10.0;
    double outVal = 0.0;
    if (y < (x - SLACK))
        outVal = 0.0;
    else if (y >= (x - SLACK) && y < (x - SLACK/2.0))
        outVal = 1.0;
    else if (y >= (x - SLACK/2.0) && y < x)
        outVal = 2.0;
    else if (y >= x && y < (x + SLACK/2.0))
        outVal = 3.0;
    else if (y >= (x + SLACK/2.0) && y < (x + SLACK))
        outVal = 4.0;
    else if (y >= (x + SLACK))
        outVal = 5.0;
    return outVal;
}

double gepMap6B(double x, double y, double z)
{
    // evaluate minValue(x,y), maxValue(x,y), midrange, midpoint1, midpoint2
    double minValue = x;
    double maxValue = y;
    if (minValue > y)
    {
        minValue = y;
        maxValue = x;
    }
    double midrange = (minValue + maxValue)/2.0;
    double midpoint1 = (minValue + midrange)/2.0;
    double midpoint2 = (midrange + maxValue)/2.0;
    
    double outVal = 0.0;
    if (z < minValue)
        outVal = 0.0;
    else if (z >= minValue && z < midpoint1)
        outVal = 1.0;
    else if (z >= midpoint1 && z < midrange)
        outVal = 2.0;
    else if (z >= midrange && z < midpoint2)
        outVal = 3.0;
    else if (z >= midpoint2 && z < maxValue)
        outVal = 4.0;
    else if (z >= maxValue)
        outVal = 5.0;
    return outVal;
}

double gepMap6C(double a, double b, double c, double d)
{
    // evaluate minValue(a,b,c), maxValue(a,b,c), midleValue(a,b,c), midrange1, midrange2
    //
    // evaluate minValue(a,b,c)
    double minValue = a;
    int argMin = 0;
    if (minValue > b)
    {
        minValue = b;
        argMin = 1;
    }
    if (minValue > c)
    {
        minValue = c;
        argMin = 2;
    }
    // evaluate maxValue(a,b,c)
    double maxValue = a;
    int argMax = 0;
    if (maxValue < b)
    {
        maxValue = b;
        argMax = 1;
    }
    if (maxValue < c)
    {
        maxValue = c;
        argMax = 2;
    }
    // evaluate midleValue(a,b,c)
    double midleValue = c;
    if (0 != argMin && 0 != argMax)
        midleValue = a;
    if (1 != argMin && 1 != argMax)
        midleValue = b;
    // evaluate midrange1 and midrange2
    double midrange1 = (minValue + midleValue)/2.0;
    double midrange2 = (midleValue + maxValue)/2.0;

    double outVal = 0.0;
    if (d < minValue)
        outVal = 0.0;
    else if (d >= minValue && d < midrange1)
        outVal = 1.0;
    else if (d >= midrange1 && d < midleValue)
        outVal = 2.0;
    else if (d >= midleValue && d < midrange2)
        outVal = 3.0;
    else if (d >= midrange2 && d < maxValue)
        outVal = 4.0;
    else if (d >= maxValue)
        outVal = 5.0;
    return outVal;
}

double gepECL3A(double x, double y, double z)
{
    if (y > x && z < x)
        return 1.0;
    else
        if (y < x && z > x)
            return -1.0;
        else return 0.0;
}

double gepECL3B(double x, double y, double z)
{
    if (y > x && z > x)
        return 1.0;
    else
        if (y < x && z < x)
            return -1.0;
        else return 0.0;
}

double gepECL3C(double x, double y, double z)
{
    if (y >= x && z >= x)
        return 1.0;
    else
        if (y <= -x && z <= -x)
            return -1.0;
        else return 0.0;
}

double gepECL3D(double a, double b, double c, double d)
{
    // evaluate minValue(a,b) and maxValue(a,b)
    double minValue = a;
    double maxValue = b;
    if (minValue > b)
    {
        minValue = b;
        maxValue = a;
    }

    if (c >= maxValue && d >= maxValue)
        return 1.0;
    else
        if (c <= minValue && d <= minValue)
            return -1.0;
        else return 0.0;
}

double gepAMin2(double x, double y)
{
    if (x < y)
        return 0.0;
    else
        return 1.0;
}

double gepAMin3(double x, double y, double z)
{
    double temp = x;
    double argMin = 0.0;    
    if (temp >= y)
    {
        temp = y;
        argMin = 1.0;
    }
    if (temp >= z)
    {
        argMin = 2.0;
    }
    return argMin;
}

double gepAMin4(double a, double b, double c, double d)
{
    double temp = a;
    double argMin = 0.0;    
    if (temp >= b)
    {
        temp = b;
        argMin = 1.0;
    }
    if (temp >= c)
    {
        temp = c;
        argMin = 2.0;
    }
    if (temp >= d)
    {
        argMin = 3.0;
    }
    return argMin;
}

double gepAMax2(double x, double y)
{
    if (x >= y)
        return 0.0;
    else
        return 1.0;
}

double gepAMax3(double x, double y, double z)
{
    double temp = x;
    double argMax = 0.0;    
    if (temp < y)
    {
        temp = y;
        argMax = 1.0;
    }
    if (temp < z)
    {
        argMax = 2.0;
    }
    return argMax;
}

double gepAMax4(double a, double b, double c, double d)
{
    double temp = a;
    double argMax = 0.0;    
    if (temp < b)
    {
        temp = b;
        argMax = 1.0;
    }
    if (temp < c)
    {
        temp = c;
        argMax = 2.0;
    }
    if (temp < d)
    {
        argMax = 3.0;
    }
    return argMax;
}

Author

Comments

There are currently no comments on this article.

Comment

Enter your comment below. Fields marked * are required. You must preview your comment first before finally posting.





← Older Newer →