recien estoy estudiando y mejorando mi habilidad en IA cuando tenga algo hare tutorial bueno y si les es importante usar opencv lo hare con eso

ahora estoy trabajando en el algebrea booleana para luego hacer condicionales
luego hare funciones y talves termine en bucles

bueno este desarrollo es incremental y tendre un tiempo de refactoring para mejorar el rendimiento la testeabilidad y facilidad de lectura

ya he escrito codigo mas complicado y con mas limpieza

***** que p**a he hecho con mi vida he puesta a la programación en un pedestal le dedique mucho de mi no se si esta bien o esta mal no se que mas sentir

la sarna con gusto no pica

estoy estudiando AI

quieren que les enseñe como se usa inteligencia artificial para hacer cosas aterradoras
saltar captchas, controlar los clasificadores de imagen ( que reconoscan mal el rostro ) una aplicacion con un solo botonazo y devuelva shell para los que tienen el dedo gordo como yo

hagan su pedido

que malito eres

bueno yo en mis malos tiempos(mejores momentos de mi vida) solia ver el código fuente de la pagina buscar el archivo style.css ojala que las cosas no hayan cambiado

otra manera es ver los archivos javascript tienes que leerlo luego buscas en el control de versiones de wordpress que el archivo sea exactamente igual

hola para todos aquellos que se preguntan como crear su propio evaluador de expresiones del tipo 5*4 +3 -2 *(5) a qui les tengo un pequeño ejemplito en menos de 81 lineas y sin usar regex

package javaapplication17;
 
import java.util.HashMap;
 
public class Interpreter {
 
    private final HashMap<String, String> variables = new HashMap<>();
 
    public static void main(String[] args) {
         Interpreter interpreter = new Interpreter();
        //calculation
        for (String text : new String[]{
            "1",
            "12",
            "5^2",
            "12+13",
            "4+2-1",
            "(1)",
            "(4/2+1*2)",
            "(1+3)+(5+6-3+13)",
            "3*(4+2)",
            "3*4*(5+3)+16+2",
            "8*7+(4+3+6*(5+4))",}) {
 
            System.out.println("text= " + text + " " + interpreter.evalProgram(text));
        }
        //programing feature booleans
        System.out.println();
        System.out.println("booleans");
        System.out.println();
        for (String text : new String[]{
            "1<2",
            "2>3",
            "12>13",
            "12<14",
            "(5+1)<14",
            "14<(5+1)",
            "(1+2)-3<4*2",
            "true",
            "false",
            "false&true",
            "false&true",
            "false&true|true",
            "true&false|true",
            "1+2<3&4<2|false",
            "(1+2)*3-1<4|false&true|(3+1)<4"}) {
            Interpreter programEvaluetor = new Interpreter();
            final String evalBoolean = programEvaluetor.evalProgram(text);
            System.out.println(text + " = " + evalBoolean);
        }
        //simple scripts
 
        System.out.println();
        System.out.println("programs");
        System.out.println();
        for (String text : new String[]{
            "1",
            "3+2-1",
            "3+2-1\n1+2+1",
            "4*5\n5*3",
            "5*8\n4+2\n5+5+5",
            "a=3*4\na",
            "b=3*4\nb",
            "abc=3*4\nabc\ncde=2*5+1\ncde",
            "a=2\nb=3\nc=a+b\nc",
            "c=true\nc",}) {
            Interpreter programEvaluetor = new Interpreter();
            System.out.println("=======program================================");
            System.out.println(text);
            System.out.println("=======endprogram=============================");
            System.out.println("=======output program=========================");
            System.out.println(programEvaluetor.evalProgram(text));
            System.out.println("=======end output program=====================");
            System.out.println("");
            System.out.println("");
        } 
 
        //conditionals programs
        System.out.println();
        System.out.println("conditionals programs");
        System.out.println();
        for (String text : new String[]{
            "1\nif(true){\n2\n}",
            "if(false){\n1\n}",
            "2\nif(true){\n1\n}",
            "2\nif(false){\n1\n}\n3",
            "1\nif(true){\n2\n}\n3",}) {
            Interpreter programEvaluetor = new Interpreter();
            System.out.println("=======program================================");
            System.out.println(text);
            System.out.println("=======endprogram=============================");
            System.out.println("=======output program=========================");
            System.out.println(programEvaluetor.evalProgram(text));
            System.out.println("=======end output program=====================");
            System.out.println("");
            System.out.println("");
        }
        //conditionals programs
    }
 
