// Java Program to illustrate parallelPrefix()

// and demonstrate different ways of

// passing parameter to it

import java.util.Arrays;

import java.util.function.IntBinaryOperator;

public class GFG {

    // Performs addition

    static int compute(int x, int y)

    {

        return x + y;

    }

    public static void main(String[] args) {

        int[] arr = { 2, 1, 7, 8, 4, 5, 6, 9, 8, 7, 1, 2, 3, 6, 5, 4, 7, 5 };

        // Uncomment to see different methods working

        /* Method 1(Creating an instance for IntBinaryOperator)

        //IntBinaryOperator op = (x, y) -> x + y;

        //Arrays.parallelPrefix(arr, op);

        // Method 2(Directly passing a lambda expression that evaluates to

        // return IntBinaryOperator)

        //Arrays.parallelPrefix(arr, (x, y) -> x + y);

        // Method 3(Declaring the operation in some external Function)

        Arrays.parallelPrefix(arr, GFG::compute); */

        Arrays.parallelPrefix(arr, (x,y) -> compute(x,y));

        // Printing the array elements

        Arrays.stream(arr).forEach(e -> System.out.print(e + "   "));

    }

}

// Java program to demonstrate parallelPrefix

// on a range of a given array

import java.util.Arrays;

import java.util.function.IntBinaryOperator;

public class GFG {

    public static void main(String[] args) {

        int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        // Example 1

        // With Primitive types

        // Performs addition with the adjacent element if first is less than

        // second else perform subtraction

        Arrays.parallelPrefix(arr, (x, y) -> {

            if (x < y)

                return x + y;

            else

                return x - y;

        });

        System.out.println("Example 1: with Primitive type");

        // Printing elements of array

        Arrays.stream(arr).forEach(e -> System.out.print(e + "   "));

        int[] arr1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        // Example 2

        // With primitives

        // Keeps on multiplying adjacent elements

        Arrays.parallelPrefix(arr1, (x, y) -> x * y);

        System.out.println("\nExample 2: with primitives");

        // Printing elements of array

        Arrays.stream(arr1).forEach(e -> System.out.print(e + "   "));

        // Lets examine parallelPrefix(int[] array, int fromIndex, int toIndex,

        // IntBinaryOperator op)

        // It is used when we want to make changes in the specified range of

        // elements in an array

        // Example:

        // If adjacent elements are even then it replace both the element with

        // first

        int[] arr2 = { 1, 2, 4, 8, 5, 9, 6, 8, 9, 10, 11 };

        Arrays.parallelPrefix(arr2, 2, 8, (x, y) -> {

            if (x % 2 == 0 && y % 2 == 0)

                return x;

            else

                return y;

        });

        System.out.println("\nExample: Making Changes in the "

                            +"specified range of element in an Array");

        // Printing element of array

        Arrays.stream(arr2).forEach(e -> System.out.print(e + "   "));

    }

}

// Java program to demonstrate parallelPrefix

// on a user defined array

import java.util.Arrays;

import java.util.function.IntBinaryOperator;

public class GFG {

    // User defined class   

    static class Person{

        String name;

        int age;

        //constructor

        Person(String name, int age){

            this.name = name;

            this.age = age;

        }

    }

    public static void main(String[] args) {

        // Working with user defined class

        Person[] p = { new Person("Geek1", 10),

                       new Person("Geek2", 20), new Person("Geek3", 30),

                       new Person("Geek4", 40), new Person("Geek5", 50),

                       new Person("Geek6", 60), };

        // Example 1; Here we convert the first parameter to upper case and then

        // concatenate or add(in case of age) with the second through out the

        // array

        Arrays.parallelPrefix(p, (e1, e2) ->

                            new Person(e1.name.toUpperCase().concat(e2.name),

                                                e1.age + e2.age));

        System.out.println("\nExample 1 :");

        // Printing elements of the array

        Arrays.stream(p).forEach(e -> System.out.println(e.name + "   " + e.age));

        Person[] p1 = { new Person("Geek1", 10),

                        new Person("Geek2", 20), new Person("Geek3", 30),

                        new Person("Geek4", 40), new Person("Geek5", 50),

                    new Person("Geek6", 60), };

        // This illustrates the same modification as described above but within

        // a specified range

        Arrays.parallelPrefix(p1, 1, 4, (e1, e2) ->

                            new Person(e1.name.toUpperCase().concat(e2.name),

                                                e1.age + e2.age));

        System.out.println("\nExample 2 :");

        // Printing elements of array

        Arrays.stream(p1).forEach(e -> System.out.println(e.name + "   " + e.age));

    }

}