# Generador de variables aleatorios discretos -- java campo con random campo con generator camp codereview Relacionados El problema

## Discrete random variable generator

2

### problema

Español

Hay mi SSCCE para generar un valor de la variable aleatoria discreta.

` BigDecimal orderPrice = order.getSide() == Side.ASK ? calcAskPrice(order) : calcBidPrice(order) 11 es un valor de valor El RV puede tomar y 99887776655443312 es equivalente a PDF discreto. `

¿Puedes anticipar algún problema con este fragmento?

` ` BigDecimal orderPrice = order.getSide() == Side.ASK ? calcAskPrice(order) : calcBidPrice(order) 3 ` `
Original en ingles

There is my SSCCE to generate a value of discrete random variable.

`values` is set of value the RV can take and `procents` is equivalent to discrete pdf.

Can you anticipate any issue with this snippet?

``import java.util.Random;  public class RandomTest {     public static void main (String[] args) throws Exception {         RandomTest rt = new RandomTest();          int[] values = {0, 1, 2};         int[] procents = {30, 60, 10};          for (int i=0; i < 10; i++) {             System.out.print(rt.discreteRV(values, procents) + " ");         }     }      public int discreteRV (int[] values, int[] procents) throws Exception {         if (values == null || procents == null) throw new Exception("Input parameters are null");         if (values.length != procents.length) throw new Exception("Input parameters length mismatch");          int sumProcents = 0;         for (int i=0; i < procents.length; i++) {             if (procents[i] < 0) throw new Exception("Negative procents are not allowed");             sumProcents += procents[i];         }          if (sumProcents != 100) throw new Exception("Sum of procents is not 100");          int rand = new Random().nextInt(100);          int left = 0, right = 0;         for (int i=0; i < procents.length; i++) {             right += procents[i];             if (rand >= left && rand < right)                 return values[i];             left = right;         }          throw new Exception("");     } } ``

## Lista de respuestas

1

La mejor respuesta

En general, esto se ve bien, es decir, funciona.
Pondré algunas notas en las líneas de su método y le proporcionaré mi sugerencia después de esto.

ortografía: procente no es una palabra inglesa. Bueno, el compilador no le importa, pero el siguiente programador probablemente lo hará.

