Composite Design pattern - how to create calculator

Question

I want to explore the difference between recursion approach and composite design pattern. Composite design pattern reminds me of a tree structure. So if I have to write up how it would look in a class diagram, we could have this:

Keeping this class diagram in mind, here is what I have so far in Java; but I don't mind pseudo-code.

Let's create a leaf:

class NumericOperand extends ArithmeticExpression{

    public Float add(String:s1,String:s2){
        return s1.toFloat() + s2.toFloat()
    }

    public Float minus(String:s1,String:s2){
        return s1.toFloat() - s2.toFloat()
    }

    public Float multiple(String:s1,String:s2){
        return s1.toFloat() * s2.toFloat()
    }

    public Float divide(String:s1,String:s2){
        return s1.toFloat() / s2.toFloat()
    }
}

Let's now define composite:

public CompositeOperand extends ArithmeticExpression{

    private List<NumericOperand> operandList = new ArrayList<NumericOperand>();
    //now what ???   
    //here im a little lost what i should do ? can you help me ? 
}

In the composite what should I be checking exactly? Obviously I need to somehow know if it's an operator or integer here, but I don't know exactly how to put it together.

Answer 1

Here is one example of arithmetic operations implemented using the Composite design pattern. There are any number of ways to implement arithmetic. The class design here is intended simply to highlight the pattern, not necessarily to portray the "best" solution.

The pattern starts with a Component interface, which is shared by Leafs and Composites.

public interface Arithmetic {
    double compute();
    default void appendChild(Arithmetic arithmetic) {}
    default void removeChild(Arithmetic arithmetic) {}
}

Next, we have Leaf nodes, which each represent a singular operation.

public class Addition implements Arithmetic {
    private final double x;
    private final double y;

    public Addition(double x, double y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public double compute() {
        return x + y;
    }
}

public class Subtraction implements Arithmetic {
    private final double x;
    private final double y;

    public Subtraction(double x, double y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public double compute() {
        return x - y;
    }
}

And finally, a Composite node, which represents multiple operations.

public class CompositeAddition implements Arithmetic {
    private final List<Arithmetic> operations = new ArrayList<>();

    public CompositeAddition(Arithmetic... arithmetics) {
        operations.addAll(Arrays.asList(arithmetics));
    }

    @Override
    public double compute() {
        return operations.stream().mapToDouble(Arithmetic::compute).sum();
    }

    @Override
    public void appendChild(Arithmetic arithmetic) {
        operations.add(arithmetic);
    }

    @Override
    public void removeChild(Arithmetic arithmetic) {
        operations.remove(arithmetic);
    }
}

I leave the remaining arithmetic types as an exercise for the reader. These few classes are sufficient for a demonstration.

public class Main {
    public static void main(String... args) {
        Arithmetic fivePlusTwo = new Addition(5,2);
        Arithmetic fiveMinusTwo = new Subtraction(5,2);
        Arithmetic sevenPlusThree = new CompositeAddition(fivePlusTwo, fiveMinusTwo);
        System.out.println(sevenPlusThree.compute());
    }
}

The critical point of the design pattern is that all operations, whether singular or multiple, can be viewed through the same interface. In this way, a client receiving Arithmetic objects is able to compute() them without knowing whether they are leafs or composites.

Answer 2

In your example, ArithmeticExpression must declare methods which takes ArithmeticExpression as operands in all kind of operations. It could look like this:

public Float add(ArithmeticExpression:s1,ArithmeticExpression:s2){
    return s1.eval() + s2.eval();
}

This idea allows to add two ArithmeticExpression where one could be CompositeOperand and other could be NumericOperand.

Below you can see simple Java implementation. I used Operand name but Expression also could be used.

import java.util.Objects;

public class ArithmeticApp {

    public static void main(String[] args) {
        // expr =  100 / (10 + (2.5 * 4))
        Operand res = CompositeOperand.divide(
                NumericOperand.fromInt(100),
                new PlusExpression(
                        NumericOperand.fromString("10"),
                        CompositeOperand.multiply(
                                NumericOperand.fromDouble(2.5D),
                                NumericOperand.fromInt(4))));
        System.out.println(res.eval());
    }
}

@FunctionalInterface
interface Operand {
    Double eval();
}

class PlusExpression implements Operand {

    private final Operand left;
    private final Operand right;

    public PlusExpression(Operand left, Operand right) {
        this.left = Objects.requireNonNull(left);
        this.right = Objects.requireNonNull(right);
    }

    @Override
    public Double eval() {
        return left.eval() + right.eval();
    }
}

class NumericOperand implements Operand {

    private final Double value;

    private NumericOperand(Double value) {
        this.value = Objects.requireNonNull(value);
    }

    @Override
    public Double eval() {
        return value;
    }

    public static NumericOperand fromString(String value) {
        return fromDouble(Double.parseDouble(value));
    }

    public static NumericOperand fromInt(int value) {
        return fromDouble((double) value);
    }

