לפלסיאן, הארקה ורשתות

function solve(A,b) {
  const M=A.map((row,i)=>[...row,b[i]]), n=A.length;
  for(let c=0;c<n;c++) { let p=c; for(let r=c+1;r<n;r++) if(Math.abs(M[r][c])>Math.abs(M[p][c])) p=r;
    [M[c],M[p]]=[M[p],M[c]]; const d=M[c][c]; for(let j=c;j<=n;j++) M[c][j]/=d;
    for(let r=0;r<n;r++) if(r!==c) { const f=M[r][c]; for(let j=c;j<=n;j++) M[r][j]-=f*M[c][j]; } }
  return M.map(row=>row[n]);
}

function groundedNetwork(n,edges,weights,ground,injections) {
  const L=Array.from({length:n},()=>Array(n).fill(0));
  edges.forEach(([a,b],k)=>{const c=weights[k];L[a][a]+=c;L[b][b]+=c;L[a][b]-=c;L[b][a]-=c;});
  const active=Array.from({length:n},(_,i)=>i).filter(i=>i!==ground);
  const reduced=active.map(i=>active.map(j=>L[i][j]));
  const values=solve(reduced,active.map(i=>injections[i]));
  const v=Array(n).fill(0);active.forEach((node,i)=>v[node]=values[i]);
  const energy=edges.reduce((sum,[a,b],k)=>sum+weights[k]*(v[a]-v[b])**2,0);
  return {L,v,energy,balances:L.map(row=>row.reduce((sum,value,j)=>sum+value*v[j],0))};
}

const edges=[[0,1],[0,2],[1,2],[0,3],[1,3]];
console.log(groundedNetwork(4,edges,[1,1,1,1,1],3,[1.6,0,0,0]));

def solve(A,b):
    M=[row[:] + [b[i]] for i,row in enumerate(A)]
    n=len(A)
    for c in range(n):
        p=max(range(c,n),key=lambda r:abs(M[r][c])); M[c],M[p]=M[p],M[c]
        d=M[c][c]; M[c]=[value/d for value in M[c]]
        for r in range(n):
            if r!=c:
                f=M[r][c]; M[r]=[M[r][j]-f*M[c][j] for j in range(n+1)]
    return [row[n] for row in M]

def grounded_network(n,edges,weights,ground,injections):
    L=[[0]*n for _ in range(n)]
    for k,(a,b) in enumerate(edges):
        c=weights[k]; L[a][a]+=c; L[b][b]+=c; L[a][b]-=c; L[b][a]-=c
    active=[i for i in range(n) if i!=ground]
    reduced=[[L[i][j] for j in active] for i in active]
    values=solve(reduced,[injections[i] for i in active])
    v=[0]*n
    for i,node in enumerate(active): v[node]=values[i]
    energy=sum(weights[k]*(v[a]-v[b])**2 for k,(a,b) in enumerate(edges))
    balances=[sum(value*v[j] for j,value in enumerate(row)) for row in L]
    return {"L":L,"v":v,"energy":energy,"balances":balances}

edges=[(0,1),(0,2),(1,2),(0,3),(1,3)]
print(grounded_network(4,edges,[1,1,1,1,1],3,[1.6,0,0,0]))