package teralg;

import java.util.Arrays;
import java.util.function.Predicate;

/**
 * Térinformatikai algoritmusok
 * Elemi algoritmusok
 * @author Máté Cserép <mcserep@outlook.com>
 */
public class BasicAlgorithms {

    public static void main(String[] args) {
        /*
         * Predikátum: Predicate<T>, T típusról logikai típusra képez le: T -> L
         * Megadható például lamda kifejezéssel: (paraméterek) -> { függvénytörzs }
         * Pozitív, páros számok: (d) -> { return d > 0 && d % 2 == 0; }
         * Egyszerűsítés:          d  -> d > 0 && d % 2 == 0;
         * A típust a prediktáum típusából a fordítóprogram dedukálja, nem szükséges (nem is lehet) megadni.
         */
        
        double[] array = { 8.4, 5.2, 9.0, 14.3, 6.2, -8.8, 0.7, 12.6, 3.9 };
        
        System.out.printf("Összeg: %.2f %n", sum(array));
        System.out.printf("Pozitív számok összege: %.2f %n",sum(array, d -> d > 0));
        System.out.printf("Páros egészrészűek száma: %d %n", count(array, d -> d.intValue() % 2 == 0));
        System.out.printf("Legnagyobb elem indexe: %d %n", maxSearch(array));
        System.out.printf("Legnagyobb 5 és 10 közötti elem indexe: %d %n", maxSearch(array, d -> d > 5 && d < 10));
        System.out.printf("Első 0 egészrészű elem indexe: %d %n", linSearch(array, d -> d.intValue() == 0));
        
        System.out.println("Tömb rendezése");
        Arrays.sort(array);
        System.out.printf("9.0 indexe: %d %n", logSearch(array, 9.0));
        System.out.printf("9.1 indexe: %d %n", logSearch(array, 9.1));
    }
    
    // Összegzés
    public static double sum(double[] elements) {
        double s = 0;
        for(int i = 0; i < elements.length; ++i)
            s += elements[i];
        return s;
    }
    
    // Feltételes összegzés
    public static double sum(double[] elements, Predicate<Double> beta) {
        double s = 0;
        for(int i = 0; i < elements.length; ++i)
            if(beta.test(elements[i]))
                s += elements[i];
        return s;
    }
    
    // Számlálás
    public static int count(double[] elements, Predicate<Double> beta) {
        int c = 0;
        for(int i = 0; i < elements.length; ++i)
            if(beta.test(elements[i]))
                ++c;
        return c;
    }
    
    // Maximum kiválasztás
    // A Java nem támogatja több visszatérési érték visszaadását eljárásból,
    // ezért itt csak az indexet adjuk vissza. A sikertelenséget a -1 extremális
    // értékkel jelezzük.
    public static int maxSearch(double[] elements) {
        if(elements.length == 0)
            return -1;
        
        int ind = 0;
        double max = elements[ind];
        
        for(int i = 1; i < elements.length; ++i)
            if(max < elements[i]) {
                ind = i;
                max = elements[ind];
            }
        return ind;
    }
    
    // Feltételes maximum keresés
    // A Java nem támogatja több visszatérési érték visszaadását eljárásból,
    // ezért itt csak az indexet adjuk vissza. A sikertelenséget a -1 extremális
    // értékkel jelezzük.
    public static int maxSearch(double[] elements, Predicate<Double> beta) {
        boolean l = false;
        int ind = -1;
        double max = 0;
        
        for(int i = 0; i < elements.length; ++i)
            if(beta.test(elements[i]))
                if(!l || max < elements[i]) {
                    l = true;
                    ind = i;
                    max = elements[ind];
                }
        return ind;
    }
    
    // Lineáris keresés
    // A Java nem támogatja több visszatérési érték visszaadását eljárásból,
    // ezért itt csak az indexet adjuk vissza. A sikertelenséget a -1 extremális
    // értékkel jelezzük.
    public static int linSearch(double[] elements, Predicate<Double> beta) {
        for(int i = 0; i < elements.length; ++i)
            if(beta.test(elements[i]))
                return i;
        return -1;
    }
    
    // Logaritmikus keresés
    // A Java nem támogatja több visszatérési érték visszaadását eljárásból,
    // ezért itt csak az indexet adjuk vissza. A sikertelenséget a -1 extremális
    // értékkel jelezzük.
    public static int logSearch(double[] elements, double h) {
        int u = 0, v = elements.length - 1;
        while(u <= v) {
            int i = (u + v) / 2;
            if(elements[i] == h)
                return i;
            else if (elements[i] < h)
                u = i + 1;
            else
                v = i - 1;
        }
        return -1;
    }
}