Resistance calculator: Difference between revisions

Content added Content deleted
(→‎{{header|zkl}}: added code)
Line 266: Line 266:


=={{header|Nim}}==
=={{header|Nim}}==
<lang python>import tables,strutils,sequtils,sugar,strformat
===Infix===
<lang python>import strutils,strformat,sugar,sequtils


type
type
Resistor = ref object of RootObj
Node = ref object
kind : char # + = serial * = parallel r = resistor
symbol : char
resistance,voltage : float
resistance : float
a,b : Resistor
voltage : float
a : Node
b : Node


proc res(r:Resistor) : float =
proc res(node : Node) : float =
if r.symbol == '+': return r.a.res + r.b.res
if node.kind == '+' : return node.a.res + node.b.res
if r.symbol == '*': return 1 / (1 / r.a.res + 1 / r.b.res)
if node.kind == '*' : return 1/(1/node.a.res + 1/node.b.res)
r.resistance
node.resistance
proc setVoltage(r:Resistor, voltage:float) =
if r.symbol == '+':
let ra = r.a.res
let rb = r.b.res
r.a.setVoltage ra/(ra+rb) * voltage
r.b.setVoltage rb/(ra+rb) * voltage
if r.symbol == '*':
r.a.setVoltage voltage
r.b.setVoltage voltage
r.voltage = voltage
proc current(r:Resistor) : auto = return r.voltage / r.res
proc effect(r:Resistor) : auto = return r.current * r.voltage
proc report(r:Resistor,level:string="") =
echo fmt"{r.res:8.3f} {r.voltage:8.3f} {r.current:8.3f} {r.effect:8.3f} {level}{r.symbol}"
if r.a!=nil: r.a.report level & "| "
if r.b!=nil: r.b.report level & "| "
proc `+`(r:Resistor,other:Resistor) : auto = return Resistor(symbol:'+', a:r, b:other)
proc `*`(r:Resistor,other:Resistor) : auto = return Resistor(symbol:'*', a:r, b:other)


proc current(node : Node) : float = return node.voltage / node.res
var R1,R2,R3,R4,R5,R6,R7,R8,R9,R10 : Resistor
proc effect (node : Node) : float = return node.current * node.voltage
let resistors = [6,8,4,8,4,6,8,10,6,2].map(res => Resistor(symbol:'r',resistance:res.float))
(R1,R2,R3,R4,R5,R6,R7,R8,R9,R10) = resistors
let node = ((((R8 + R10) * R9 + R7) * R6 + R5) * R4 + R3) * R2 + R1
node.setVoltage(18)
echo(" Ohm Volt Ampere Watt Network tree")
node.report()</lang>


proc report(node : Node, level : string = "") =
===Shunting Yard===
echo fmt"{node.res:8.3f} {node.voltage:8.3f} {node.current:8.3f} {node.effect:8.3f} {level}{node.kind}"
<lang python>import strutils, sequtils, sugar, strformat
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]) =
echo ""
echo " Ohm Volt Ampere Watt Network tree"
let node = build tokens
node.setVoltage voltage
node.report</lang>

===RPN===
<lang python>proc rpn(voltage:float, s:string) = calculate(voltage, s.split ' ')
rpn 18.0,"10 2 + 6 * 8 + 6 * 4 + 8 * 4 + 8 * 6 +"</lang>

===Infix===
<lang python>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] =
proc shuntRPN(s:string): seq[string] =
let ops = "+*"
let ops = "+*"
var input = s.replace("("," ( ")
var tokens = parse s
input = input.replace(")"," ) ")
input = input.replace("+"," + ")
input = input.replace("*"," * ")
input = input.replace(" "," ")
var tokens = input.strip.split
tokens = tokens.filter x => x.strip != ""
var stack: seq[string]
var stack: seq[string]
var op: string
var op: string
for token in tokens:
for token in tokens:
case token
case token
Line 338: Line 359:
stack.add token
stack.add token
else: result.add token
else: result.add token
while stack.len > 0: result.add stack.pop()
while stack.len > 0: result.add stack.pop()


proc infix(voltage:float, s:string) = calculate(voltage, shuntRPN s)
type
infix 18.0,"((((10+2)*6+8)*6+4)*8+4)*8+6"</lang>
Node = ref object
kind : string # +=serial *=parallel r=resistor
resistance : float
voltage : float
a : Node
b : Node

proc res(node: Node) : float =
case node.kind:
of "+": node.a.res + node.b.res
of "*": 1/(1/node.a.res + 1/node.b.res)
else: 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 * voltage/(ra+rb)
node.b.setVoltage rb * voltage/(ra+rb)
if node.kind == "*":
node.a.setVoltage voltage
node.b.setVoltage voltage

proc build(tokens : seq[string]) : Node =
var stack: seq[Node]
for word in tokens:
case word:
of "+","*": stack.add Node(kind: word, a: stack.pop, b: stack.pop)
else: stack.add Node(kind: "r", resistance: parseFloat(word))
stack.pop

proc main =
let node = build shuntRPN "((((10+2)*6+8)*6+4)*8+4)*8+6"
node.setVoltage 18.0
echo " Ohm Volt Ampere Watt Network tree"
node.report

main()</lang>


=={{header|Perl 6}}==
=={{header|Perl 6}}==
Retrieved from "https://rosettacode.org/wiki/Resistance_calculator"