La siguiente imagen muestra un circuito RLC. Un circuito RLC es un circuito eléctrico que consiste en una resistencia (R), un inductor (L) y un condensador (C), conectados en serie o en paralelo. (1)

Para simplificar los cálculos, es común trabajar en el dominio de la frecuencia (Laplace) en lugar del dominio del tiempo.

Tu tarea es:

Tome los valores R, Ly Ccomo entrada, y devuelva los voltajes VR, VLyVC

La conversión al dominio de Laplace es la siguiente:

R = R
XL = j*w*L      // OK, XL = w*L, and ZL = j*XL, but don't mind this here.  
XC = 1/(j*w*C)  // I haven't ruined physics, it's only a minor terminology tweak

donde j = sqrt(-1), y w = 2*pi*50(La frecuencia es de 50 Hz).

La impedancia combinada, cuando los componentes están en serie es Z = R + XL + XC. Quizás recuerdes U = R*Ide las conferencias de física de la escuela secundaria. Es casi lo mismo, pero un poco más compleja ahora: VS = Z*I. La corriente se calcula dividiendo el voltaje VSpor la impedancia total Z. Para encontrar el voltaje en un solo componente, debe conocer la corriente y luego multiplicarla por la impedancia. Por simplicidad, se supone que el voltaje es VS = 1+0*j.

Las ecuaciones que puede necesitar son:

XL = j*w*L
XC = 1/(j*w*C)
Z = R + XL + XC   // The combined impedance of the circuit
I = VS / Z         // The current I (Voltage divided by impedance)
VR = I * R        // Voltage over resistance (Current times resistance)
VL = I * XL       // Voltage over inductor (Current times impedance)
VC = I * XC       // Voltage over capacitor (Current times impedance)

La entrada es de STDIN o como argumentos de función. El resultado / resultado debe ser tres números complejos, en una lista, cadena o lo que sea más práctico en su idioma. No es necesario incluir nombres (ex VR = ...), siempre que los resultados estén en el mismo orden que a continuación. La precisión debe ser de al menos 3 puntos decimales tanto para la parte real como para la imaginaria. La entrada y salida / resultados pueden estar en notación científica si eso es predeterminado en su idioma.

Ry Lson >= 0y C > 0.R, L, C <= inf(o el número más alto posible en su idioma).

Un caso de prueba simple:

R = 1, L = 1, C = 0.00001

VR = 0.0549 + 0.2277i
VL = -71.5372 +17.2353i
VC = 72.4824 -17.4630i

Para los resultados anteriores, este podría ser uno (de muchos) formatos de salida válidos:

(0.0549 + 0.2277i, -71.5372 +17.2353i, 72.4824 -17.4630i)

Algunos formatos de salida válidos para un valor de voltaje son:

1.234+i1.234,   1.23456+1.23456i,   1.2345+i*1.2345,   1.234e001+j*1.234e001.

Esta lista no es exclusiva, por lo que se pueden usar otras variantes, siempre que la parte imaginaria esté indicada por una io una j(común en ingeniería eléctrica comoi se usa para la corriente).

Para verificar el resultado para otros valores de R, L y C, la siguiente debe ser cierto para todos los resultados: VR + VL + VC = 1.

¡El código más corto en bytes gana!

_{Por cierto: sí, es el voltaje sobre un componente y la corriente a través de un componente. Un voltaje nunca ha pasado por nada. =)}

Pyth, 30 29 28 bytes

L*vw*100.l_1)K[Qy0c1y1)cRsKK

Pruébalo en línea.

Mathematica, 33 bytes

Tan cerca de Pyth ...

l/Tr[l={#,#2(x=100Pi*I),1/x/#3}]&

Esta es una función sin nombre, que toma R, Ly Ccomo sus tres argumentos y devuelve una lista de números complejos como el resultado (en el orden requerido VR, VL, VC). Ejemplo de uso:

l/Tr[l={#,#2(x=100Pi*I),1/x/#3}]&[1, 1, 0.00001]
(* {0.0548617 + 0.22771 I, -71.5372 + 17.2353 I, 72.4824 - 17.463 I} *)

Octave / Matlab, 53 51 bytes

function f(R,L,C)
k=-.01j/pi;Z=[R L/k k/C];Z/sum(Z)

Pruébalo en línea

Gracias a @StewieGriffin por eliminar dos bytes.

APL (Dyalog Unicode) , 27 ^SBCS de 24 bytes

Programa completo Indicaciones para C, L, Ren ese orden.

(⊢÷+/)(⎕,⎕∘÷,÷∘⎕)÷○0J100

Pruébalo en línea!

0J100 100  i

○ π veces que

÷ recíproco de eso

(... ) aplique la siguiente función tácita:

 ÷∘⎕ dividir el argumento por input ( C)

 ⎕∘÷, anteponer input ( L) dividido por el argumento

 ⎕, anteponer entrada (R )

(... ) aplique la siguiente función tácita:

 +/ suma los argumentos

 ⊢÷ dividir los argumentos por eso

Octava, 41 bytes

@(R,L,C)(Z=[R L/(k=-.01j/pi) k/C])/sum(Z)

1/(100*j*pi)se puede acortar a lo -.01j/pique es mucho más corto. Al asignarlo a la variable en klínea, la variable se puede usar dos veces. Asignar todo el vector a la variable Zcuesta 4 bytes, pero nos permite dividir por sum(Z), que es 5 bytes más corto que(R+L/k+k/C) .