>>> (float('inf')+0j)*1
(inf+nanj)

¿Por qué? Esto causó un error desagradable en mi código.

¿Por qué 1la identidad multiplicativa no es dar (inf + 0j)?

El 1se convierte en un número complejo primero, 1 + 0j, que entonces lleva a una inf * 0multiplicación, lo que resulta en un nan.

(inf + 0j) * 1
(inf + 0j) * (1 + 0j)
inf * 1  + inf * 0j  + 0j * 1 + 0j * 0j
#          ^ this is where it comes from
inf  + nan j  + 0j - 0
inf  + nan j

Mecánicamente, la respuesta aceptada es, por supuesto, correcta, pero yo diría que se puede dar una respuesta más profunda.

Primero, es útil aclarar la pregunta como lo hace @PeterCordes en un comentario: "¿Existe una identidad multiplicativa para números complejos que funcione en inf + 0j?"o, en otras palabras, es lo que OP ve una debilidad en la implementación informática de la multiplicación compleja o hay algo conceptualmente incorrecto coninf+0j

Respuesta corta:

Usando coordenadas polares podemos ver la multiplicación compleja como una escala y una rotación. Al girar un "brazo" infinito incluso en 0 grados, como en el caso de multiplicar por uno, no podemos esperar colocar su punta con precisión finita. Entonces, de hecho, hay algo fundamentalmente que no está bien con inf+0j, a saber, que tan pronto como estamos en el infinito, un desplazamiento finito deja de tener sentido.

Respuesta larga:

Antecedentes: El "gran elemento" en torno al cual gira esta pregunta es la cuestión de extender un sistema de números (piense en números reales o complejos). Una de las razones por las que uno podría querer hacer eso es agregar algún concepto de infinito, o "compactar" si uno es matemático. También hay otras razones ( https://en.wikipedia.org/wiki/Galois_theory , https://en.wikipedia.org/wiki/Non-standard_analysis ), pero aquí no nos interesan.

Compactación de un punto

Lo complicado de esta extensión es, por supuesto, que queremos que estos nuevos números encajen en la aritmética existente. La forma más sencilla es agregar un solo elemento en el infinito ( https://en.wikipedia.org/wiki/Alexandroff_extension ) y hacer que sea igual a todo menos cero dividido por cero. Esto funciona para los reales ( https://en.wikipedia.org/wiki/Projectively_extended_real_line ) y los números complejos ( https://en.wikipedia.org/wiki/Riemann_sphere ).

Otras extensiones ...

Si bien la compactación de un punto es simple y matemáticamente sólida, se han buscado extensiones "más ricas" que comprendan múltiples infintos. El estándar IEEE 754 para números de coma flotante reales tiene + inf y -inf ( https://en.wikipedia.org/wiki/Extended_real_number_line ). Parece natural y sencillo, pero ya nos obliga a saltar e inventar cosas como -0 https://en.wikipedia.org/wiki/Signed_zero

... del plano complejo

¿Qué pasa con las extensiones de más de una inf del plano complejo?

En las computadoras, los números complejos generalmente se implementan uniendo dos fp reales, uno para el real y otro para la parte imaginaria. Eso está perfectamente bien siempre que todo sea finito. Sin embargo, tan pronto como se consideran infinitos, las cosas se vuelven complicadas.

El plano complejo tiene una simetría rotacional natural, que se relaciona muy bien con la aritmética compleja, ya que multiplicar el plano completo por e ^ phij es lo mismo que una rotación phi radianes alrededor 0.

Esa cosa del anexo G

Ahora, para mantener las cosas simples, fp complejo simplemente usa las extensiones (+/- inf, nan, etc.) de la implementación del número real subyacente. Esta elección puede parecer tan natural que ni siquiera se percibe como una elección, pero echemos un vistazo más de cerca a lo que implica. Una visualización simple de esta extensión del plano complejo se ve así (I = infinito, f = finito, 0 = 0)

I IIIIIIIII I
             
I fffffffff I
I fffffffff I
I fffffffff I
I fffffffff I
I ffff0ffff I
I fffffffff I
I fffffffff I
I fffffffff I
I fffffffff I
             
I IIIIIIIII I

Pero dado que un verdadero plano complejo es aquel que respeta la multiplicación compleja, una proyección más informativa sería

     III    
 I         I  
    fffff    
   fffffff   
  fffffffff  
I fffffffff I
I ffff0ffff I
I fffffffff I
  fffffffff  
   fffffff   
    fffff    
 I         I 
     III    

En esta proyección vemos la "distribución desigual" de infinitos que no solo es fea sino también la raíz de problemas del tipo que ha sufrido OP: La mayoría de los infinitos (los de las formas (+/- inf, finito) y (finito, + / -inf) se agrupan en las cuatro direcciones principales, todas las demás direcciones están representadas por solo cuatro infinitos (+/- inf, + -inf). No debería sorprender que extender la multiplicación compleja a esta geometría sea una pesadilla .

El anexo G de la especificación C99 hace todo lo posible para que funcione, incluida la flexión de las reglas sobre cómo infe naninteractuar (esencialmente inftriunfa nan). El problema de OP se evita al no promover los reales y un tipo puramente imaginario propuesto a complejo, pero hacer que el 1 real se comporte de manera diferente al complejo 1 no me parece una solución. Es revelador que el Anexo G no llegue a especificar completamente cuál debería ser el producto de dos infinitos.

¿Podemos hacerlo mejor?

Es tentador intentar solucionar estos problemas eligiendo una mejor geometría de infinitos. En analogía con la línea real extendida, podríamos agregar un infinito para cada dirección. Esta construcción es similar al plano proyectivo, pero no agrupa direcciones opuestas. Los infinitos se representarían en coordenadas polares inf xe ^ {2 omega pi i}, la definición de productos sería sencilla. En particular, el problema de OP se resolvería de forma bastante natural.

Pero aquí es donde terminan las buenas noticias. En cierto modo, podemos ser arrojados de nuevo al punto de partida, no sin razón, requiriendo que nuestros infinitos de estilo nuevo admitan funciones que extraigan sus partes reales o imaginarias. La adición es otro problema; agregando dos infinitos no antipodales, tendríamos que establecer el ángulo en indefinido, es decir nan(se podría argumentar que el ángulo debe estar entre los dos ángulos de entrada, pero no hay una forma simple de representar esa "nan-nidad parcial")

Riemann al rescate

En vista de todo esto, tal vez la compactación de un solo punto sea lo más seguro. Quizás los autores del Anexo G sintieron lo mismo al imponer una función cprojque agrupa todos los infinitos.

Aquí hay una pregunta relacionada respondida por personas más competentes en el tema que yo.

Este es un detalle de implementación de cómo se implementa la multiplicación compleja en CPython. A diferencia de otros lenguajes (por ejemplo, C o C ++), CPython adopta un enfoque algo simplista:

1. los ints / floats se promueven a números complejos en la multiplicación
2. Se usa la fórmula escolar simple , que no proporciona los resultados deseados / esperados tan pronto como se involucran números infinitos:

Py_complex
_Py_c_prod(Py_complex a, Py_complex b)
{
    Py_complex r;
    r.real = a.real*b.real - a.imag*b.imag;
    r.imag = a.real*b.imag + a.imag*b.real;
    return r;
}

Un caso problemático con el código anterior sería:

(0.0+1.0*j)*(inf+inf*j) = (0.0*inf-1*inf)+(0.0*inf+1.0*inf)j
                        =  nan + nan*j

Sin embargo, a uno le gustaría tener -inf + inf*jcomo resultado.

En este sentido, otros lenguajes no están muy por delante: la multiplicación de números complejos no fue durante mucho tiempo parte del estándar C, incluido solo en C99 como apéndice G, que describe cómo se debe realizar una multiplicación compleja, y no es tan simple como la fórmula de la escuela anterior! El estándar C ++ no especifica cómo debería funcionar la multiplicación compleja, por lo que la mayoría de las implementaciones de compiladores están recurriendo a la implementación de C, que puede ser conforme a C99 (gcc, clang) o no (MSVC).

Para el ejemplo "problemático" anterior, las implementaciones compatibles con C99 (que son más complicadas que la fórmula de la escuela) darían ( ver en vivo ) el resultado esperado:

(0.0+1.0*j)*(inf+inf*j) = -inf + inf*j 

Incluso con el estándar C99, no se define un resultado inequívoco para todas las entradas y podría ser diferente incluso para las versiones compatibles con C99.

Otro efecto secundario de floatno ser promocionado complexen C99 es que multiplicar inf+0.0jcon 1.0o 1.0+0.0jpuede conducir a resultados diferentes (ver aquí en vivo):

• (inf+0.0j)*1.0 = inf+0.0j
• (inf+0.0j)*(1.0+0.0j) = inf-nanj, ser parte imaginaria -nany no nan(como para CPython) no juega un papel aquí, porque todos los nans silenciosos son equivalentes (ver esto ), incluso algunos de ellos tienen un bit de signo establecido (y por lo tanto se imprimen como "-", ver esto ) y otros no.

Lo cual es al menos contrario a la intuición.

Mi conclusión clave es: no hay nada simple en la multiplicación (o división) de números complejos "simples" y cuando se cambia entre lenguajes o incluso compiladores uno debe prepararse para errores / diferencias sutiles.

Definición divertida de Python. Si estamos resolviendo esto con lápiz y papel, diría que el resultado esperado sería el expected: (inf + 0j)que usted señaló porque sabemos que nos referimos a la norma de 1eso (float('inf')+0j)*1 =should= ('inf'+0j):

Pero ese no es el caso como puede ver ... cuando lo ejecutamos obtenemos:

>>> Complex( float('inf') , 0j ) * 1
result: (inf + nanj)

Python entiende esto *1como un número complejo y no como la norma, por 1lo que interpreta como *(1+0j)y el error aparece cuando intentamos hacer lo inf * 0j = nanjque inf*0no se puede resolver.

Lo que realmente quiere hacer (asumiendo que 1 es la norma de 1):

Recuerde que si z = x + iyes un número complejo con parte real xy parte imaginaria y, el conjugado complejo de zse define como z* = x − iy, y el valor absoluto, también llamado norm of zse define como:

Suponiendo que 1es la norma 1, deberíamos hacer algo como:

>>> c_num = complex(float('inf'),0)
>>> value = 1
>>> realPart=(c_num.real)*value
>>> imagPart=(c_num.imag)*value
>>> complex(realPart,imagPart)
result: (inf+0j)

no muy intuitivo, lo sé ... pero a veces los lenguajes de codificación se definen de una forma diferente a la que usamos en nuestro día a día.