` ` public int discreteRV(final int[] values, final int[] procents) throws Exception {   ``

Para lanzar una excepción de tipo ` Exception no proporciona ninguna ayuda. El propósito de las excepciones es comunicar errores. Nadie sabe el tipo de error de Exception y puede hacer algo al respecto. Deben ser evitados en declaraciones de lanzamiento. `

` `     if (values == null || procents == null)         throw new Exception("Input parameters are null");   ``

Mientras está revisando su contrato es una buena idea, no obtiene nada aquí.
Java lanzará un error de nullPointer con casi el mismo mensaje exacto, de todos modos, si intenta acceder a ellos.
Mientras no haya planes para hacer cosas especiales, no desperdiciaría las líneas en esto.

` `     if (values.length != procents.length)         throw new Exception("Input parameters length mismatch");  ` `

Lanzaría una excepción de tiempo de ejecución. ` IllegalArgumentException ` parece adecuado aquí.

` `     int sumProcents = 0;     for (final int procent : procents) {         if (procent < 0)             throw new Exception("Negative procents are not allowed");         sumProcents += procent;     }   ``

por excepción: igual que la anterior.
Para verificar: Esto no es válido para todas las entradas.
Considere (y / o pruebe :) ` final int[] procents = { 1234567890, 1234567890, 1825831616 }; `

` `     if (sumProcents != 100)         throw new Exception("Sum of procents is not 100");  ` `

por excepción: igual que la anterior.

` `     final int rand = new Random().nextInt(100);   ``

Si usa este método con frecuencia, hazlo estático (y / o incluso ThreadLocalrandom)

` ` Exception0 ` `

No se necesita la verificación izquierda.
Si consulta algo en el medio, apoye a sus lectores:
En lugar de ` Exception1 intente leer Exception2 `

` ` Exception3 ` `

Para excepción: igual que la anterior. Un ` Exception4 ` se ve adecuado aquí.

` ` Exception5  ``

sugerencia:

` ` Exception6 ` `

Más ideas:
Los argumentos (matrices) podrían ser reemplazados por un objeto. Esto podría facilitar el manejo. Depende de la caja de uso.
Los dos bucles podrían combinarse en un bucle. Perderá el cheque por suma == 100 entonces.

In general, this looks ok, i.e. it works.
I will put some notes on the lines of your method and will provide my suggestion after this.

Spelling: procent is not an English word. Well, the compiler does not care, but the next programmer probably will.

``public int discreteRV(final int[] values, final int[] procents) throws Exception { ``

To throw a exception of type `Exception` does not provide any help. The purpose of exceptions is to communicate errors. Noone knows the type of error from `Exception` and can do anything about it. They should be avoided in throw statements.

``    if (values == null || procents == null)         throw new Exception("Input parameters are null"); ``

While checking your contract is a good idea, you do not gain anything here.
Java will throw a Nullpointer error with nearly the exact same message anyway if you try to access them.
As long as there are no plans to do any special things, I would not waste lines on this.

``    if (values.length != procents.length)         throw new Exception("Input parameters length mismatch"); ``

I would throw a runtime exception. `IllegalArgumentException` looks suitable here.

``    int sumProcents = 0;     for (final int procent : procents) {         if (procent < 0)             throw new Exception("Negative procents are not allowed");         sumProcents += procent;     } ``

For exception: same as above.
For check: This is not valid for all input.
Consider (and/or try:) `final int[] procents = { 1234567890, 1234567890, 1825831616 };`
If you want to check the input, check for both sides.

``    if (sumProcents != 100)         throw new Exception("Sum of procents is not 100"); ``

For exception: same as above.

``    final int rand = new Random().nextInt(100); ``

If you use this method frequently, make it static (and/or even ThreadLocalRandom)

``    int left = 0, right = 0;     for (int i = 0; i < procents.length; i++) {         right += procents[i];         if (rand >= left && rand < right)             return values[i];         left = right;     } ``

The left check is not needed.
Instead of `rand >= left && rand < right` try to read `left <= rand && rand < right`

``    throw new Exception(""); ``

For exception: same as above. A `IllegalStateException` looks suitable here.

``} ``

Suggestion:

``public int discreteRV(final int[] values, final int[] percentages) {     if (values.length != percentages.length)         throw new IllegalArgumentException("values.length != percentages.length");      int sumPercentages = 0;     for (int i = 0; i < percentages.length; ++i) {         if (percentages[i] < 0)             throw new IllegalArgumentException("Negative percentages are not allowed: percentages[" + i + "] = " + percentages[i]);         sumPercentages += percentages[i];         if (sumPercentages > 100)             throw new IllegalArgumentException("Sum > 100");     }      if (sumPercentages != 100)         throw new IllegalArgumentException("Sum of percentages is not 100");      final int randomIntUpTo100 = random.nextInt(100);     int threshold = 0;     for (int i = 0; i < percentages.length; i++) {         threshold += percentages[i];         if (randomIntUpTo100 < threshold)             return values[i];     }     throw new IllegalStateException("No value found. rand:" + randomIntUpTo100); } ``

More ideas:
The arguments (arrays) could be replaced by an Object. This could make the handling easier. Depends on the use case.
The two loops could be combined into one loop. You will loose the check for sum == 100 then.

3  Parser de texto implementado como generador  ( Text parser implemented as a generator )
A menudo necesito analizar el texto separado por pestañas (generalmente de un archivo enorme) a los registros. Escribí un generador para hacer eso por mí; ¿Ha...

2  Proyecto EULER # 2: Suma de incluso números de Fibonacci, utilizando generadores  ( Project euler 2 sum of even fibonacci numbers using generators )
Actualmente estoy trabajando en Project Euler Problem # 2, lo que requiere que imprima la suma de todos los números de Fibonacci todos incluso por debajo ...

2  ASYNC LINKED LISTA DE Y DESYNC ITERABLE  ( Async linked list to and from async iterable )
Estoy trabajando en algunas cosas que funciona mejor con listas vinculadas (inmutables ASYNC), como esta: { value: 'one', next: async () => { value: 'two',...

9  Generador de cadena aleatorio en C  ( Random string generator in c )
He creado esta pequeña función solo para practicar el código C. Es un simple generador de cadenas aleatorias. #include <string.h> #include <time.h> char *...

1  Función del generador para enumerar archivos  ( Generator function to enumerate files )
Quiero implementar una función que enumera todos los archivos en el directorio. Creo que la función debe devuelve una promesa , porque se prefiere la llam...

4  Creación de un índice invertido de documentos de texto  ( Creating an inverted index from text documents )
Estoy trabajando en un proyecto de recuperación de información, donde tengo que procesar un Datos de texto de ~ 1.5 GB y crear un diccionario (palabras, frecu...

10  Uso de generadores para imprimir la estructura similar a un árbol de un proyecto  ( Using generators to print the tree like structure of a project )
El objetivo de este código es imprimir el árbol de entidad de un proyecto VHDL. Hay un readme y pruebas muy mínimas en la github repo . Estoy tratando de h...

4  Combinando fragmentos de datos en una tubería del generador  ( Combining fragments of data in a generator pipeline )
Editar: Parece que el enfoque de programación basado en flujo (o reactivo) ayudaría aquí; Hay algunas bibliotecas en Python que lo intentan. Intenté seguir ...

3  Aplanamiento recursivo de secuencias rápidas - un enfoque demasiado complicado  ( Recursive flattening of swift sequences an overly complicated approach )
Recientemente leí y respondí Martin R 's Recursive Aplanking of Swift Secuencias y continuó jugando con el código hasta que llegué a algo que era bastante...

1  Una clase con un puntero de función en lugar de un generador  ( A class with a function pointer instead of a generator )
Estoy construyendo archivos Tikz, un PDF para cada imagen que tengo. El propósito es agregar texto a cada uno por separado. Las imágenes son LEGION, así que c...