# bit hard to provide a simple conversion without definitions of the
class 'Node', the template 'DirectedGraph' and the function 'Writed'!
# I've used the package 'igraph' as a drop in - hope it is still clear.
#
# by the way:
# - your curly braces don't match,
# - not all elements of P are initialised before they are used.
#------------------------------------
# original code (cleaned to make comparison easier).
#------------------------------------
#Random r = new Random();
#DirectedGraph<SimpleNode> graph = GetGraph();
#decimal B = 0.1m;
#decimal D = 0.05m;
#int nodes = graph.NodesCount;
#decimal[] E = new decimal[nodes];
#decimal[] P = new decimal[nodes];
#
#for (int i = 7; i <= 10; ++i) P[i] = (decimal)r.NextDouble();
#
#for (int t = 0; t < 100; ++t){
# Writed(P, "P");
#
# foreach (SimpleNode n in graph.Nodes) {
# int id = graph.index[n];
#
# decimal product = 1;
# foreach (var item in graph.GetAdjacentNodes(n)){
# int j = graph.index[item];
# product *= (1 - B * P[j]);
# }
#
# E[id] = product;
# }
#
# foreach (SimpleNode n in graph.Nodes){
# int i = graph.index[n];
# P[i] = 1 - ((1 - P[i]) * E[i] + D * (1 - P[i]) * E[i] + 0.5m
* D * P[i] * (1 - E[i]));
# if (P[i] < 0) P[i] = 0;
# }
#}
#
#}
#------------------------------------
# drop-in for your method getGraph (produces a 10 'random' node
directed graph). I only assign to temporary so I can use the same
'grph' and 'P' in both implementations.
#------------------------------------
library(igraph)
GetGraph <- function() graph.adjacency(matrix(sample(0:1, size=100,
replace=T), nrow=10))
grph.t <- GetGraph()
P.t <- runif(nodes) # assume you meant to initialise all elements of P
#------------------------------------
# IMPLEMENTATON 1.
# A 'mirror' implementation. Some of the code relies
# on the specifics of package igraph, but I've tried to
# be as similar as possible. Hope it still makes sense!
#------------------------------------
B <- 0.1
D <- 0.05
grph <- grph.t
nodes <- vcount(grph)
E <- numeric(nodes)
P <- P.t
for(t in 0:99){
cat('P:', P, '\n')# is this equivalent to 'Writed(P, "P")' ???
graph.Nodes <- get.adjlist(grph) # returns a list of vectors,
where each vector is the nodes a node is connected to.
id <- 0 # we loop over the vectors and so must index separately
for(n in graph.Nodes){ # n is a vector containing the verticies
the vertex at index id+1 is connected to.
id <- id+1
product <- 1;
for(item in n){
product <- product * (1 - B * P[item+1]); # verticies are
indexed from 0. no operator*= in R.
}
E[id] <- product;
}
at <- 0
for(i in 1:nodes){
P[i] <- 1 - ((1 - P[i]) * E[i] + D * (1 - P[i]) * E[i] + 0.5 *
D * P[i] * (1 - E[i])); # we are accessing nodes in order so the
indexes are also ordered.
if (P[i] < 0) P[i] <- 0;
}
}
P # print the result
#------------------------------------
# IMPLEMENTATION 2.
# a more 'R-ish' implementation.
#------------------------------------
B <- 0.1
D <- 0.05
P <- P.t
grph <- grph.t
for(t in 0:99){
E <- sapply(get.adjlist(grph), function(node) prod(1-B*P[node+1]))
P <- 1 - ((1 - P) * E + D * (1 - P) * E + 0.5 * D * P * (1 - E))
}
P # print the result
______________________________________________
R-help@r-project.org mailing list
https://stat.ethz.ch/mailman/listinfo/r-help
PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
and provide commented, minimal, self-contained, reproducible code.