    public static NumericOperand fromDouble(Double value) {
        return new NumericOperand(value);
    }
}

class CompositeOperand implements Operand {

    private final Operand root;

    public CompositeOperand(Operand root) {
        this.root = Objects.requireNonNull(root);
    }

    @Override
    public Double eval() {
        return root.eval();
    }

    public static CompositeOperand minus(Operand left, Operand right) {
        return new CompositeOperand(() -> left.eval() - right.eval());
    }

    public static CompositeOperand multiply(Operand left, Operand right) {
        return new CompositeOperand(() -> left.eval() * right.eval());
    }

    public static CompositeOperand divide(Operand left, Operand right) {
        return new CompositeOperand(() -> left.eval() / right.eval());
    }
}

Above code prints:

5.0

Take a look at main method where I build complex expression using different kinds of operands. Now, you can implement arithmetical parser and build expression from String.

See:

• How to evaluate a math expression given in string form?
• An algorithm to evaluate arithmetic expressions
• Composite Design Pattern

Answer 3

probably you already solved your problem but if you still need it or if anyone is looking for a more elegant aproach there's a way...

So to start we gonna make 1 interface and 2 classes.

Evaluable.java

public interface Evaluable {
    public int evaluate();
}

Operand.java

public class Operand implements Evaluable {

    private int value;

    public Operand(int value) {
        this.value = value;
    }

    @Override
    public int evaluate() {
        return value;
    }
}

Expression.java

public class Expression implements Evaluable {

    private Evaluable leftOperand;
    private Evaluable rightOperand;
    private final char operation;

    public Expression(Evaluable leftOperand, Evaluable rightOperand, char operation) {
        this.leftOperand = leftOperand;
        this.rightOperand = rightOperand;
        this.operation = operation;
    }


    @Override
    public int evaluate() {
        int result = 0;

        switch (operation) {
            case '+':
                result = leftOperand.evaluate() + rightOperand.evaluate();
                break;
            case '-':
                result = leftOperand.evaluate() - rightOperand.evaluate();
                break;
            case '*':
                result = leftOperand.evaluate() * rightOperand.evaluate();
                break;
            case '/':
                result = leftOperand.evaluate() / rightOperand.evaluate();
                break;
        }
        return result;
    }
}

And now with everything ready we can use it to make some arithmetics:

App.java

public static void main( String[] args ){

Evaluable evaluable = new Operand(5);
System.out.println("Result :" + evaluable.evaluate());

Evaluable expression1 = new Expression(new Operand(3),new Operand(5),'*');
System.out.println("Result :" + expression1.evaluate());

With this pattern we can compose Expressions, and that's excactly the point of it:

Expression expression = new Expression(
        new Expression(
            new Operand(10),
            new Operand(2),
            '+'
        ), 
        new Operand(6),
        '/'
    );
System.out.println("Resultado: " + expression.getResultado());

Answer 4

I think add a partition function which will traverse down the composite tree to compute value will help in this way. The composite tree will be something like this.

And here is the code written in python which implements it given the calculation 2 + (3*5)

#!/usr/bin/env python
# coding: utf-8

# In[34]:


class ArithmeticExpression:

    result = 0

    def __init__(self, operator):
        self.operator = operator

    def compute(self, left, right, operator):

        if operator == '+':
            result = self.add(left, right)
        elif operator == '-':
            result = self.substract(left, right)
        elif operator == '*':
            result = self.multiple(left, right)
        elif operator == '/':
            result = self.multiple(left, right)

        return result 

    def add(self, left, right):
        print('cal {} + {} = {}' .format(left, right, left + right))
        return left + right

    def substract(self, left, right):
        print('cal {} - {} = {}' .format(left, right, left - right))
        return left - right

    def multiple(self, left, right):
        print('cal {} * {} = {}' .format(left, right, left * right))
        return left*right

    def divide(self, left, right):
        print('cal {} / {} = {}' .format(left, right, left / right))
        return left / right

class NumericNode:

    def __init__(self, value):
        self.value = value

    def __repr__(self):
        return "NumericNode {}".format(self.value)

class Composite(ArithmeticExpression):

    def __init__(self, operator):
        super().__init__(operator)
        self.left = None
        self.right = None

    def __repr__(self):
        return "Composite {}".format(self.operator)

    def add_node(self, left, right):
        self.left = left
        self.right = right

    def partition(self, node):

        if isinstance(node, NumericNode):
            return node.value

        return self.compute(self.partition(node.left), self.partition(node.right), node.operator)


# In[35]:


root = Composite(operator='+')
leaf1 = NumericNode(2)
leaf2 = NumericNode(3)
leaf3 = NumericNode(5)
composite2 = Composite(operator='*')
composite2.add_node(leaf2, leaf3)
root.add_node(leaf1, composite2)


# In[36]:


root.partition(root)

# Output:
# Caculate  3 * 5 = 15
# Calculate 2 + 15 = 17