wolfram mathematica - usar - Módulo de Mathematica versus con o bloque-Guía, regla de oro para el uso?

wolfram alpha manual pdf

Question

Leonid escribió en el capítulo iv de su libro: "... Module, Block and With. Estos constructos se explican en detalle en Mathematica Book y Mathematica Help, así que solo diré algunas palabras sobre ellos aquí ..."

Por lo que he leído (he podido encontrar) todavía estoy en la oscuridad. Para las funciones empaquetadas, (simplemente) uso Module, porque funciona y conozco el constructo. Sin embargo, puede que no sea la mejor opción. No me queda del todo claro (de la documentación) cuándo, dónde o por qué usar With (o Block).

Pregunta. ¿Existe una regla de oro / guía sobre cuándo usar Módulo, Con o Bloque (para funciones en paquetes)? ¿Hay limitaciones en comparación con el Módulo? Los documentos dicen que With es más rápido. Quiero poder defender my = choice = for Module (u otro constructo).

Answer 1

Andrew ya ha proporcionado una respuesta muy completa. Simplemente resumiría al señalar que el Module es para definir variables locales que pueden redefinirse dentro del alcance de una definición de función, mientras que With es para definir constantes locales, que no pueden ser. Tampoco puede definir una constante local en función de la definición de otra constante local que haya configurado en la misma declaración With , o tener múltiples símbolos en el LHS de una definición. Es decir, lo siguiente no funciona.

With[{{a,b}= OptionValue /@ {opt1,opt2} }, ...]

Tiendo a configurar definiciones de funciones complicadas con el Module incluye un With . Configuré todas las constantes locales que puedo primero dentro del With , por ejemplo, la Length de los datos pasados ​​a la función, si lo necesito, luego otras variables locales según sea necesario. La razón es que With es un poco más rápido de lo que realmente tiene constantes, no variables.

Answer 2

Como mencionó, hay muchas cosas que considerar y es posible realizar una discusión detallada. Pero aquí hay algunas reglas generales que aplico la mayoría del tiempo:

Module[{x}, ...] es el más seguro y puede ser necesario si

1. Existen definiciones de x que desea evitar durante la evaluación del Módulo, o

2. Existe un código que depende de que x no esté definido (por ejemplo, código como Integrate[..., x] ).

El módulo también es la única opción para crear y devolver un nuevo símbolo. En particular, el módulo a veces se necesita en la programación dinámica avanzada por este motivo.

Si está seguro de que no hay definiciones existentes importantes para xo ningún código que dependa de que no esté definido, entonces Block[{x}, ...] es a menudo más rápido. (Tenga en cuenta que, en un proyecto completamente codificado por usted, estar seguro de estas condiciones es un estándar de "encapsulación" razonable que puede querer hacer cumplir de todos modos, por lo que Bloquear suele ser una buena opción en estas situaciones).

With[{x = ...}, expr] es la única construcción de alcance que inyecta el valor de x dentro de Hold[...] . Esto es útil e importante. With puede ser más rápido o más lento que Block dependiendo de expr y la ruta de evaluación particular que se tome. With es menos flexible, sin embargo, ya que no puede cambiar la definición de x dentro de expr.

Answer 3

Me gustaría mencionar que la documentación oficial sobre la diferencia entre Block y Module está disponible en http://reference.wolfram.com/mathematica/tutorial/BlocksComparedWithModules.html .

Answer 4

Aquí se puede ver una diferencia más práctica entre Block y Module :

Module[{x}, x]
Block[{x}, x]
(*
-> x$1979
x
*)

Entonces, si desea regresar, por ejemplo, x , puede usar Block . Por ejemplo,

Plot[D[Sin[x], x], {x, 0, 10}]

No funciona; para que funcione, uno podría usar

Plot[Block[{x}, D[Sin[x], x]], {x, 0, 10}]

(por supuesto, esto no es ideal, es simplemente un ejemplo).

Otro uso es algo así como Block[{$RecursionLimit = 1000},...] , que cambia temporalmente $RecursionLimit (El Module no habría funcionado ya que renombra $RecursionLimit ).

También se puede usar el Block para bloquear la evaluación de algo, por ejemplo

Block[{Sin}, Sin[.5]] // Trace
(*
-> {Block[{Sin},Sin[0.5]],Sin[0.5],0.479426}
*)

es decir, devuelve Sin[0.5] que solo se evalúa después de que el Block ha terminado de ejecutarse. Esto se debe a que Sin dentro del Block es solo un símbolo, en lugar de la función sinusoidal. Incluso podrías hacer algo como

Block[{Sin = Cos[#/4] &}, Sin[Pi]]
(*
-> 1/Sqrt[2]
*)

(use Trace para ver cómo funciona). Por lo tanto, puede usar Block para redefinir localmente funciones incorporadas también:

Block[{Plus = Times}, 3 + 2]
(*
-> 6
*)