    private boolean evalCondition(String condition) {
        final String evalBoleanExpresion = evalBoleanExpresion(condition.substring(3, condition.length() - 2));
        return Boolean.parseBoolean(evalBoleanExpresion);
    }
 
    private String evalProgram(final String expresion) {
        String[] comands = expresion.split("\n");
        String result = "";
        boolean run = true;
        for (int i = 0; i < comands.length; i++) {
            String comand = comands[i];
            if (comand.startsWith("if")) {
                run = evalCondition(comand);
                continue;
            }
 
            if (comand.startsWith("}")) {
                run = true;
                continue;
            }
 
            if (run) {
                final String evalComand = evalComand(comand);
                if (!evalComand.isEmpty()) {
                    result += evalComand + "\n";
                }
            }
 
        }
 
        return result.isEmpty() ? "" : result.substring(0, result.length() - 1);
    }
 
    private String evalComand(String expresion) {
        String[] comandPart = expresion.split("=");
        String result = "";
 
        if (comandPart.length == 1) {
            String candidate = comandPart[0];
            if (candidate.equals("true") || candidate.equals("false")) {
                return eval(expresion);
            }
            if (candidate.chars().allMatch(Character::isLetter)) {
                return "" + variables.get(candidate);
            }
            return eval(expresion);
        }
        if (comandPart.length == 2) {
            variables.put(comandPart[0], (eval(comandPart[1])));
 
            return "";
        }
 
        return result;
    }
 
    private String eval(String inputString) {
 
        String buffer = "";
        int beginIndex = -1;
 
        for (int i = 0; i < inputString.length(); i++) {
            final char character = inputString.charAt(i);
            if (character == '(') {
                beginIndex = i;
                buffer = "";
                buffer += character;
            }
            if (!buffer.isEmpty()) {
                String charLetter = (character + "");
                buffer += charLetter.equals("(") || charLetter.equals(")") ? "" : charLetter;
            }
            if (character == ')') {
 
                buffer += character;
                inputString = inputString.substring(0, beginIndex) + evalParentesis(buffer) + inputString.substring(beginIndex + buffer.length());
                i = 0;
                buffer = "";
 
            }
        }
 
        return "" + evalExpresion(inputString);
    }
 
    private String evalParentesis(String coeficientString) {
 
        return evalExpresion(coeficientString.substring(1, coeficientString.length() - 1));
    }
 
    private String evalExpresion(String expresion) {
        String result = "";
        if (expresion.contains("<")
                || expresion.contains(">")
                || expresion.contains("&")
                || expresion.contains("|")
                || expresion.contains("true")
                || expresion.contains("false")) {
            result = evalBoleanExpresion(expresion);
        } else {
            result = evalAddExpresion(expresion) + "";
        }
 
        return result;
    }
 
    private int evalAddExpresion(String expresion) {
        char[] characters = expresion.toCharArray();
        String buffer = "";
        int result = 0;
        for (int i = 0; i < expresion.length(); i++) {
            char character = expresion.charAt(i);
            buffer += character;
            if (i == characters.length - 1
                    || characters[i + 1] == '+'
                    || characters[i + 1] == '-') {
 
                if (buffer.startsWith("-")) {
                    result -= evalSub(buffer.replace("-", ""));
                } else {
                    result += evalSub(buffer.replace("+", ""));
                }
                buffer = "";
            }
 
        }
 
        return result;
    }
 
    private int evalSub(final String expresion) {
        char[] characters = expresion.toCharArray();
        String buffer = "";
        int result = 1;
        for (int i = 0; i < expresion.length(); i++) {
            char character = expresion.charAt(i);
            buffer += character;
            if (i == characters.length - 1
                    || characters[i + 1] == '*'
                    || characters[i + 1] == '/') {
 
                if (buffer.startsWith("/")) {
                    result /= evalExpo(buffer.replace("/", ""));
                } else {
                    result *= evalExpo(buffer.replace("*", ""));
                }
                buffer = "";
            }
 
        }
 
        return result;
    }
 
