DouKaku?

import Jama._

def pagerank(data:Map[int, List[int]]):Array[double] = {
  val m = (1 to data.size).map(x=>Array.make(data.size, 0d)).toArray
  for(val i <- data) {
    for(val j <- i._2) {
      m(j-1)(i._1-1) = 1.toDouble / i._2.size
    }
  }

  val m2 = new Matrix((new Matrix(m)).eig.getV.getArray.map(x=>x(0)), data.size)
  val norm1 = m2.norm1
  m2.getArray.map(x => x(0) / norm1)
}
println(pagerank(Map(
  1 -> List(2,3,4,5,7),
  2 -> List(1),
  3 -> List(1,2),
  4 -> List(2,3,5),
  5 -> List(1,3,4,6),
  6 -> List(1,5),
  7 -> List(5)
)).mkString("{\n",",\n","\n}"))

(use srfi-1)
(use srfi-42)
(use gauche.uvector)
(use gauche.sequence)
(use c-wrapper)

(c-load '("gsl/gsl_eigen.h" "gsl/gsl_complex_math.h") :libs "-lgslcblas -lgsl")

(define (pagerank data)
  (let* ([dim (apply max (map car data))]
         [dvec (make-f64vector (* dim dim))])
    (do-ec (: r data) (: j (cdr r))
           (set! (ref dvec (+ (* (- j 1) dim) (- (car r) 1))) (/. (length (cdr r)))))
    (let ([eval (gsl_vector_complex_alloc dim)]
          [evec (gsl_matrix_complex_alloc dim dim)]
          [ws   (gsl_eigen_nonsymmv_alloc dim)]
          [mat  (gsl_matrix_view_array dvec dim dim)])
      (gsl_eigen_nonsymmv (ptr (ref mat 'matrix)) eval evec ws)
      (gsl_eigen_nonsymmv_free ws)
      (let* ([maxevi (find-max (iota dim)
                               :key (lambda (k)
                                      (gsl_complex_abs
                                       (gsl_vector_complex_get eval k))))]
             [ev (map-to <f64vector>
                         (lambda (k)
                           (gsl_complex_abs
                            (gsl_vector_complex_get
                             (ptr (ref (gsl_matrix_complex_column evec maxevi) 'vector))
                             k)))
                         (iota dim))])
        (gsl_vector_complex_free eval)
        (gsl_matrix_complex_free evec)
        (f64vector-div ev (f64vector-dot ev (make-f64vector dim 1.0)))))))

using System;
class Program
{
  static void Main()
  {
    string data = "2 3 4 5 7,1,1 2,2 3 5,1 3 4 6,1 5,5";
    double[] pageRank = Calc(data);
    foreach (double d in pageRank) Console.WriteLine("{0:F8}", d);
  }
  static double[] Calc(string data)
  {
    string[] ss = data.Split(',');
    double[,] m = new double[ss.Length, ss.Length];
    for (int i = 0; i < ss.Length; ++i)
    {
      string[] tt = ss[i].Split();
      for (int j = 0; j < tt.Length; ++j)
        m[int.Parse(tt[j]) - 1, i] = 1.0 / tt.Length;
    }
    double[] pageRank = new double[ss.Length];
    for (int i = 0; i < pageRank.Length; ++i) pageRank[i] = 1.0 / pageRank.Length;
    double df = 1;
    while (df > 1e-8)
    {
      double[] nxt = new double[ss.Length];
      for (int i = 0; i < ss.Length; ++i)
        for (int j = 0; j < ss.Length; ++j)
          nxt[i] += m[i, j] * pageRank[j];
      df = 0;
      for (int i = 0; i < ss.Length; ++i)
        df = Math.Max(df, Math.Abs(nxt[i] - pageRank[i]));
      pageRank = nxt;
    }
    return pageRank;
  }
}

require "matrix"
require "pp"

def map_to_mat( map )
  size = map.keys.length
  
  con_mat = Array.new( size ) {
    Array.new( size ) { 0.0 }
  }
  
  map.each {| key, val |
    length = val.length
    
    val.each {| i |
      con_mat[ key - 1 ][ i - 1 ] = 1.0 / length
    }
  }
  
  Matrix[*con_mat]
end

def eigen_values( mat, time = 100 )
  time.times {| i |
    mat *= mat
    
    mat_ary = mat.to_a
    mat_ary.map! {| row |
      sum = row.inject( 0.0 ) {| e, t | e + t }
      row.map! {| val | val / sum }
    }
    mat = Matrix[*mat_ary]
  }
  
  mat.to_a[0]
end

## 以下テスト

data = {
  1 => [2, 3, 4, 5, 7],
  2 => [1],
  3 => [1, 2],
  4 => [2, 3, 5],
  5 => [1, 3, 4, 6],
  6 => [1, 5],
  7 => [5],
}

matrix = map_to_mat( data )
pp matrix.to_a

pp eigen_values( matrix )

| data matrix pageRanks |
data := #((2 3 4 5 7) (1) (1 2) (2 3 5) (1 3 4 6) (1 5) (5)).
matrix := Matrix new: data size element: 0.

data keysAndValuesDo: [:page :refs |
    refs do: [:ref | matrix at: page at: ref put: 1 / refs size]].

pageRanks := [:mat |
    | prev delta |
    prev := mat.
    [   mat := (mat := mat +* mat) / mat sum asFloat.
        ((delta := prev - (prev := mat)) * delta) sum > 1e-12] whileTrue.
    (mat atRow: 1) / (mat atRow: 1) sum].

^pageRanks value: matrix

public class PageRank {
    private static final int MAX_REPEAT = 1000;

    public static void main(String[] argv) {
        int[][] data = {{ 2, 3, 4, 5, 7 }, 
                        { 1 }, 
                        { 1, 2 }, 
                        { 2, 3, 5 },
                        { 1, 3, 4, 6 }, 
                        { 1, 5 }, 
                        { 5 }};

        double[][] a = new double[data.length][];
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < data[i].length; j++) {
            a[data[i][j] - 1][i] = 1.0 / data[i].length;
            }
        }
        double[] eigVec = calcEigenVector(a);

        double sum = 0.0;
        for (int i = 0; i < eigVec.length; i++) sum += eigVec[i];
        for (int i = 0; i < eigVec.length; i++) System.out.println(eigVec[i] / sum);
    }

    /** べき乗法により、行列の固有ベクトルを求める。 */
    private static double[] calcEigenVector(double[][] mat) {
        final int n = mat.length;
        if(n != mat[0].length) throw new IllegalArgumentException("正方行列じゃないとダメだよ。");
        double eigVec[] = new double[n];
        eigVec[0] = 1.0;

        double eigVal = 1.0;
        
        for(int count=0; count < MAX_REPEAT; count++) {
            double[] newVec = new double[n];
            double df = 0;
            for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) newVec[i] += mat[i][j] * eigVec[j];
            df = Math.max(df, Math.abs(newVec[i] - eigVal * eigVec[i]));
            }
            if(df < 1.0e-8) return eigVec;
            
            double norm = 0;
            for (int i = 0; i < n; ++i) norm += newVec[i] * newVec[i];
            eigVal = Math.sqrt(norm);
            for (int i = 0; i < newVec.length; i++) eigVec[i] = newVec[i] / eigVal;
        }
        throw new ArithmeticException(MAX_REPEAT+"回やっても収束しませんでした。");
    }
}

from scipy import absolute
from scipy.linalg import eig, norm

def pagerank(data):
  n = len(data)
  l, v = eig([[1.0 / len(data[i]) if j in data[i] else 0 for i in range(1, n+1)] for j in range(1, n+1)])
  ev = v[:, (l == absolute(l).max()).nonzero()[0][0]]
  return ev / norm(ev, 1)

data = {
  1: [2, 3, 4, 5, 7],
  2: [1],
  3: [1, 2],
  4: [2, 3, 5],
  5: [1, 3, 4, 6],
  6: [1, 5],
  7: [5],
}

for x in pagerank(data): print float(x)

(function(data){ with(dojo.math.matrix){
  var size = 0, i, j, l;
  for(i in data) size++;
  var m = zeros(size, size), pr = create(1, size, 1 / size);
  for(i in data) for(j = l = data[i].length; j--;)
    m[data[i][j] - 1][i - 1] = 1 / l;
  for(var diff = 1, nx; diff > ALMOST_ZERO; pr = nx){
    nx = multiply(m, pr);
    for(diff = 0, j = size; j--;) diff += Math.abs(nx[j][0] - pr[j][0]);
  }
  (typeof WSH != 'undefined' ? function($){WSH.echo($)} : confirm)(format(pr));
}})({
 1: [2, 3, 4, 5, 7],
 2: [1],
 3: [1, 2],
 4: [2, 3, 5],
 5: [1, 3, 4, 6],
 6: [1, 5],
 7: [5]
});

require 'gsl'

data = {
  1 => [2, 3, 4, 5, 7],
  2 => [1],
  3 => [1, 2],
  4 => [2, 3, 5],
  5 => [1, 3, 4, 6],
  6 => [1, 5],
  7 => [5],
}

mat = GSL::Matrix.zeros(data.size)
data.each do |k, v|
  v.each do |j|
    mat[j-1, k-1] = 1.0 / v.size
  end
end

# 非対称行列の固有値計算はGSL-1.9以上が必要らしい
eigvals, eigvecs = mat.eigen_nonsymmv
eigvec = eigvecs.abs.get_col(eigvals.abs.max_index)

pagerank = (eigvec / eigvec.sum).to_a
puts pagerank