Resistor mesh: Difference between revisions

 

 

 

=={{header|Ada}}==

{{trans|C}}

procedure ResistMesh is

H, W : constant Positive := 10;

diff := 4.0 / (curA - curB);

IIO.Put (diff, Exp => 0); New_Line;

{{out}}<pre> 1.60899124173073</pre>

 

{{trans|Maxima}}

{{works with|BBC BASIC for Windows}}

*FLOAT 64

@% = &F0F

PROC_invert(A())

B() = A().B()

{{out}}

<pre>Resistance = 1.60899124173071 ohms</pre>

 

=={{header|C}}==

#include <stdlib.h>

printf("R = %g\n", 2 / iter(mesh, S, S));

return 0;

 

=={{header|D}}==

{{trans|C}}

 

enum Node.FP differenceThreshold = 1e-40;

 

struct Node {

enum Kind : size_t { free, A, B }

 

FP voltage = 0.0;

 

}

 

static void enforceBoundaryConditions(ref Node[w][h] m)

m[1][1].voltage = 1.0;

m[6][7].voltage = -1.0;

 

static Node.FP calcDifference(in ref Node[w][h] m,

Node.FP total = 0.0;

 

Node.FP v = 0.0;

{

size_t n = 0;

v = m[i][j].voltage - v / n;

}

 

d[i][j].voltage = v;

total += v ^^ 2;

}

 

return total;

if (calcDifference(m, difference) < differenceThreshold)

break;

m[i][j].voltage -= dij.voltage;

}

 

Node.FP[EnumMembers!(Node.Kind).length] cur = 0.0;

 

return (cur[Node.Kind.A] - cur[Node.Kind.B]) / 2.0;

mesh[6][7] = Node(-1.0, Node.Kind.B);

 

{{out}}

<pre>R = 1.6089912417307296556</pre>

 

=={{header|Euler Math Toolbox}}==

The functions for this have been implemented in Euler already. Thus the following commands solve this problem.

 

>load incidence;

>{u,r}=solvePotentialX(makeRectangleX(10,10),12,68); r,

1.60899124173

 

The necessary functions in the file incidence.e are as follows. There are versions with full matrices. But the functions listed here use compressed matrices and the conjugate gradient method.

 

function makeRectangleX (n:index,m:index)

## Make the incidence matrix of a rectangle grid in compact form.

return {u,2/f}

endfunction

 

Here is the code for the conjugate gradient method for compressed, sparse matrices from cpx.e.

 

function cgX (H:cpx, b:real column, x0:real column=none, f:index=10)

## Conjugate gradient method to solve Hx=b for compressed H.

return x;

endfunction

 

=={{header|Go}}==

{{trans|C}}

 

import "fmt"

fmt.Printf("R = %g\n", 2/iter(mesh, S, S))

}

 

=={{header|J}}==

 

 

nodeA=: 1 1

nodeB=: 6 7

 

conn =: [: (#~ e.~/@|:~&0 2) ([ ,: +)"1

 

Here, the result of <code>nodes conn offset</code> represents all pairs of nodes where we can connect the argument nodes to neighboring nodes at the specified offset, and <code>wiring</code> is a list of index pairs representing all connections made by all resistors (note that each connection is represented twice -- node e is connected to node f AND node f is connected to node e). Yii contains the values for the diagonal elements of the Y bus while Yij contains the values for the off diagonal elements of the Y bus.

So:

 

 

Or, if we want an exact answer (this is slow), we can assume our resistors are perfect:

 

 

(here, the letter 'r' separates the numerator from the denominator)

 

=={{header|Maxima}}==

for the potential at A and B, since I = R (V(B) - V(A)) where I is given and we want R.

Atually, we will compute potential at each node, except A where we assume it's 0.

is known up to a constant. For A we will simply write the equation V(A) = 0, to

keep the program simple.

 

bfloat(%), fpprec = 40;

 

 

 

 

=={{header|Perl}}==

{{trans|C}}

 

my ($w, $h) = (9, 9);

sub iter {

my $diff = 1;

set_boundary();

$diff = calc_diff();

for my $i (0 .. $h) {

for my $j (0 .. $w) {

}

}

 

my @current = (0) x 3;

}

 

 

{{out}}

 

=={{header|Python}}==

{{trans|D}}

 

class Fixed:

print "R = %.16f" % (2 / iter(mesh))

 

{{out}}

<pre>R = 1.6089912417307286</pre>

 

=={{header|REXX}}==

{{trans|Ada}}

 

say

 

 

 

</pre>

 

=={{header|Tcl}}==

{{trans|C}}

 

oo::class create ResistorMesh {

variable forcePoints V fixed w h

expr {$voltageDifference / [my FindCurrentFixpoint $epsilon]}

}

Setting up and solving this particular problem:

size {10 10}

fixed {1 1 1.0}

fixed {6 7 -1.0}

}

{{out}}

<pre>

R = 1.60899124173

</pre>

 

=={{header|XPL0}}==

{{trans|C}}

def S = 10;

 

real MeshV(S,S); int MeshF(S,S);

 

{{out}}

</pre>