    private int evalExpo(final String expresion) {
        char[] characters = expresion.toCharArray();
        String buffer = "";
        int result = 1;
        for (int i = expresion.length() - 1; i >= 0; i--) {
            char character = expresion.charAt(i);
            buffer = character + buffer;
            if (i == 0 || characters[i - 1] == '^') {
                result = (int) (Math.pow(Integer.parseInt(evalElement(buffer.replace("^", ""))), (result)));
                buffer = "";
            }
 
        }
        return result;
    }
 
    private String evalElement(String expresion) {
 
        if (expresion.chars().allMatch(Character::isLetter)) {
            return variables.get(expresion);
        } else {
            return expresion;
        }
 
    }
 
    private String evalBoleanExpresion(String expresion) {
        char[] characters = expresion.toCharArray();
        String buffer = "";
        boolean result = true;
        for (int i = 0; i < expresion.length(); i++) {
            char character = expresion.charAt(i);
            buffer += character;
            if (i == characters.length - 1
                    || characters[i + 1] == '&'
                    || characters[i + 1] == '|') {
 
                if (buffer.startsWith("&")) {
                    result &= Boolean.parseBoolean(evalBooleanElement(buffer.replace("&", "")));
                } else if (buffer.startsWith("|")) {
                    result |= Boolean.parseBoolean(evalBooleanElement(buffer.replace("|", "")));
                } else {
                    result = Boolean.parseBoolean(evalBooleanElement(buffer));
                }
                buffer = "";
            }
 
        }
 
        return result + "";
    }
 
    private String evalBooleanElement(final String expresion) {
        String result = "";
        if (expresion.contains("<") || expresion.contains(">")) {
 
            String[] split = expresion.split("<|>");
            String left = evalExpresion(split[0]);
            String right = evalExpresion(split[1]);
 
            if (expresion.contains("<")) {
                result = "" + (Integer.parseInt(left) < Integer.parseInt(right));
 
            }
            if (expresion.contains(">")) {
                result = "" + (Integer.parseInt(left) > Integer.parseInt(right));
            }
        } else {
            result = expresion;
        }
 
        return result;
    }
}
 
 
 

en un futuro agregare la funcionalidad de de agregar variables funciones bucles y condicionales para que se paresca a javascript  

porfavor cuentenme lo que quieran del post preguntas traumas amensas o respuesta troll pero no me ignoren por que soy una perra de atención


diganme si lo han usado y en que

1 para que el compilador te oblige a que escribas el cuerpo de metodo a implementar
2 por que cuando escribieron el metodo addChangeListener lo hicieron asi

addChangeListener(ChangeListener l){
....
}


dale una repasada a lo que son las clases e interfaces y como se usan y tambien a los inner clases

eclipse no tiene nada que ver

tienes que pasarle un objeto por que asi funciona el patron de diseño observador

y se le pasa un objeto entero debido a que java en las versiones anterirores a la 8 a los metodos solo puedes pasarle objetos no hay forma de pasar como parametros a metodos

cuando el usuario le hace click al radiobutton

waaa no lei bien

le quitas el parrallel(linea 3) y ya  se ejecuta en un solo nucleo
o programas normal con bucles y sin usar hilos y ya no habría forma de usar varios nucleos

la "mejor forma y mas facil" de hacerlo es con stream

este es un ejemplo de como
creo un stream de los numeros del uno al 6 (1)
luego le ordeno que los calculos sean en paralelo (2)
luego lo multiplico cada elemento por 2 (3)
luego filtro los que son mayores a 3 (4)
luego le saco el minimo de todos (5)
y en caso de que haya error muera muera tragica y pateticamente sin darle auxilio

 
int min = Stream.of(1, 2, 4, 5, 6).   //1
                parallel().                      //2
                mapToInt((x) -> x * 2). //3
                filter((x) -> x > 3).        //4
                min().                           //5
                orElseThrow(NoSuchElementException::new);//6
        System.out.println(min);
 
 

recuerda que lo mas probable cuando uses streams malogre el rendimiento (es solo para gente grande con pelos en el pecho y lomo plateado)

los stream mejorar el rendimiento solo cuando son calculos de muy alto costo computacional para casos chicos incluso puede empeorar la unica forma de tener un grado de seguridad es con experimentos realistas o un analisis estadisco de datos historicos de forma muy rigurosa

leea para tener fundamento teorico
1 experimentcion k a la n
2 universal escalability law
3 historgrama
4 percentiles
5 usa el "#$%$ excel

xdddddd


mira que bonita ventenita

gracias por el aporte me sera muy util a mi y a los demás cuando tenga que implentarlo