⚠️ Warning: This is a draft ⚠️
This means it might contain formatting issues, incorrect code, conceptual problems, or other severe issues.
If you want to help to improve and eventually enable this page, please fork RosettaGit's repository and open a merge request on GitHub.
{{draft task}}
;Introduction
- Calculate the resistance of a network of resistors.
- The resistors can be connected in series or parallel.
- Use infix or RPN to state the network.
- Calculate resistance, voltage, current and power for every resistor and operation.
;Background
- Serial Resistors: the sum of the resistors gives the equivalent resistor
- Parallel Resistors: the inverse of the sum of the inverse of the resistors
- The voltage drops over the resistors
- Current = Resistance / Voltage
- Power = Current * Voltage
;Input [https://photos.app.goo.gl/58heQVm8UJYf8Ra29 Resistance Calculator]
- Infix: ((((10 + 2) * 6 + 8) * 6 + 4) * 8 + 4) * 8 + 6
- RPN: 10 2 + 6 * 8 + 6 * 4 + 8 * 4 + 8 * 6 +
- Voltage = 18.0 V
;Output
- 10.000 ohms in the upper left corner is the equivalent resistance.
- The first operation is 10 + 2 = 12 which can be found in the three middle rows. Ohm Volt Ampere Watt Network tree 10.000 18.000 1.800 32.400 + 4.000 7.200 1.800 12.960 | * 8.000 7.200 0.900 6.480 | | + 4.000 3.600 0.900 3.240 | | | * 8.000 3.600 0.450 1.620 | | | | + 4.000 1.800 0.450 0.810 | | | | | * 12.000 1.800 0.150 0.270 | | | | | | + 4.000 0.600 0.150 0.090 | | | | | | | * 12.000 0.600 0.050 0.030 | | | | | | | | + 10.000 0.500 0.050 0.025 | | | | | | | | | r 2.000 0.100 0.050 0.005 | | | | | | | | | r 6.000 0.600 0.100 0.060 | | | | | | | | r 8.000 1.200 0.150 0.180 | | | | | | | r 6.000 1.800 0.300 0.540 | | | | | | r 4.000 1.800 0.450 0.810 | | | | | r 8.000 3.600 0.450 1.620 | | | | r 4.000 3.600 0.900 3.240 | | | r 8.000 7.200 0.900 6.480 | | r 6.000 10.800 1.800 19.440 | r
CoffeeScript
RPN
nd = (num) -> num.toFixed(3).padStart 8
class Resistor
constructor : (@resistance,@a=null,@b=null,@symbol='r') ->
res : -> @resistance
setVoltage : (@voltage) ->
current : -> @voltage / @res()
effect : -> @current() * @voltage
report : (level) ->
print "#{nd @res()} #{nd @voltage} #{nd @current()} #{nd @effect()} #{level}#{@symbol}"
if @a then @a.report level + "| "
if @b then @b.report level + "| "
class Serial extends Resistor
constructor : (a,b) -> super 0,a,b,'+'
res : -> @a.res() + @b.res()
setVoltage : (@voltage) ->
ra = @a.res()
rb = @b.res()
@a.setVoltage ra/(ra+rb) * @voltage
@b.setVoltage rb/(ra+rb) * @voltage
class Parallel extends Resistor
constructor : (a,b) -> super 0,a,b,'*'
res : -> 1 / (1 / @a.res() + 1 / @b.res())
setVoltage : (@voltage) ->
@a.setVoltage @voltage
@b.setVoltage @voltage
build = (s) ->
stack = []
for word in s.split ' '
if word == '+' then stack.push new Serial stack.pop(), stack.pop()
else if word == '*' then stack.push new Parallel stack.pop(), stack.pop()
else stack.push new Resistor parseFloat word
stack.pop()
node = build "10 2 + 6 * 8 + 6 * 4 + 8 * 4 + 8 * 6 +"
node.setVoltage 18.0
print " Ohm Volt Ampere Watt Network tree"
node.report ""
Go
Infix
{{trans|Nim}}
package main import "fmt" type Resistor struct { symbol rune resistance, voltage float64 a, b *Resistor } func (r *Resistor) res() float64 { switch r.symbol { case '+': return r.a.res() + r.b.res() case '*': return 1 / (1/r.a.res() + 1/r.b.res()) default: return r.resistance } } func (r *Resistor) setVoltage(voltage float64) { switch r.symbol { case '+': ra := r.a.res() rb := r.b.res() r.a.setVoltage(ra / (ra + rb) * voltage) r.b.setVoltage(rb / (ra + rb) * voltage) case '*': r.a.setVoltage(voltage) r.b.setVoltage(voltage) } r.voltage = voltage } func (r *Resistor) current() float64 { return r.voltage / r.res() } func (r *Resistor) effect() float64 { return r.current() * r.voltage } func (r *Resistor) report(level string) { fmt.Printf("%8.3f %8.3f %8.3f %8.3f %s%c\n", r.res(), r.voltage, r.current(), r.effect(), level, r.symbol) if r.a != nil { r.a.report(level + "| ") } if r.b != nil { r.b.report(level + "| ") } } func (r *Resistor) add(other *Resistor) *Resistor { return &Resistor{'+', 0, 0, r, other} } func (r *Resistor) mul(other *Resistor) *Resistor { return &Resistor{'*', 0, 0, r, other} } func main() { var r [10]*Resistor resistances := []float64{6, 8, 4, 8, 4, 6, 8, 10, 6, 2} for i := 0; i < 10; i++ { r[i] = &Resistor{'r', resistances[i], 0, nil, nil} } node := r[7].add(r[9]).mul(r[8]).add(r[6]).mul(r[5]).add(r[4]).mul(r[3]).add(r[2]).mul(r[1]).add(r[0]) node.setVoltage(18) fmt.Println(" Ohm Volt Ampere Watt Network tree") node.report("") }
RPN
package main import ( "fmt" "strconv" "strings" ) type Stack []*Resistor func (s *Stack) push(r *Resistor) { *s = append(*s, r) } func (s *Stack) pop() *Resistor { le := len(*s) if le == 0 { panic("Attempt to pop from an empty stack") } le-- r := (*s)[le] *s = (*s)[:le] return r } type Resistor struct { symbol rune resistance, voltage float64 a, b *Resistor } func (r *Resistor) res() float64 { switch r.symbol { case '+': return r.a.res() + r.b.res() case '*': return 1 / (1/r.a.res() + 1/r.b.res()) default: return r.resistance } } func (r *Resistor) setVoltage(voltage float64) { switch r.symbol { case '+': ra := r.a.res() rb := r.b.res() r.a.setVoltage(ra / (ra + rb) * voltage) r.b.setVoltage(rb / (ra + rb) * voltage) case '*': r.a.setVoltage(voltage) r.b.setVoltage(voltage) } r.voltage = voltage } func (r *Resistor) current() float64 { return r.voltage / r.res() } func (r *Resistor) effect() float64 { return r.current() * r.voltage } func (r *Resistor) report(level string) { fmt.Printf("%8.3f %8.3f %8.3f %8.3f %s%c\n", r.res(), r.voltage, r.current(), r.effect(), level, r.symbol) if r.a != nil { r.a.report(level + "| ") } if r.b != nil { r.b.report(level + "| ") } } func build(rpn string) *Resistor { st := new(Stack) for _, token := range strings.Fields(rpn) { switch token { case "+": b, a := st.pop(), st.pop() st.push(&Resistor{'+', 0, 0, a, b}) case "*": b, a := st.pop(), st.pop() st.push(&Resistor{'*', 0, 0, a, b}) default: r, _ := strconv.ParseFloat(token, 64) st.push(&Resistor{'r', r, 0, nil, nil}) } } return st.pop() } func main() { node := build("10 2 + 6 * 8 + 6 * 4 + 8 * 4 + 8 * 6 +") node.setVoltage(18) fmt.Println(" Ohm Volt Ampere Watt Network tree") node.report("") }
Nim
import tables,strutils,sequtils,sugar,strformat type Node = ref object kind : char # + = serial * = parallel r = resistor resistance : float voltage : float a : Node b : Node proc res(node : Node) : float = if node.kind == '+' : return node.a.res + node.b.res if node.kind == '*' : return 1/(1/node.a.res + 1/node.b.res) node.resistance proc current(node : Node) : float = return node.voltage / node.res proc effect (node : Node) : float = return node.current * node.voltage proc report(node : Node, level : string = "") = echo fmt"{node.res:8.3f} {node.voltage:8.3f} {node.current:8.3f} {node.effect:8.3f} {level}{node.kind}" if node.kind in "+*": node.a.report level & "| " node.b.report level & "| " proc setVoltage(node : Node, voltage : float) = node.voltage = voltage if node.kind == '+': let ra = node.a.res let rb = node.b.res node.a.setVoltage ra/(ra+rb) * voltage node.b.setVoltage rb/(ra+rb) * voltage if node.kind == '*': node.a.setVoltage voltage node.b.setVoltage voltage proc build(tokens : seq[string]) : Node = var stack : seq[Node] for token in tokens: if token == "+": stack.add Node(kind : '+', a : stack.pop, b : stack.pop) elif token == "*": stack.add Node(kind : '*', a : stack.pop, b : stack.pop) else: stack.add Node(kind : 'r', resistance : parseFloat(token)) stack.pop proc calculate(voltage:float, tokens:seq[string]): Node = echo "" echo " Ohm Volt Ampere Watt Network tree" let node = build tokens node.setVoltage voltage node.report node
RPN
proc rpn(voltage:float, s:string): Node = calculate(voltage, s.split ' ') var node = rpn 18.0,"10 2 + 6 * 8 + 6 * 4 + 8 * 4 + 8 * 6 +" assert 10 == node.res assert 18 == node.voltage assert 1.8 == node.current() assert 32.4 == node.effect() assert '+' == node.kind
Infix
proc parse(s: string): seq[string] = var tmp = "" for ch in s: if ch == ' ': if tmp!="": result.add tmp tmp = "" continue if ch in "+*()": if tmp!="": result.add tmp tmp="" result.add fmt"{ch}" else: tmp &= ch if tmp!="": result.add tmp proc shuntRPN(s:string): seq[string] = let ops = "+*" var tokens = parse s var stack: seq[string] var op: string for token in tokens: case token of "(": stack.add token of ")": while stack.len > 0: op = stack.pop() if op == "(": break result.add op else: if token in ops: while stack.len > 0: op = stack[^1] if not (op in ops): break if ops.find(token) >= ops.find(op): break discard stack.pop() result.add op stack.add token else: result.add token while stack.len > 0: result.add stack.pop() proc infix(voltage:float, s:string): Node = calculate(voltage, shuntRPN s) node = infix 18.0,"((((10+2)*6+8)*6+4)*8+4)*8+6" assert 10 == node.res assert 18 == node.voltage assert 1.8 == node.current() assert 32.4 == node.effect() assert '+' == node.kind
Perl
Infix
{{trans|Perl 6}}
use strict; use warnings; use feature <say state>; { package Resistor; sub new { my ($class, $args) = @_; my $self = { symbol => $args->{symbol}, voltage => $args->{voltage}, resistance => $args->{resistance}, a => $args->{a}, b => $args->{b}, }; return bless $self, $class; } sub res { my $self = shift; if ($self->{symbol} eq '+') { return res($self->{a}) + res($self->{b}) } elsif ($self->{symbol} eq '*') { return 1 / (1/res($self->{a}) + 1/res($self->{b})) } else { return $self->{resistance} } } sub set_voltage { my($self,$voltage) = @_; if ($self->{symbol} eq '+') { my $ra = res($self->{a}); my $rb = res($self->{b}); set_voltage($self->{a}, $ra / ($ra+$rb) * $voltage ); set_voltage($self->{b}, $rb / ($ra+$rb) * $voltage ); } elsif ($self->{symbol} eq '*') { set_voltage($self->{a}, $voltage ); set_voltage($self->{b}, $voltage ); } $self->{voltage} = $voltage; } sub current { my $self = shift; return $self->{voltage} / res($self) } sub effect { my $self = shift; return $self->{voltage} * current($self) } use overload '+' => \&serial, '*' => \∥ sub serial { my($a,$b) = @_; Resistor->new( {symbol => '+', a => $a, b => $b} ) } sub parallel { my($a,$b) = @_; Resistor->new( {symbol => '*', a => $a, b => $b} ) } sub report { my($self,$level) = @_; state @results; push @results, ' Ohm Volt Ampere Watt Network tree' and $level = 1 unless $level; my $pad = ('| ') x $level; my $f = sprintf '%9.3f' x 4, res($self), $self->{voltage}, current($self), effect($self); say "$f $pad" . $self->{symbol}; report($self->{a}, $level+1) if defined $self->{a}; report($self->{b}, $level+1) if defined $self->{b}; join "\n", @results; } } package main; my ($R1, $R2, $R3, $R4, $R5, $R6, $R7, $R8, $R9, $R10) = map { Resistor->new( {symbol => 'r', resistance => $_} ) } <6 8 4 8 4 6 8 10 6 2>; my $node = (((($R8 + $R10) * $R9 + $R7) * $R6 + $R5) * $R4 + $R3) * $R2 + $R1; Resistor::set_voltage($node,18); say Resistor::report($node);
{{out}}
Ohm Volt Ampere Watt Network tree
10.000 18.000 1.800 32.400 | +
4.000 7.200 1.800 12.960 | | *
8.000 7.200 0.900 6.480 | | | +
4.000 3.600 0.900 3.240 | | | | *
8.000 3.600 0.450 1.620 | | | | | +
4.000 1.800 0.450 0.810 | | | | | | *
12.000 1.800 0.150 0.270 | | | | | | | +
4.000 0.600 0.150 0.090 | | | | | | | | *
12.000 0.600 0.050 0.030 | | | | | | | | | +
10.000 0.500 0.050 0.025 | | | | | | | | | | r
2.000 0.100 0.050 0.005 | | | | | | | | | | r
6.000 0.600 0.100 0.060 | | | | | | | | | r
8.000 1.200 0.150 0.180 | | | | | | | | r
6.000 1.800 0.300 0.540 | | | | | | | r
4.000 1.800 0.450 0.810 | | | | | | r
8.000 3.600 0.450 1.620 | | | | | r
4.000 3.600 0.900 3.240 | | | | r
8.000 7.200 0.900 6.480 | | | r
6.000 10.800 1.800 19.440 | | r
```
## Perl 6
### Infix
{{trans|Nim}}
```perl6
class Resistor {
has Str $.symbol;
has Numeric ( $.voltage, $.resistance );
has Resistor ( $.a, $.b );
method res ( ) {
given $.symbol {
when '+' { return $.a.res + $.b.res }
when '*' { return 1 / (1 / $.a.res + 1 / $.b.res) }
default { return $.resistance }
}
}
method set-voltage ( Numeric $voltage ) {
given $.symbol {
when '+' {
my $ra = $.a.res;
my $rb = $.b.res;
$.a.set-voltage( $ra / ($ra+$rb) * $voltage );
$.b.set-voltage( $rb / ($ra+$rb) * $voltage );
}
when '*' {
$.a.set-voltage( $voltage );
$.b.set-voltage( $voltage );
}
}
$!voltage = $voltage;
}
method current ( ) { return $.voltage / self.res }
method effect ( ) { return $.voltage * self.current }
method report ( Int $level = 1 ) {
my $pad = '| ' x $level;
my $f = ( self.res, $.voltage, self.current, self.effect ).fmt('%8.3f');
say "$f $pad$.symbol";
$.a.report( $level+1 ) if $.a;
$.b.report( $level+1 ) if $.b;
}
}
multi sub infix:<+> (Resistor $a, Resistor $b) { $a.new( symbol => '+', :$a, :$b ) }
multi sub infix:<*> (Resistor $a, Resistor $b) { $a.new( symbol => '*', :$a, :$b ) }
my Resistor ($R1, $R2, $R3, $R4, $R5, $R6, $R7, $R8, $R9, $R10) =
map { Resistor.new: symbol => 'r', resistance => $_ },
6, 8, 4, 8, 4, 6, 8, 10, 6, 2;
my $node = (((($R8 + $R10) * $R9 + $R7) * $R6 + $R5)
* $R4 + $R3) * $R2 + $R1;
$node.set-voltage(18);
say ' Ohm Volt Ampere Watt Network tree';
$node.report;
```
{{out}}
Ohm Volt Ampere Watt Network tree
10.000 18.000 1.800 32.400 | +
4.000 7.200 1.800 12.960 | | *
8.000 7.200 0.900 6.480 | | | +
4.000 3.600 0.900 3.240 | | | | *
8.000 3.600 0.450 1.620 | | | | | +
4.000 1.800 0.450 0.810 | | | | | | *
12.000 1.800 0.150 0.270 | | | | | | | +
4.000 0.600 0.150 0.090 | | | | | | | | *
12.000 0.600 0.050 0.030 | | | | | | | | | +
10.000 0.500 0.050 0.025 | | | | | | | | | | r
2.000 0.100 0.050 0.005 | | | | | | | | | | r
6.000 0.600 0.100 0.060 | | | | | | | | | r
8.000 1.200 0.150 0.180 | | | | | | | | r
6.000 1.800 0.300 0.540 | | | | | | | r
4.000 1.800 0.450 0.810 | | | | | | r
8.000 3.600 0.450 1.620 | | | | | r
4.000 3.600 0.900 3.240 | | | | r
8.000 7.200 0.900 6.480 | | | r
6.000 10.800 1.800 19.440 | | r
```
## Phix
```Phix
-- node contents:
enum KIND, -- '+', '*', or 'r'
RESISTANCE, VOLTAGE,
A, B -- nested nodes or NULL
function resistance(sequence node)
switch node[KIND] do
case '+': return resistance(node[A]) + resistance(node[B])
case '*': return 1 / (1/resistance(node[A]) + 1/resistance(node[B]))
case 'r': return node[RESISTANCE]
default: ?9/0 -- unknown node kind
end switch
end function
function setVoltage(sequence node, atom voltage)
switch node[KIND] do
case '+':
atom ra := resistance(node[A]),
rb := resistance(node[B])
node[A] = setVoltage(node[A], ra / (ra + rb) * voltage)
node[B] = setVoltage(node[B], rb / (ra + rb) * voltage)
case '*':
node[A] = setVoltage(node[A],voltage)
node[B] = setVoltage(node[B],voltage)
end switch
node[VOLTAGE] = voltage
return node
end function
function current(sequence node)
return node[VOLTAGE] / resistance(node)
end function
function effect(sequence node)
return current(node) * node[VOLTAGE]
end function
procedure report(sequence node, string level="")
printf(1,"%8.3f %8.3f %8.3f %8.3f %s%c\n", {resistance(node), node[VOLTAGE], current(node), effect(node), level, node[KIND]})
if node[A]!=NULL then
report(node[A],level & "| ")
end if
if node[B]!=NULL then
report(node[B],level & "| ")
end if
end procedure
function push(sequence stack, string tok)
switch tok do
case "+","*": sequence b = stack[$],
a = stack[$-1]
stack = stack[1..$-1]
stack[$] = {tok[1], 0, 0, a, b}
default: integer {{r}} = scanf(tok,"%d")
stack = append(stack,{'r', r, 0, NULL, NULL})
end switch
return stack
end function
```
### RPN
```Phix
function rpn(string s)
sequence stack = {},
tokens = split(s)
for i=1 to length(tokens) do
stack = push(stack,tokens[i])
end for
return stack[$]
end function
sequence node = rpn("10 2 + 6 * 8 + 6 * 4 + 8 * 4 + 8 * 6 +")
node = setVoltage(node,18)
printf(1," Ohm Volt Ampere Watt Network tree\n")
report(node,"")
```
{{out}}
```txt
Ohm Volt Ampere Watt Network tree
10.000 18.000 1.800 32.400 +
4.000 7.200 1.800 12.960 | *
8.000 7.200 0.900 6.480 | | +
4.000 3.600 0.900 3.240 | | | *
8.000 3.600 0.450 1.620 | | | | +
4.000 1.800 0.450 0.810 | | | | | *
12.000 1.800 0.150 0.270 | | | | | | +
4.000 0.600 0.150 0.090 | | | | | | | *
12.000 0.600 0.050 0.030 | | | | | | | | +
10.000 0.500 0.050 0.025 | | | | | | | | | r
2.000 0.100 0.050 0.005 | | | | | | | | | r
6.000 0.600 0.100 0.060 | | | | | | | | r
8.000 1.200 0.150 0.180 | | | | | | | r
6.000 1.800 0.300 0.540 | | | | | | r
4.000 1.800 0.450 0.810 | | | | | r
8.000 3.600 0.450 1.620 | | | | r
4.000 3.600 0.900 3.240 | | | r
8.000 7.200 0.900 6.480 | | r
6.000 10.800 1.800 19.440 | r
```
### infix
slightly trickier
```Phix
constant ops = {"+","*"}
function infix(string s)
string lastnum = ""
sequence tokens = {}
for i=1 to length(s) do
integer ch = s[i]
if ch>='0' and ch<='9' then
lastnum &= ch
else
if length(lastnum) then
tokens = append(tokens,lastnum)
lastnum = ""
end if
tokens = append(tokens,ch&"")
end if
end for
if length(lastnum) then
tokens = append(tokens,lastnum)
end if
sequence stack = {}, result = {}
for i=1 to length(tokens) do
string token = tokens[i], op
switch token do
case "(": stack = append(stack,token)
case ")": while true do
op = stack[$]
stack = stack[1..$-1]
if op == "(" then break end if
result = push(result,op)
end while
else:
integer tp = find(token,ops)
if tp then
while length(stack) do
op = stack[$]
integer sp = find(op,ops)
if not sp or tp>=sp then exit end if
stack = stack[1..$-1]
result = push(result,op)
end while
stack = append(stack,token)
else
result = push(result,token)
end if
end switch
end for
for i=length(stack) to 1 by -1 do
result = push(result,stack[i])
end for
return result[1]
end function
sequence node = infix("((((10+2)*6+8)*6+4)*8+4)*8+6")
```
then as per last 3 lines of RPN, same output.
## Python
### RPN
```python
class Resistor :
def __init__(self, resistance, a=None, b=None, symbol='r'):
self.resistance = resistance
self.a = a
self.b = b
self.symbol = symbol
def res(self) : return self.resistance
def setVoltage(self, voltage): self.voltage = voltage
def current(self) : return self.voltage / self.res()
def effect(self) : return self.current() * self.voltage
def report(self,level=""):
print(f"{self.res():8.3f} {self.voltage:8.3f} {self.current():8.3f} {self.effect():8.3f} {level}{self.symbol}")
if self.a: self.a.report(level + "| ")
if self.b: self.b.report(level + "| ")
class Serial(Resistor) :
def __init__(self, a, b) : super().__init__(0, b, a, '+')
def res(self) : return self.a.res() + self.b.res()
def setVoltage(self, voltage) :
ra = self.a.res()
rb = self.b.res()
self.a.setVoltage(ra/(ra+rb) * voltage)
self.b.setVoltage(rb/(ra+rb) * voltage)
self.voltage = voltage
class Parallel(Resistor) :
def __init__(self,a,b) : super().__init__(0, b, a, '*')
def res(self) : return 1 / (1 / self.a.res() + 1 / self.b.res())
def setVoltage(self, voltage) :
self.a.setVoltage(voltage)
self.b.setVoltage(voltage)
self.voltage = voltage
def build(s) :
stack = []
for word in s.split(' '):
if word == "+": stack.append(Serial(stack.pop(), stack.pop()))
elif word == "*": stack.append(Parallel(stack.pop(), stack.pop()))
else: stack.append(Resistor(float(word)))
return stack.pop()
node = build("10 2 + 6 * 8 + 6 * 4 + 8 * 4 + 8 * 6 +")
print(" Ohm Volt Ampere Watt Network tree")
node.setVoltage(18.0)
node.report()
```
### Infix
```python
class Resistor :
def __init__(self, resistance, a=None, b=None, symbol='r') :
self.resistance = resistance
self.a = a
self.b = b
self.symbol = symbol
def res(self) : return self.resistance
def setVoltage(self, voltage) : self.voltage = voltage
def current(self) : return self.voltage / self.res()
def effect(self) : return self.current() * self.voltage
def report(self,level="") :
print(f"{self.res():8.3f} {self.voltage:8.3f} {self.current():8.3f} {self.effect():8.3f} {level}{self.symbol}")
if self.a: self.a.report(level + "| ")
if self.b: self.b.report(level + "| ")
def __add__(self,other) : return Serial(self,other)
def __mul__(self,other) : return Parallel(self,other)
class Serial(Resistor) :
def __init__(self, a, b) : super().__init__(0, a, b, '+')
def res(self) : return self.a.res() + self.b.res()
def setVoltage(self, voltage) :
ra = self.a.res()
rb = self.b.res()
self.a.setVoltage(ra/(ra+rb) * voltage)
self.b.setVoltage(rb/(ra+rb) * voltage)
self.voltage = voltage
class Parallel(Resistor) :
def __init__(self,a,b) : super().__init__(0, a, b, '*')
def res(self) : return 1 / (1 / self.a.res() + 1 / self.b.res())
def setVoltage(self, voltage):
self.a.setVoltage(voltage)
self.b.setVoltage(voltage)
self.voltage = voltage
[R1,R2,R3,R4,R5,R6,R7,R8,R9,R10] = [Resistor(res) for res in [6,8,4,8,4,6,8,10,6,2]]
node = ((((R8+R10) * R9 + R7) * R6 + R5) * R4 + R3) * R2 + R1
node.setVoltage(18)
print(" Ohm Volt Ampere Watt Network tree")
node.report()
```
## zkl
```zkl
class Resistor{
fcn init(resistance_,symbol_="r", a_=Void, b_=Void){
var resistance,a,b,symbol, voltage=Void;
resistance,symbol,a,b = vm.arglist;
resistance=resistance.toFloat(); // deal with strings/ints
}
fcn res{
if (symbol=="+") a.res() + b.res();
else if(symbol=="*") 1.0/(1.0/a.res() + 1.0/b.res());
else resistance
}
fcn setVoltage(voltage){
if(symbol=="+"){
ra,rb := a.res(), b.res();
a.setVoltage(ra/(ra + rb)*voltage);
b.setVoltage(rb/(ra + rb)*voltage);
}
else if(symbol=="*") T(a,b).apply2("setVoltage",voltage);
self.voltage = voltage.toFloat();
}
fcn current{ voltage/res() }
fcn effect { current()*voltage }
fcn report(level=""){
println("%8.3f %8.3f %8.3f %8.3f %s%s".fmt(res(),voltage,current(),effect(),level,symbol));
T(a,b).apply2("report",level + "| "); // noop if Void
}
fcn __opAdd(other){ Resistor(0,"+",self,other) }
fcn __opMul(other){ Resistor(0,"*",self,other) }
}
```
### Infix
```zkl
R1,R2,R3,R4,R5,R6,R7,R8,R9,R10 := T(6,8,4,8,4,6,8,10,6,2].apply(Resistor);
node:=((((R8 + R10)*R9 + R7)*R6 + R5)*R4 + R3)*R2 + R1;
node.setVoltage(18);
println(" Ohm Volt Ampere Watt Network tree");
node.report();
```
{{out}}
Ohm Volt Ampere Watt Network tree
10.000 18.000 1.800 32.400 +
4.000 7.200 1.800 12.960 | *
8.000 7.200 0.900 6.480 | | +
4.000 3.600 0.900 3.240 | | | *
8.000 3.600 0.450 1.620 | | | | +
4.000 1.800 0.450 0.810 | | | | | *
12.000 1.800 0.150 0.270 | | | | | | +
4.000 0.600 0.150 0.090 | | | | | | | *
12.000 0.600 0.050 0.030 | | | | | | | | +
10.000 0.500 0.050 0.025 | | | | | | | | | r
2.000 0.100 0.050 0.005 | | | | | | | | | r
6.000 0.600 0.100 0.060 | | | | | | | | r
8.000 1.200 0.150 0.180 | | | | | | | r
6.000 1.800 0.300 0.540 | | | | | | r
4.000 1.800 0.450 0.810 | | | | | r
8.000 3.600 0.450 1.620 | | | | r
4.000 3.600 0.900 3.240 | | | r
8.000 7.200 0.900 6.480 | | r
6.000 10.800 1.800 19.440 | r
```
### RPN
```zkl
fcn build(rpnStr){
stack:=List();
foreach symbol in (rpnStr.split()){
if(symbol=="+"){
a,b:=stack.pop(),stack.pop();
stack.append(Resistor(0,"+",b,a))
}
else if(symbol=="*"){
a,b:=stack.pop(),stack.pop();
stack.append(Resistor(0,"*",b,a))
}
else stack.append(Resistor(symbol,"r"));
}
stack.pop() // unevaluated top of circuit
}
node:=build("10 2 + 6 * 8 + 6 * 4 + 8 * 4 + 8 * 6 +");
node.setVoltage(18);
println(" Ohm Volt Ampere Watt Network tree");
node.report();
```
{{out}}
Ohm Volt Ampere Watt Network tree
10.000 18.000 1.800 32.400 +
4.000 7.200 1.800 12.960 | *
8.000 7.200 0.900 6.480 | | +
4.000 3.600 0.900 3.240 | | | *
8.000 3.600 0.450 1.620 | | | | +
4.000 1.800 0.450 0.810 | | | | | *
12.000 1.800 0.150 0.270 | | | | | | +
4.000 0.600 0.150 0.090 | | | | | | | *
12.000 0.600 0.050 0.030 | | | | | | | | +
10.000 0.500 0.050 0.025 | | | | | | | | | r
2.000 0.100 0.050 0.005 | | | | | | | | | r
6.000 0.600 0.100 0.060 | | | | | | | | r
8.000 1.200 0.150 0.180 | | | | | | | r
6.000 1.800 0.300 0.540 | | | | | | r
4.000 1.800 0.450 0.810 | | | | | r
8.000 3.600 0.450 1.620 | | | | r
4.000 3.600 0.900 3.240 | | | r
8.000 7.200 0.900 6.480 | | r
6.000 10.800 1.800 19.440 | r
```