[Java] Kleine Klasse für Polynome

[Mr. White]

Hi,

ich habe eine Klasse wiedergefunden, die ich vor >1 Jahr für meine Mathe-Hausaufgaben geschrieben habe.

Spoiler:

class Polynomial {

    private static enum GroupNames {

        COEFF, POW, NUM;

    }



    private List<Tuple<Double, Integer>> monomials;



    public Polynomial(String input) {

        this.monomials = parse(input.replaceAll("\\s", ""));

        sortByDegreeDesc();

    }



    private Polynomial(List<Tuple<Double, Integer>> newMonomials) {

        monomials = new ArrayList<>();

        for (Tuple<Double, Integer> tuple : newMonomials) {

            monomials.add(tuple);

        }

        sortByDegreeDesc();

    }



    public double evaluate(double x) {

        double sum = 0;

        for (Tuple<Double, Integer> tuple : monomials) {

            final Double v1 = tuple.getValue1();

            final Integer v2 = tuple.getValue2();

            sum += v2 == null ? v1 : v1 * Math.pow(x, v2);

        }

        return sum;

    }



    public Polynomial getDerivative() {

        final List<Tuple<Double, Integer>> newMonomials = new ArrayList<>();

        for (Tuple<Double, Integer> tuple : monomials) {

            final Double  coeff = tuple.getValue1();

            final Integer power = tuple.getValue2();

            if (power == null)

                continue;

            final Double newCoeff = coeff * power;

            final Integer newPower = (power - 1) == 0 ? null : (power - 1);

            newMonomials.add(new Tuple<Double, Integer>(newCoeff, newPower));

        }

        return new Polynomial(newMonomials);

    }



    public Polynomial getAntiderivative() {

        final List<Tuple<Double, Integer>> newMonomials = new ArrayList<>();

        for (Tuple<Double, Integer> tuple : monomials) {

            final Double  coeff = tuple.getValue1();

            final Integer power = tuple.getValue2() == null ? 0 : tuple.getValue2();

            final Double newCoeff = coeff / (power + 1);

            final Integer newPower = power + 1;

            newMonomials.add(new Tuple<Double, Integer>(newCoeff, newPower));

        }

        return new Polynomial(newMonomials);

    }





    private List<Tuple<Double, Integer>> parse(String input) {

        final Matcher matcher = getPattern().matcher(input);

        final List<Tuple<Double, Integer>> output = new ArrayList<>();

        while (matcher.find()) {

            final String coeffGroup = matcher.group(GroupNames.COEFF.name());

            final String powerGroup = matcher.group(GroupNames.POW.name());

            final String   numGroup = matcher.group(GroupNames.NUM.name());

            if (numGroup != null) {

                output.add(new Tuple<Double, Integer>(Double.parseDouble(numGroup), null));

            } else {

                final double coeff = coeffGroup == null ? 1 : Double.parseDouble(coeffGroup);

                final int    power = powerGroup == null ? 1 : Integer.parseInt(powerGroup);

                output.add(new Tuple<Double, Integer>(coeff, power));

            }

        }

        return output;

    }



    private Pattern getPattern() {

        final String numberP = "[+-]?\\d+(\\.\\d+)?";

        final String  coeffP = "(?<" + GroupNames.COEFF.name() + ">" + numberP + ")";

        final String  powerP = "(?<" + GroupNames.POW.name()   + ">\\d+)";

        final String    numP = "(?<" + GroupNames.NUM.name()   + ">" + numberP + ")";

        return Pattern.compile("((" + coeffP + ")?(x(\\^" + powerP + ")?))|" + numP);

    }



    private void sortByDegreeDesc() {

        Collections.sort(monomials, new Comparator<Tuple<Double, Integer>>() {

            @Override

            public int compare(Tuple<Double, Integer> o1, Tuple<Double, Integer> o2) {

                final Integer o1Degree = o1.getValue2();

                final Integer o2Degree = o2.getValue2();

                if (o1Degree == null && o2Degree == null)

                    return 0;

                else if (o1Degree == null && o2Degree != null)

                    return 1;

                else if (o1Degree != null && o2Degree == null)

                    return -1;

                return o1Degree == o2Degree ? 0 : (o1Degree > o2Degree ? -1 : 1);

            }

        });

    }



    @Override

    public String toString() {

        final StringBuilder output = new StringBuilder();

        for (Tuple<Double, Integer> tuple : monomials) {

            final Double  v1 = tuple.getValue1();

            final Integer v2 = tuple.getValue2();

            if (v2 == null)

                output.append(String.format("%+.2f", v1) + " ");

            else

                output.append(String.format("%+.2f", v1) + (v2 == 1 ? "x " : "x^" + v2 + " "));

        }

        return output.toString();

    }

}



final class Tuple<A, B> {

    private final A value1;

    private final B value2;



    public Tuple(A value1, B value2) {

        this.value1 = value1;

        this.value2 = value2;

    }



    public A getValue1() { return value1; }

    public B getValue2() { return value2; }

}

Die Klasse nimmt Polynome als String (z.B. "6x^3+2x^2+6x-9") entgegen, parst sie und stellt Methoden zur Verfügung, mit denen man ab- und aufleiten sowie evaluieren kann.

Beispielprogramm:

public final class PolynomialDemo {

    public static void main(String[] args) throws IOException {

        final Polynomial polynomial = new Polynomial("6x^3+2x^2+6x-9");



        final Polynomial firstAntiDeriv = polynomial.getAntiderivative();

        final Polynomial secndAntiDeriv = firstAntiDeriv.getAntiderivative();

        final Polynomial thirdAntiDeriv = secndAntiDeriv.getAntiderivative();



        final Polynomial firstDeriv = polynomial.getDerivative();

        final Polynomial secndDeriv = firstDeriv.getDerivative();

        final Polynomial thirdDeriv = secndDeriv.getDerivative();



        System.out.println("F'''(x) = " + thirdAntiDeriv);

        System.out.println("F''(x) = " + secndAntiDeriv);

        System.out.println("F'(x) = " + firstAntiDeriv);



        System.out.println("\nf(x) = " + polynomial + "\t f(5) = " + polynomial.evaluate(5) + "\n");



        System.out.println("f'(x) = " + firstDeriv);

        System.out.println("f''(x) = " + secndDeriv);

        System.out.println("f'''(x) = " + thirdDeriv);

    }

}

Ausgabe:



Vielleicht werde ich bei Gelegenheit etwas mehr Ordnung reinbringen und um Funktionalität erweitern. Die Nullstellenberechnung zu programmieren, war mir damals zu kompliziert. xD