Volts, Amps, Watts and Ohms: given two, calculate the other two Ohm's law tells us that the current (I) in amps flowing through a resistance (R) in Ohms when a voltage (V) is applied across it is given as follows:

V = I / R


Similarly the power (P) in watts dissipated by that resistance is given by:

P = V * I


By rearrangement and substitution, formulae may be derived for calculating two of these quantities when any of the other two is given.  These formulae are summarised as follows (note this image uses E instead of V for volts):



Given an input of any two of these quantities in a string, output the other two.


Input numbers will be decimals in whatever format is appropriate for your language.  Precision should be to at least 3 decimal places.  (IEEE 754-2008 binary32 floats are sufficient.)
Each input number will be suffixed with a unit.  This will be one of V A W R for Voltage, Amperage, Power and Resistance (or the equivalent lowercase).  Additionally, you may use Ω instead of R.  The units will not have any decimal prefixes (Kilo-, milli-, etc).
The two input quantities will be given in any order in one string, separated by a single space.
Input quantities will always be real numbers greater than 0.
Output will be in the same format as input.
Equation-solving builtins are disallowed.


Example Inputs

1W 1A
12V 120R
10A 10V
8R 1800W
230V 13A
1.1W 2.333V


Corresponding Outputs

1V 1R
0.1A 1.2W
1R 100W
120V 15A
2990W 17.692R
0.471A 4.948R


It should be noted that solutions to this challenge will effectively be self-inverses.  In other words if you apply a solution to input A B and get output C D, then apply a solution to input C D, then the output should be A B again, though possibly out of order and perturbed due to FP rounding.  So test inputs and outputs may be used interchangeably.
Ruby 171 bytes
Input as function argument. Output to stdout with trailing space (can be revised if necessary.)
-&gt;s{a,b,c,d=s.split.map{|z|[z[-1],z.to_f]}.sort.flatten
%w{EA9.EAAVAA.WVA GS;.A?#WWV.RRR}.map{|w|m=w[n=(a+c+?!).sum%10].ord;print (b**(m%9-4)*d**(m/9-5))**0.5,w[n+7],' '}}

Explanation
All formulas can be expressed in the form b**x*d**y where b &amp; d are the two input values and x &amp; y are powers. For golfing reasons the expression (b**x*d**y)**0.5 was finally preferred as it means x and y become integers in the range -4 to 4.
The following table shows the required expressions (inputs are assumed sorted alphabetically) and the encoded values for the powers. Where x and y are the doubled powers, they are encoded as (x+4)+(y+4)*9+9 or equivalently (x+4)+(y+5)*9. This puts all encodings in the printable ASCII range. Power operators are omitted from the formulas for brevity.
n is a kind of checksum made from the input unit symbols; it can take the values 0,1,2,4,5,6 (3 is not used.)
n     formula 1 formula 2      formula 1                formula 2
value                      powers x+4 y+4 encoding   powers x+4 y+4 encoding

0      A*R=V    A2*R=W       1 1    6 6   69 E        2 1     8 6   71 G  
1    R-1*V=A  R-1*V2=W      -1 1    2 6   65 A       -1 2     2 8   83 S
2 R-.5*W.5=A R.5*W.5=V     -.5 .5   3 5   57 9       .5 .5    5 5   59 ;
3          .         .                       .                         .
4      A*V=W   A-1*V=R       1 1    6 6   69 E       -1 1     2 6   65 A
5    A-1*W=V   A-2*W=R      -1 1    2 6   65 A       -2 1     0 6   63 ?
6    V-1*W=A  V2*W-1=R      -1 1    2 6   65 A        2 -1    8 2   35 #

Ungolfed in test program
f=-&gt;s{
  a,b,c,d=s.split.map{|z|[z[-1],z.to_f]}.        #split the input into an array [[symbol1,value1],[symbol2,value2]]
  sort.flatten                                   #sort alphabetically by symbol and flatten to assign the 4 objects to different variables
  n=(a+c+?!).sum%10                              #sum the ascii codes of the symbols (plus that of ! for good value distribution) and take mod 10. gives a number 0..6 (3 is not used)
  %w{EA9.EAAVAA.WVA GS;.A?#WWV.RRR}.             #for each of the outputs, there is a 14 character string. 1st 7 characters encode powers, 2nd 7 characters are output symbol
  map{|w|                                        #iterate through the 2 outputs
    m=w[n].ord                                   #select one character according to value of n and convert to a number encoding the powers to raise the two inputs to
    print (b**(m%9-4)*d**(m/9-5))**0.5,w[n+7],' '#decode the powers, evaluate the expression and output, append the unit symbol and a space
  }
}

f[&quot;6W 3A&quot;]
puts
f[&quot;12V 120R&quot;]
puts
f[&quot;10A 10V&quot;]
puts
f[&quot;8R 1800W&quot;]
puts
f[&quot;6W 2V&quot;]
puts
f[&quot;2A 3R&quot;]
puts

Output
2.0V 0.6666666666666666R
0.1A 1.2W
100.0W 1.0R
15.0A 120.0V
3.0A 0.6666666666666666R
6.0V 12.0W