VisComms»Vis Comms

VisComms.VisComms History

Hide minor edits - Show changes to output

January 13, 2012, at 07:45 PM by PJM - removed unclosed parenthesis
Changed line 11 from:
This MATLAB code requires that your adjacency matrix (or matrix that shows the connections between people) is sparse.  To create a sparse matrix in MATLAB, take your matrix (suppose it's called "A"), type "sparse(A)".  This code also requires that you download the package from [[http://www.mathworks.com/matlabcentral/fileexchange/10922 | this website]].  (If you are using a Mac with 64-bit OS X (version 2009b or later), then instead download the package from [[http://dgleich.wordpress.com/2010/07/08/matlabbgl-osx-64-bit/ | this website]].
to:
This MATLAB code requires that your adjacency matrix (or matrix that shows the connections between people) is sparse.  To create a sparse matrix in MATLAB, take your matrix (suppose it's called "A"), type "sparse(A)".  This code also requires that you download the package from [[http://www.mathworks.com/matlabcentral/fileexchange/10922 | this website]].  If you are using a Mac with 64-bit OS X (version 2009b or later), then instead download the package from [[http://dgleich.wordpress.com/2010/07/08/matlabbgl-osx-64-bit/ | this website]].
Changed line 11 from:
This MATLAB code requires that your adjacency matrix (or matrix that shows the connections between people) is sparse.  To create a sparse matrix in MATLAB, take your matrix (suppose it's called "A"), type "sparse(A)".  This code also requires that you download the package from [[http://www.mathworks.com/matlabcentral/fileexchange/10922 | this website]].  (If you are using a Mac with 64-bit OS X, then instead download the package from [[http://dgleich.wordpress.com/2010/07/08/matlabbgl-osx-64-bit/ | this website]].
to:
This MATLAB code requires that your adjacency matrix (or matrix that shows the connections between people) is sparse.  To create a sparse matrix in MATLAB, take your matrix (suppose it's called "A"), type "sparse(A)".  This code also requires that you download the package from [[http://www.mathworks.com/matlabcentral/fileexchange/10922 | this website]].  (If you are using a Mac with 64-bit OS X (version 2009b or later), then instead download the package from [[http://dgleich.wordpress.com/2010/07/08/matlabbgl-osx-64-bit/ | this website]].
January 13, 2012, at 01:09 PM by Mason Lucas - refined instructions
Changed line 11 from:
This MATLAB code requires that your adjacency matrix (or matrix that shows the connections between people) is sparse.  To create a sparse matrix in MATLAB, take your matrix (suppose it's called "A"), type "sparse(A)".  This code also requires that you download the package from [[http://www.mathworks.com/matlabcentral/fileexchange/10922 | this website]].
to:
This MATLAB code requires that your adjacency matrix (or matrix that shows the connections between people) is sparse.  To create a sparse matrix in MATLAB, take your matrix (suppose it's called "A"), type "sparse(A)".  This code also requires that you download the package from [[http://www.mathworks.com/matlabcentral/fileexchange/10922 | this website]].  (If you are using a Mac with 64-bit OS X, then instead download the package from [[http://dgleich.wordpress.com/2010/07/08/matlabbgl-osx-64-bit/ | this website]].
October 25, 2011, at 03:22 PM by Amanda Traud - Adding drawForceCPie.m
Added lines 146-159:
-----
7. drawForceCPie (Draws pie charts for each community) [[(Attach:)drawForceCPie.m]]

*Inputs:
**A: the adjacency matrix
**XY: the community coordinates, the XY output of all of the above programs that take community structure into consideration.
**scores: Categorical data for each node, this is how the colors are chosen.
**gn: group numbers found in community detection

*Outputs:
**Plot of network, no other outputs.

*Calling this Function:
**drawForceCPie(A,XY,scores,gn)
Changed line 1 from:
The visualization code on this page is featured in Amanda L. Traud, Christina Frost, Peter J. Mucha, and Mason A. Porter. “Visualization of communities in networks.” Chaos: An Interdisciplinary Journal of Nonlinear Science 19, no. 4: 041104 (2009).
to:
The visualization code on this page is featured in "Visualization of communities in networks," Amanda L. Traud, Christina Frost, Peter J. Mucha, and Mason A. Porter, ''Chaos'' '''19''', 041104 (2009).
Changed lines 48-49 from:
 Graphs" while respecting individual communities.  It uses the Fruchterman-Reingold algorithm to place the nodes within each community.
to:
 Graphs" while respecting individual communities.  It uses the Fruchterman-Reingold
algorithm to place the nodes within each community.
Changed lines 67-69 from:
3. fruc_reinC (Fruchterman and Reingold placement of communities and then Fruchterman and Reingold placement of nodes within communities)  [[(Attach:)fruc_reinC.m]]

 This function uses the Fruchterman-Reingold Algorithm to find the optimal
to:
3. fruc_reinC (Fruchterman and Reingold placement of communities and then Fruchterman-Reingold placement of nodes within communities)  [[(Attach:)fruc_reinC.m]]

 This function uses the Fruchterman-Reingold algorithm to find the optimal
Changed lines 1-2 from:
The visualization code on this page is featured in
Amanda L. Traud, Christina Frost, Peter J. Mucha, and Mason A. Porter. “Visualization of communities in networks.” Chaos: An Interdisciplinary Journal of Nonlinear Science 19, no. 4: 041104 (2009).
to:
The visualization code on this page is featured in Amanda L. Traud, Christina Frost, Peter J. Mucha, and Mason A. Porter. “Visualization of communities in networks.” Chaos: An Interdisciplinary Journal of Nonlinear Science 19, no. 4: 041104 (2009).
Changed lines 1-5 from:
The visualization code on this page is featured in the following publication:

*[[(Attach:)nonlinear.pdf | One Page Paper for Chaos]] (preprint version)

*Its associated winning [[(Attach:)Poster.pdf | poster]] from the Gallery
of Nonlinear Image at the 2009 APS March Meeting
to:
The visualization code on this page is featured in
Amanda L. Traud, Christina Frost, Peter J. Mucha, and Mason A. Porter. “Visualization of communities in networks.” Chaos: An Interdisciplinary Journal of Nonlinear Science 19, no. 4: 041104 (2009).
*[[http://www.amath.unc.edu/Faculty/mucha/Reprints/ChaosVisComms.pdf|Article (pdf)]]
*The associated winning [[(Attach:)Poster.pdf|poster (pdf)]] from the Gallery of Nonlinear Images
at the 2009 APS March Meeting
Added lines 18-19:

-----
Changed lines 8-9 from:

to:
-----

Changed lines 17-18 from:
to:
Each of the programs below gives xy coordinates as one of the outputs; these can be put into the following program to produce the graphs that are featured in our Nonlinear Science Gallery poster and paper: [[(Attach:)graphplot2D.m]]
Added lines 42-43:
-----
Added lines 64-65:
-----
Added lines 87-88:
-----
Added lines 109-110:
-----
Added lines 127-128:
-----
Changed lines 145-146 from:

Each of these programs has xy coordinates as one of the outputs which can be put into the following program to produce the graphs that are featured in our Nonlinear Science Gallery poster and paper: [[(Attach:)graphplot2D.m]]
to:
-----
Changed lines 17-18 from:
#FRKK (Fruchterman-Reingold placement of communities, Kamada-Kawai placement of nodes within each community)  [[(Attach:)FRKK.m]]
to:
1. FRKK (Fruchterman-Reingold placement of communities, Kamada-Kawai placement of nodes within each community)  [[(Attach:)FRKK.m]]
Changed lines 40-41 from:
#KKFR (Kamada-Kawai placement of communities, Fruchterman-Reingold placement of nodes within communities)  [[(Attach:)KKFR.m]]
to:
2. KKFR (Kamada-Kawai placement of communities, Fruchterman-Reingold placement of nodes within communities)  [[(Attach:)KKFR.m]]
Changed lines 60-61 from:
#fruc_reinC (Fruchterman and Reingold placement of communities and then Fruchterman and Reingold placement of nodes within communities)  [[(Attach:)fruc_reinC.m]]
to:
3. fruc_reinC (Fruchterman and Reingold placement of communities and then Fruchterman and Reingold placement of nodes within communities)  [[(Attach:)fruc_reinC.m]]
Changed lines 81-82 from:
#KamadaC (Kamada-Kawai placement of communities and then Kamada-Kawai placement of nodes within communities)  [[(Attach:)KamadaC.m]]
to:
4. KamadaC (Kamada-Kawai placement of communities and then Kamada-Kawai placement of nodes within communities)  [[(Attach:)KamadaC.m]]
Changed lines 101-102 from:
#Kamada  (Kamada-Kawai placement of nodes, ignoring community structure) [[(Attach:)Kamada.m]]
to:
5. Kamada  (Kamada-Kawai placement of nodes, ignoring community structure) [[(Attach:)Kamada.m]]
Changed lines 117-118 from:
#fruc_rein (Fruchterman and Reingold placement of nodes, ignoring community structure) [[(Attach:)fruc_rein.m]]
to:
6. fruc_rein (Fruchterman and Reingold placement of nodes, ignoring community structure) [[(Attach:)fruc_rein.m]]
Changed lines 128-129 from:
**xy: the matrix of xy coordinates for each node in your network; the first column is the x coordinates and the second column is the y 
coordinates.
to:
**xy: the matrix of xy coordinates for each node in your network; the first column gives the x coordinates and the second column gives the y coordinates.
Changed lines 71-72 from:
**factor2: the number to multiply the node coordinates by within the community, if there are more than five nodes within a particular community it is helpful to normalize the coordinates and then multiply them by a factor to redistribute them.  4 tends to work in most cases but you may
want to change it based on your data.
to:
**factor2: the number to multiply the node coordinates by within the community, if there are more than five nodes within a particular community it is helpful to normalize the coordinates and then multiply them by a factor to redistribute them.  4 tends to work in most cases, but you may want to change it based on your data.
Changed lines 71-72 from:
**factor2: the number to multiply the node coordinates by within the community, if there are more than five nodes within a particular community
it is helpful to normalize the coordinates and then multiply them by a factor to redistribute them.  4 tends to work in most cases but you may
to:
**factor2: the number to multiply the node coordinates by within the community, if there are more than five nodes within a particular community it is helpful to normalize the coordinates and then multiply them by a factor to redistribute them.  4 tends to work in most cases but you may
Added line 35:
Added line 53:
Added line 56:
Added line 74:
Added line 79:
Added line 96:
Added line 99:
Added line 112:
Added line 115:
Added line 128:
Added line 132:
Changed line 12 from:
This MATLAB code requires that your adjacency matrix (or matrix that shows the connections between people) is sparse.  To create a sparse matrix in MATLAB, take your matrix (suppose it's called "A") "type sparse(A)".  This code also requires that you download the package from [[http://www.mathworks.com/matlabcentral/fileexchange/10922 | this website]].
to:
This MATLAB code requires that your adjacency matrix (or matrix that shows the connections between people) is sparse.  To create a sparse matrix in MATLAB, take your matrix (suppose it's called "A"), type "sparse(A)".  This code also requires that you download the package from [[http://www.mathworks.com/matlabcentral/fileexchange/10922 | this website]].
Changed lines 49-50 from:
**gn: a list of group numbers for identifying each node by the community in which they they belong. For example, if you have 20 nodes, gn should be a 20 x 1
matrix.  If node 5 is in the 2nd community, then at (5,1) the value is 2.  You may use any community detection program you see fit.
to:
**gn: a list of group numbers for identifying each node by the community in which they they belong. For example, if you have 20 nodes, gn should be a 20 x 1 matrix.  If node 5 is in the 2nd community, then at (5,1) the value is 2.  You may use any community detection program you see fit.
Changed lines 29-31 from:
**factor2: the number to multiply the node coordinates by within the community, if there are more than five nodes within a particular community it is helpful to normalize the coordinates and then multiply them by a factor to redistribute them.  4 tends to work in most cases, but you may
want to change it based on your data.
to:
**factor2: the number to multiply the node coordinates by within the community, if there are more than five nodes within a particular community it is helpful to normalize the coordinates and then multiply them by a factor to redistribute them.  4 tends to work in most cases, but you may want to change it based on your data.
Changed line 105 from:
**epsilon: the accuracy at which the algorithm acts, .01 works well.
to:
**epsilon: the accuracy at which the algorithm acts; .01 works well.
Changed lines 29-30 from:
**factor2: the number to multiply the node coordinates by within the community, if there are more than five nodes within a particular community
it is helpful to normalize the coordinates and then multiply them by a factor to redistribute them.  4 tends to work in most cases, but you may
to:
**factor2: the number to multiply the node coordinates by within the community, if there are more than five nodes within a particular community it is helpful to normalize the coordinates and then multiply them by a factor to redistribute them.  4 tends to work in most cases, but you may
Changed lines 51-58 from:
**gn: a list of group numbers for identifying each node by the community
 they belong in. For example, if you have 20 nodes, gn should be a 20 x 1
 matrix.  If node 5 is in the 2nd community, then at (5,1) the value is 2.
You may use any community detection program you see fit.
**epsilon: determines how precise you want to be in your node placement.
We suggest epsilon being .01
**seed: the seed for the random number generator for the initial
placement of the communities
to:
**gn: a list of group numbers for identifying each node by the community in which they they belong. For example, if you have 20 nodes, gn should be a 20 x 1
 matrix.  If node 5 is in the 2nd community, then at (5,1) the value is 2.  You may use any community detection program you see fit.
**epsilon: determines how precise you want to be in your node placement.  We suggest epsilon = .01.
**seed: the seed for the random number generator for the initial placement of the communities
Changed lines 67-78 from:
**gn: a vector of group numbers, i.e. every node that has the number 1
is in group 1.
**epsilon: the accuracy at which you would like the algorithm to act,
.01 tends to work well.
**seed: the number used in the random number generator for placing the
communities, any four digit number will work.
**factor1: the number to multiply the community coordinates by, 2 tends to
work well, but you may want the communities farther apart.
**factor2: the number to multiply the node coordinates by within the
community, if there are more than five nodes within a particular community
 it is helpful to normalize the coordinates and then multiply them by a
factor to redistribute them.  4 tends to work in most cases but you may
to:
**gn: a vector of group numbers, i.e. every node that has the number 1 is in group 1.
**epsilon: the accuracy at which you would like the algorithm to act; .01 tends to work well.
**seed: the number used in the random number generator for placing the communities, any four digit number will work.
**factor1: the number to multiply the community coordinates by, 2 tends to work well, but you may want the communities farther apart.
**factor2: the number to multiply the node coordinates by within the community, if there are more than five nodes within a particular community
 it is helpful to normalize the coordinates and then multiply them by a factor to redistribute them.  4 tends to work in most cases but you may
Changed lines 75-80 from:
**xynew: the vectors of the xy coordinates for each node in your network, this
is one of the inputs for graphplot2d.m
**XY: the vectors of xy coordinates for the communties, this is one of
the inputs for drawForceCPie.m
**xyc: the cellarray of xy coordinates for the nodes within each community
that are centered at zero.
to:
**xynew: the vectors of the xy coordinates for each node in your network, this is one of the inputs for graphplot2d.m
**XY: the vectors of xy coordinates for the communties, this is one of the inputs for drawForceCPie.m
**xyc: the cellarray of xy coordinates for the nodes within each community that are centered at zero.
Changed lines 91-96 from:
**gn: a list of group numbers for identifying each node by the community
they belong in. For example, if you have 20 nodes, gn should be a 20 x 1
 matrix.  If node 5 is in the 2nd community, then at (5,1) the value is 2.
You can use any community detection program you see fit.
**epsilon: determines how precise you want to be in your node placement.
We suggest epsilon = .01
to:
**gn: a list of group numbers for identifying each node by the community they belong in. For example, if you have 20 nodes, gn should be a 20 x 1
 matrix.  If node 5 is in the 2nd community, then at (5,1) the value is 2. You can use any community detection program you see fit.
**epsilon: determines how precise you want to be in your node placement.  We suggest epsilon = .01.
Changed lines 120-123 from:
**eps: is the accuracy at which the algorithm will act; .01 works well in
most cases.
**seed: the seed for the random number generator for initial placement of
the nodes.
to:
**eps: is the accuracy at which the algorithm will act; .01 works well in most cases.
**seed: the seed for the random number generator for initial placement of the nodes.
Changed lines 123-124 from:
**xy: the matrix of xy coordinates for each node in your network,
 the first column is the x coordinates and the second column is the y
to:
**xy: the matrix of xy coordinates for each node in your network; the first column is the x coordinates and the second column is the y
Changed lines 25-36 from:
**gn: a vector of group numbers, i.e. every node that has the number 1
is in group 1.
**epsilon: the accuracy at which you would like the algorithm to act,
.01 tends to work well.
**seed: the number used in the random number generator for placing the
communities, any four digit number will work.
**factor1: the number to multiply the community coordinates by, 2 tends to
work well, but you may want the communities farther apart.
**factor2: the number to multiply the node coordinates by within the
community, if there are more than five nodes within a particular community
 it is helpful to normalize the coordinates and then multiply them by a
factor to redistribute them.  4 tends to work in most cases but you may
to:
**gn: a vector of group numbers, i.e. every node that has the number 1 is in group 1.
**epsilon: the accuracy at which you would like the algorithm to act; .01 tends to work well.
**seed: the number used in the random number generator for placing the communities; any 4-digit number will work.
**factor1: the number to multiply the community coordinates by, 2 tends to work well, but you may want the communities farther apart.
**factor2: the number to multiply the node coordinates by within the community, if there are more than five nodes within a particular community
 it is helpful to normalize the coordinates and then multiply them by a factor to redistribute them.  4 tends to work in most cases, but you may
Changed lines 34-39 from:
**xynew: the vectors of the xy coordinates for each node in your network, this
is one of the inputs for graphplot2d.m
**XY: the vectors of xy coordinates for the communties, this is one of
the inputs for drawForceCPie.m
**xyc: the cellarray of xy coordinates for the nodes within each community
that are centered at zero.
to:
**xynew: the vectors of the xy coordinates for each node in your network, this is one of the inputs for graphplot2d.m
**XY: the vectors of xy coordinates for the communties, this is one of the inputs for drawForceCPie.m
**xyc: the cellarray of xy coordinates for the nodes within each community that are centered at zero.
Changed lines 23-27 from:
 *Inputs:

 **A: the adjacency matrix for the network

 
**gn: a vector of group numbers, i.e. every node that has the number 1
to:
*Inputs:
**A: the adjacency matrix for the network
**gn: a vector of group numbers, i.e. every node that has the number 1
Changed lines 27-28 from:

 
**epsilon: the accuracy at which you would like the algorithm to act,
to:
**epsilon: the accuracy at which you would like the algorithm to act,
Changed lines 29-30 from:

 
**seed: the number used in the random number generator for placing the
to:
**seed: the number used in the random number generator for placing the
Changed lines 31-32 from:

 
**factor1: the number to multiply the community coordinates by, 2 tends to
to:
**factor1: the number to multiply the community coordinates by, 2 tends to
Changed lines 33-34 from:

 
**factor2: the number to multiply the node coordinates by within the
to:
**factor2: the number to multiply the node coordinates by within the
Changed lines 39-41 from:
 *Outputs:

 
**xynew: the vectors of the xy coordinates for each node in your network, this
to:
*Outputs:
**xynew: the vectors of the xy coordinates for each node in your network, this
Changed lines 42-43 from:

 
**XY: the vectors of xy coordinates for the communties, this is one of
to:
**XY: the vectors of xy coordinates for the communties, this is one of
Changed lines 44-45 from:

 
**xyc: the cellarray of xy coordinates for the nodes within each community
to:
**xyc: the cellarray of xy coordinates for the nodes within each community
Changed lines 46-55 from:

 *Calling this Function (either of the commands below):

 **[xynew, XY, xyc]=FRKK(A,gn,epsilon)
       
 **[xynew, XY, xyc]=FRKK(A,gn,epsilon, seed, factor1,
factor2)



to:
*Calling this Function (either of the commands below):
**[xynew, XY, xyc]=FRKK(A,gn,epsilon)
**[xynew, XY, xyc]=FRKK(A,gn,epsilon, seed, factor1, factor2)
Changed lines 59-62 from:

 **A: the adjacency matrix for the network

 
**gn: a list of group numbers for identifying each node by the community
to:
**A: the adjacency matrix for the network
**gn: a list of group numbers for identifying each node by the community
Changed lines 64-65 from:

 
**epsilon: determines how precise you want to be in your node placement.
to:
**epsilon: determines how precise you want to be in your node placement.
Changed lines 66-67 from:

 
**seed: the seed for the random number generator for the initial
to:
**seed: the seed for the random number generator for the initial
Changed lines 68-70 from:

 *Outputs:
 
to:
*Outputs:
Changed lines 70-71 from:

 *Calling this function:
to:
*Calling this function:
**[xynew]=KKFR(A,gn,epsilon, seed)

#fruc_reinC (Fruchterman and Reingold placement of communities and then Fruchterman and Reingold placement of nodes within communities)  [[(Attach:)fruc_reinC.m]]

 This function uses the Fruchterman-Reingold Algorithm to find the optimal
 node placement for a given network with respect to Communities.
Deleted lines 77-86:
 
 **[xynew]=KKFR(A,gn,epsilon, seed)



#fruc_reinC (Fruchterman and Reingold placement of communities and then Fruchterman and Reingold placement of nodes within communities)  [[(Attach:)fruc_reinC.m]]

 This function uses the Fruchterman-Reingold Algorithm to find the optimal
 node placement for a given network with respect to Communities.
 
Changed lines 79-82 from:

 **A: the adjacency matrix for the network

 
**gn: a vector of group numbers, i.e. every node that has the number 1
to:
**A: the adjacency matrix for the network
**gn: a vector of group numbers, i.e. every node that has the number 1
Changed lines 82-83 from:

 
**epsilon: the accuracy at which you would like the algorithm to act,
to:
**epsilon: the accuracy at which you would like the algorithm to act,
Changed lines 84-85 from:

 
**seed: the number used in the random number generator for placing the
to:
**seed: the number used in the random number generator for placing the
Changed lines 86-87 from:

 
**factor1: the number to multiply the community coordinates by, 2 tends to
to:
**factor1: the number to multiply the community coordinates by, 2 tends to
Changed lines 88-89 from:

 
**factor2: the number to multiply the node coordinates by within the
to:
**factor2: the number to multiply the node coordinates by within the
Changed lines 93-96 from:

 *Outputs:

 
**xynew: the vectors of the xy coordinates for each node in your network, this
to:
*Outputs:
**xynew: the vectors of the xy coordinates for each node in your network, this
Changed lines 96-97 from:

 
**XY: the vectors of xy coordinates for the communties, this is one of
to:
**XY: the vectors of xy coordinates for the communties, this is one of
Changed lines 98-99 from:

 
**xyc: the cellarray of xy coordinates for the nodes within each community
to:
**xyc: the cellarray of xy coordinates for the nodes within each community
Changed lines 100-102 from:

 *Calling this Function:
 
to:
*Calling this Function:
Deleted lines 102-103:

Changed lines 112-115 from:

 **A: the adjacency matrix for the network

 
**gn: a list of group numbers for identifying each node by the community
to:
**A: the adjacency matrix for the network
**gn: a list of group numbers for identifying each node by the community
Changed lines 117-119 from:
 

 
**epsilon: determines how precise you want to be in your node placement.
to:
**epsilon: determines how precise you want to be in your node placement.
Changed lines 119-121 from:

 *Outputs:
 
to:
*Outputs:
Changed lines 121-128 from:

 *Calling this Function:


 **xy = KamadaC(A,maxgroups,.01)


to:
*Calling this Function:
**xy = KamadaC(A,maxgroups,.01)
Changed lines 130-144 from:
 *Inputs:

 **A:the adjacency matrix of your network

 **epsilon: the accuracy at which the algorithm acts, .01 works well.

 *Outputs:

 **xynew: the matrix of xy coordinates for each node.

 *Calling this Function:

 **xynew = Kamada(A,epsilon)

to:
*Inputs:
**A:the adjacency matrix of your network
**epsilon: the accuracy at which the algorithm acts, .01 works well.
*Outputs:
**xynew: the matrix of xy coordinates for each node.
*Calling this Function:
**xynew = Kamada(A,epsilon)
Changed lines 143-147 from:
 *Inputs:

 **A: the adjacency matrix for the network

 
**eps: is the accuracy at which the algorithm will act; .01 works well in
to:
*Inputs:
**A: the adjacency matrix for the network
**eps: is the accuracy at which the algorithm will act; .01 works well in
Changed lines 147-148 from:

 
**seed: the seed for the random number generator for initial placement of
to:
**seed: the seed for the random number generator for initial placement of
Changed lines 149-152 from:

 *Outputs:

 
**xy: the matrix of xy coordinates for each node in your network,
to:
*Outputs:
**xy: the matrix of xy coordinates for each node in your network,
Changed lines 153-156 from:

 *Calling this Function:

 
**[xy] = fruc_rein(A,eps, seed)
to:
*Calling this Function:
**[xy] = fruc_rein(A,eps, seed)
Changed lines 3-6 from:
[[(Attach:)nonlinear.pdf | One Page Paper for Chaos]] (preprint version)

Its associated winning [[(Attach:)Poster.pdf | poster]] from the Gallery of Nonlinear Image at the 2009 APS March Meeting
to:
*[[(Attach:)nonlinear.pdf | One Page Paper for Chaos]] (preprint version)

*Its associated winning [[(Attach:)Poster.pdf | poster]] from the Gallery of Nonlinear Image at the 2009 APS March Meeting
Deleted line 9:
Changed lines 12-20 from:
All of this code requires that your adjacency matrix(or matrix that shows the connections between people) be sparse.  To do this you can take your already created matrix A in Matlab and type sparse(A).  This code also requires that you download the package from this website:

http:
//www.mathworks.com/matlabcentral/fileexchange/10922

Typing help and then the name of each program below gives specific instructions on the inputs and outputs of each program, which are also shown below.


*
FRKK (Fruchterman-Reingold placement of communities, Kamada-Kawai placement of nodes within each community)  [[(Attach:)FRKK.m]]
to:
This MATLAB code requires that your adjacency matrix (or matrix that shows the connections between people) is sparse.  To create a sparse matrix in MATLAB, take your matrix (suppose it's called "A") "type sparse(A)".  This code also requires that you download the package from [[http://www.mathworks.com/matlabcentral/fileexchange/10922 | this website]].

Typing "help" and then the name of each program below gives specific instructions on the inputs and outputs of each program.  We also show these here:


#
FRKK (Fruchterman-Reingold placement of communities, Kamada-Kawai placement of nodes within each community)  [[(Attach:)FRKK.m]]
Changed lines 23-27 from:
 Inputs:

 A is the adjacency matrix for the network

 gn are a vector of group numbers, i.e. every node that has the number 1
to:
 *Inputs:

 **A: the adjacency matrix for the network

 **gn: a vector of group numbers, i.e. every node that has the number 1
Changed line 30 from:
 episilon is the accuracy at which you would like the algorithm to act,
to:
 **epsilon: the accuracy at which you would like the algorithm to act,
Changed line 33 from:
 seed is the number used in the random number generator for placing the
to:
 **seed: the number used in the random number generator for placing the
Changed line 36 from:
 factor1 is the number to multiply the community coordinates by, 2 tends to
to:
 **factor1: the number to multiply the community coordinates by, 2 tends to
Changed line 39 from:
 factor2 is the number to multiply the node coordinates by within the
to:
 **factor2: the number to multiply the node coordinates by within the
Changed lines 45-47 from:
 Outputs:

 xynew are the vectors of the xy coordinates for each node in your network, this
to:
 *Outputs:

 **xynew: the vectors of the xy coordinates for each node in your network, this
Changed line 50 from:
 XY are the vectors of xy coordinates for the communties, this is one of
to:
 **XY: the vectors of xy coordinates for the communties, this is one of
Changed line 53 from:
 xyc is the cellarray of xy coordinates for the nodes within each community
to:
 **xyc: the cellarray of xy coordinates for the nodes within each community
Changed lines 56-66 from:
 Calling this Function:

 [xynew, XY, xyc]=FRKK(A,gn,epsilon)
 
             or
 
[xynew, XY, xyc]=FRKK(A,gn,epsilon, seed, factor1, factor2)




*KKFR (Kamada-Kawai placement of communities, Fruchterman-Reingold placement of nodes within communities)  [[(Attach:)KKFR.m]]
to:
 *Calling this Function (either of the commands below):

 **[xynew, XY, xyc]=FRKK(A,gn,epsilon)
       
 **[xynew, XY, xyc]=FRKK(A,gn,epsilon, seed, factor1, factor2)




#KKFR (Kamada-Kawai placement of communities, Fruchterman-Reingold placement of nodes within communities)  [[(Attach:)KKFR.m]]
Changed lines 72-77 from:
 Inputs:

 A is the adjacency matrix for the network

 gn is a list of group numbers for identifying each node by the community
 they belong in. For example, if you have 20 nodes, gn should be a 20x1
to:
 
*
Inputs:

 **A: the adjacency matrix for the network

 **gn: a list of group numbers for identifying each node by the community
 they belong in. For example, if you have 20 nodes, gn should be a 20 x 1
Changed line 82 from:
 epsilon determines how precise you want to be in your node placement.
to:
 **epsilon: determines how precise you want to be in your node placement.
Changed line 85 from:
 seed is the seed for the random number generator for the initial
to:
 **seed: the seed for the random number generator for the initial
Changed lines 88-91 from:
 Outputs:
 xynew is the set of coordinates for each node, the first column is the x coordinates and the second column is the y-coordinates.

 Calling this function
:
to:
 *Outputs:
Added lines 90-92:
**xynew: the set of coordinates for each node, the first column is the x coordinates and the second column is the y-coordinates.

 *Calling this function:
Changed lines 94-99 from:
 [xynew]=KKFR(A,gn,epsilon, seed)



*fruc_reinC (Fruchterman and Reingold placement of communities and then Fruchterman and Reingold placement of nodes within communities)  [[(Attach:)fruc_reinC.m]]
to:
 
 **[xynew]=KKFR(A,gn,epsilon, seed)



#fruc_reinC (Fruchterman and Reingold placement of communities and then Fruchterman and Reingold placement of nodes within communities)  [[(Attach:)fruc_reinC.m]]
Changed lines 103-107 from:
 Inputs:

 A is the adjacency matrix for the network

 gn are a vector of group numbers, i.e. every node that has the number 1
to:
 
*
Inputs:

 **A: the adjacency matrix for the network

 **gn: a vector of group numbers, i.e. every node that has the number 1
Changed line 111 from:
 episilon is the accuracy at which you would like the algorithm to act,
to:
 **epsilon: the accuracy at which you would like the algorithm to act,
Changed line 114 from:
 seed is the number used in the random number generator for placing the
to:
 **seed: the number used in the random number generator for placing the
Changed line 117 from:
 factor1 is the number to multiply the community coordinates by, 2 tends to
to:
 **factor1: the number to multiply the community coordinates by, 2 tends to
Changed line 120 from:
 factor2 is the number to multiply the node coordinates by within the
to:
 **factor2: the number to multiply the node coordinates by within the
Changed lines 126-128 from:
 Outputs:

 xynew are the vectors of the xy coordinates for each node in your network, this
to:
 *Outputs:

 **xynew: the vectors of the xy coordinates for each node in your network, this
Changed line 131 from:
 XY are the vectors of xy coordinates for the communties, this is one of
to:
 **XY: the vectors of xy coordinates for the communties, this is one of
Changed line 134 from:
 xyc is the cellarray of xy coordinates for the nodes within each community
to:
 **xyc: the cellarray of xy coordinates for the nodes within each community
Changed lines 137-143 from:
 Calling this Function:
 [xynew, XY, xyc] = fruc_reinC(A, gn, epsilon, seed, factor1, factor2)



*KamadaC (Kamada-Kawai placement of communities and then Kamada-Kawai placement of nodes within communities)  [[(Attach:)KamadaC.m]]
to:
 *Calling this Function:
 
**[xynew, XY, xyc] = fruc_reinC(A, gn, epsilon, seed, factor1, factor2)



#KamadaC (Kamada-Kawai placement of communities and then Kamada-Kawai placement of nodes within communities)  [[(Attach:)KamadaC.m]]
Deleted lines 149-156:
 Inputs:

 A is the adjacency matrix for the network

 gn is a list of group numbers for identifying each node by the community
 they belong in. For example, if you have 20 nodes, gn should be a 20x1
 matrix.  If node 5 is in the 2nd community, then at (5,1) the value is 2.
 You can use any community detection program you see fit.
Changed lines 151-159 from:

 epsilon determines how precise you want to be in your node placement.
 We suggest epsilon being .01

 Outputs:
 xynew this is the list of xy coordinates for each node in your network.

 Calling this Function:

to:
*Inputs:

 **A: the adjacency matrix for the network

 **gn: a list of group numbers for identifying each node by the community
 they belong in. For example, if you have 20 nodes, gn should be a 20 x 1
 matrix.  If node 5 is in the 2nd community, then at (5,1) the value is 2.
 You can use any community detection program you see fit.
Changed lines 160-165 from:
 xy = KamadaC(A,maxgroups,.01)



*Kamada  (Kamada-Kawai placement of nodes, ignoring community structure) [[(Attach:)Kamada.m]]
to:

 **epsilon: determines how precise you want to be in your node placement. 
 We suggest epsilon = .
01

 
*Outputs:
 
**xynew: is the list of xy coordinates for each node in your network.

 *Calling this Function:

 
 **xy = KamadaC(A,maxgroups,.01)



#
Kamada  (Kamada-Kawai placement of nodes, ignoring community structure) [[(Attach:)Kamada.m]]
Changed lines 181-197 from:
 Inputs:

 A is the adjacency matrix of your network

 epsilon is the accuracy at which the algorithm acts, .01 works well.

 Outputs:

 xynew is the matrix of xy coordinates for each node.

 Calling this Function:

 xynew = Kamada(A,epsilon)


*fruc_rein (Fruchterman and Reingold placement of nodes, ignoring community structure) [[(Attach:)fruc_rein.m]]
to:
 *Inputs:

 **A:the adjacency matrix of your network

 **epsilon: the accuracy at which the algorithm acts, .01 works well.

 *Outputs:

 **xynew: the matrix of xy coordinates for each node.

 *Calling this Function:

 **xynew = Kamada(A,epsilon)


#fruc_rein (Fruchterman and Reingold placement of nodes, ignoring community structure) [[(Attach:)fruc_rein.m]]
Changed lines 201-205 from:
 Inputs:

 A is the adjacency matrix for the network

 eps is the accuracy at which the algorithm will act, .01 works well in
to:
 *Inputs:

 **A: the adjacency matrix for the network

 **eps: is the accuracy at which the algorithm will act; .01 works well in
Changed line 208 from:
 seed is the seed for the random number generator for initial placement of
to:
 **seed: the seed for the random number generator for initial placement of
Changed lines 211-213 from:
 Outputs:

 xy is the matrix of xy coordinates for each node in your network,
to:
 *Outputs:

 **xy: the matrix of xy coordinates for each node in your network,
Changed lines 217-223 from:
 Calling this Function:

 [xy] = fruc_rein(A,eps, seed)


Each of these programs has xy coordinates as one of the outputs which can be put into the below program to produce the graphs that are featured in the above article:
[[(Attach:)graphplot2D.m]]
to:
 *Calling this Function:

 **[xy] = fruc_rein(A,eps, seed)


Each of these programs has xy coordinates as one of the outputs which can be put into the following program to produce the graphs that are featured in our Nonlinear Science Gallery poster and paper: [[(Attach:)graphplot2D.m]]
Changed lines 3-5 from:
 [[(Attach:)nonlinear.pdf | One Page Paper for Chaos]] (preprint version) and its associated winning [[(Attach:)Poster.pdf | poster]] from the Gallery of Nonlinear Image at the 2009 APS March Meeting
to:
[[(Attach:)nonlinear.pdf | One Page Paper for Chaos]] (preprint version)

Its
associated winning [[(Attach:)Poster.pdf | poster]] from the Gallery of Nonlinear Image at the 2009 APS March Meeting
Changed lines 1-8 from:
This is the page for the Visualization Code Featured in the below publications:

Gallery of Nonlinear Images Winner
[[(Attach:)Poster.pdf]]


One Page Paper for
Chaos
[[(Attach:)nonlinear.pdf]]
to:
The visualization code on this page is featured in the following publication:

 [[(Attach:)nonlinear.pdf | One Page Paper for Chaos]] (preprint version) and its associated winning [[(Attach:)Poster.pdf | poster]] from the Gallery of Nonlinear Image at the 2009 APS March Meeting

-----

October 23, 2009, at 08:42 AM by 72.150.154.229 -
Changed lines 223-230 from:
'''References'''
to:
'''References'''

Tomihisa Kamada, Satoru Kawai.: An Algorithm for Drawing General Undirected Graphs.
Information Processing Letters, 31:7-15, 1988.

Fruchtermann, T.M.J., Reingold, E.M.: Graph drawing by force-directed placement.
Software, Practice and Experience 21:1129-1164, 1991.

October 23, 2009, at 08:37 AM by 72.150.154.229 -
Changed lines 82-85 from:
 The community detection program LeadEigs.m spits out the gn as maxgroups. 
 This can be found on the Kamada-Kawai page at
 http://netwiki.amath.unc.edu/Code/Kamada-Kawai 

to:
 You may use any community detection program you see fit.
Changed lines 95-96 from:
 After running LeadEigs.m on your symmetric sparse matrix, the proper
 prompt to run this program is the following:
to:
 
Changed line 205 from:
 seed is the seed for the random number generator for intial placement of
to:
 seed is the seed for the random number generator for initial placement of
Changed line 223 from:
'''References''
to:
'''References'''
October 23, 2009, at 08:36 AM by 72.150.154.229 -
Changed lines 20-21 from:
*FRKK (Fruchterman and Reingold placement of communities, Kamada Kawaii placement of nodes within each community)  [[(Attach:)FRKK.m]]
to:
*FRKK (Fruchterman-Reingold placement of communities, Kamada-Kawai placement of nodes within each community)  [[(Attach:)FRKK.m]]
Changed lines 24-25 from:
 uses the Kamada Kawai algorithm to place the nodes within each community.
to:
 uses the Kamada-Kawai algorithm to place the nodes within each community.
Changed lines 68-69 from:
*KKFR (Kamada Kawaii placement of communities, Fruchterman and Reingold placement of nodes within communities)  [[(Attach:)KKFR.m]]
to:
*KKFR (Kamada-Kawai placement of communities, Fruchterman-Reingold placement of nodes within communities)  [[(Attach:)KKFR.m]]
Changed lines 72-74 from:
 Graphs" while respecting individual communities.  It uses the Fructerman
 and
Reingold algorithm to place the nodes within each community.
to:
 Graphs" while respecting individual communities.  It uses the Fruchterman-Reingold algorithm to place the nodes within each community.
Changed lines 145-146 from:
*KamadaC (Kamada Kawaii placement of communities and then Kamada Kawaii placement of nodes within communities)  [[(Attach:)KamadaC.m]]
to:
*KamadaC (Kamada-Kawai placement of communities and then Kamada-Kawai placement of nodes within communities)  [[(Attach:)KamadaC.m]]
Changed line 151 from:
 This code outputs the xy coordinants for the nodes of a given network
to:
 This code outputs the xy coordinates for the nodes of a given network
Changed lines 159-162 from:
 The community detection program LeadEigs.m spits out the gn as maxgroups.
 This can be found on the Kamada-Kaawai page at
 http://netwiki.amath.unc.edu/Code/Kamada-Kawai

to:
 You can use any community detection program you see fit.
 
Changed lines 170-171 from:
 After running LeadEigs.m on your symmetric sparse matrix, the proper
 prompt to run this program is the following:
to:
 
Changed lines 175-176 from:
*Kamada  (Kamada Kawaii placement of nodes, ignoring community structure) [[(Attach:)Kamada.m]]
to:
*Kamada  (Kamada-Kawai placement of nodes, ignoring community structure) [[(Attach:)Kamada.m]]
Changed lines 223-226 from:
[[(Attach:)graphplot2D.m]]
to:
[[(Attach:)graphplot2D.m]]


'''References''
September 14, 2009, at 01:39 PM by 152.23.118.196 -
Changed lines 204-205 from:
Inputs:
to:
 Inputs:
Changed line 208 from:
 eps is the accuracy at which the algorith will act, .01 works well in
to:
 eps is the accuracy at which the algorithm will act, .01 works well in
September 14, 2009, at 01:37 PM by 152.23.118.196 -
Changed lines 180-198 from:
to:
 This code follows the algorithm in the article written by Tomihisa Kamada
 and Satoru Kawai entitled "An Algorithm For Drawing General Undirected
 Graphs."

 Inputs:

 A is the adjacency matrix of your network

 epsilon is the accuracy at which the algorithm acts, .01 works well.

 Outputs:

 xynew is the matrix of xy coordinates for each node.

 Calling this Function:

 xynew = Kamada(A,epsilon)

Added lines 201-222:
 This function uses the Fruchterman-Reingold Algorithm to find the optimal
 node placement for a given network.

Inputs:

 A is the adjacency matrix for the network

 eps is the accuracy at which the algorith will act, .01 works well in
 most cases.

 seed is the seed for the random number generator for intial placement of
 the nodes.

 Outputs:

 xy is the matrix of xy coordinates for each node in your network,
 the first column is the x coordinates and the second column is the y
 coordinates.

 Calling this Function:

 [xy] = fruc_rein(A,eps, seed)
September 14, 2009, at 01:35 PM by 152.23.118.196 -
Added lines 147-177:

 This code follows the algorithm in the article written by Tomihisa Kamada
 and Satoru Kawai entitled "An Algorithm For Drawing General Undirected
 Graphs" while respecting individual communities.

 This code outputs the xy coordinants for the nodes of a given network
 Inputs:

 A is the adjacency matrix for the network

 gn is a list of group numbers for identifying each node by the community
 they belong in. For example, if you have 20 nodes, gn should be a 20x1
 matrix.  If node 5 is in the 2nd community, then at (5,1) the value is 2.
 The community detection program LeadEigs.m spits out the gn as maxgroups.
 This can be found on the Kamada-Kaawai page at
 http://netwiki.amath.unc.edu/Code/Kamada-Kawai 

 epsilon determines how precise you want to be in your node placement.
 We suggest epsilon being .01

 Outputs:
 xynew this is the list of xy coordinates for each node in your network.

 Calling this Function:

 After running LeadEigs.m on your symmetric sparse matrix, the proper
 prompt to run this program is the following:
 xy = KamadaC(A,maxgroups,.01)


Added lines 179-180:

Added lines 182-183:

September 14, 2009, at 01:32 PM by 152.23.118.196 -
Changed lines 39-52 from:
factor1 is the number to multiply the community coordinates by, 2 tends to
work well, but you may want the communities farther apart.

factor2 is the number to multiply the node coordinates by within the
community, if there are more than five nodes within a particular community
it is helpful to normalize the coordinates and then multiply them by a
factor to redistribute them.  4 tends to work in most cases but you may
want to change it based on your data.

Outputs:

xynew are the vectors of the xy coordinates for each node in your network, this
is one of the inputs for graphplot2d.m
to:
 factor1 is the number to multiply the community coordinates by, 2 tends to
 work well, but you may want the communities farther apart.

 factor2 is the number to multiply the node coordinates by within the
 community, if there are more than five nodes within a particular community
 it is helpful to normalize the coordinates and then multiply them by a
 factor to redistribute them.  4 tends to work in most cases but you may
 want to change it based on your data.

 Outputs:

 xynew are the vectors of the xy coordinates for each node in your network, this
 is one of the inputs for graphplot2d.m
Changed lines 56-61 from:
xyc is the cellarray of xy coordinates for the nodes within each community
that are centered at zero.

Calling this Function:

[xynew, XY, xyc]=FRKK(A,gn,epsilon)
to:
 xyc is the cellarray of xy coordinates for the nodes within each community
 that are centered at zero.

 Calling this Function:

 [xynew, XY, xyc]=FRKK(A,gn,epsilon)
Changed lines 63-67 from:
[xynew, XY, xyc]=FRKK(A,gn,epsilon, seed, factor1, factor2)



to:
 [xynew, XY, xyc]=FRKK(A,gn,epsilon, seed, factor1, factor2)



Changed lines 70-95 from:
This code follows the algorithm in the article written by Tomihisa Kamada
and Satoru Kawai entitled "An Algorithm For Drawing General Undirected
Graphs" while respecting individual communities.  It uses the Fructerman
and Reingold algorithm to place the nodes within each community.

This code outputs the xy coordinates for the nodes of a given network
Inputs:

A is the adjacency matrix for the network

gn is a list of group numbers for identifying each node by the community
they belong in. For example, if you have 20 nodes, gn should be a 20x1
matrix.  If node 5 is in the 2nd community, then at (5,1) the value is 2.
The community detection program LeadEigs.m spits out the gn as maxgroups. This can be found on the Kamada-Kawai page at
http://netwiki.amath.unc.edu/Code/Kamada-Kawai 

epsilon determines how precise you want to be in your node placement.
We suggest epsilon being .01

seed is the seed for the random number generator for the initial
placement of the communities

Outputs:
xynew is the set of coordinates for each node, the first column is the x coordinates and the second column is the y coordinates.

Calling this function:
to:
 This code follows the algorithm in the article written by Tomihisa Kamada
 and Satoru Kawai entitled "An Algorithm For Drawing General Undirected
 Graphs" while respecting individual communities.  It uses the Fructerman
 and Reingold algorithm to place the nodes within each community.

 This code outputs the xy coordinates for the nodes of a given network
 Inputs:

 A is the adjacency matrix for the network

 gn is a list of group numbers for identifying each node by the community
 they belong in. For example, if you have 20 nodes, gn should be a 20x1
 matrix.  If node 5 is in the 2nd community, then at (5,1) the value is 2.
 The community detection program LeadEigs.m spits out the gn as maxgroups.
 
This can be found on the Kamada-Kawai page at
 http://netwiki.amath.unc.edu/Code/Kamada-Kawai 

 epsilon determines how precise you want to be in your node placement.
 We suggest epsilon being .01

 seed is the seed for the random number generator for the initial
 placement of the communities

 Outputs:
 xynew is the set of coordinates for each node, the first column is the x coordinates and the second column is the y-coordinates.

 Calling this function:
Changed lines 98-103 from:
After running LeadEigs.m on your symmetric sparse matrix, the proper
prompt to run this program is the following:
[xynew]=KKFR(A,gn,epsilon, seed)


to:
 After running LeadEigs.m on your symmetric sparse matrix, the proper
 prompt to run this program is the following:
 [xynew]=KKFR(A,gn,epsilon, seed)


Added lines 105-145:

 This function uses the Fruchterman-Reingold Algorithm to find the optimal
 node placement for a given network with respect to Communities.
 Inputs:

 A is the adjacency matrix for the network

 gn are a vector of group numbers, i.e. every node that has the number 1
 is in group 1.

 episilon is the accuracy at which you would like the algorithm to act,
 .01 tends to work well.

 seed is the number used in the random number generator for placing the
 communities, any four digit number will work.

 factor1 is the number to multiply the community coordinates by, 2 tends to
 work well, but you may want the communities farther apart.

 factor2 is the number to multiply the node coordinates by within the
 community, if there are more than five nodes within a particular community
 it is helpful to normalize the coordinates and then multiply them by a
 factor to redistribute them.  4 tends to work in most cases but you may
 want to change it based on your data.

 Outputs:

 xynew are the vectors of the xy coordinates for each node in your network, this
 is one of the inputs for graphplot2d.m

 XY are the vectors of xy coordinates for the communties, this is one of
 the inputs for drawForceCPie.m

 xyc is the cellarray of xy coordinates for the nodes within each community
 that are centered at zero.

 Calling this Function:
 [xynew, XY, xyc] = fruc_reinC(A, gn, epsilon, seed, factor1, factor2)


September 14, 2009, at 01:27 PM by 152.23.118.196 -
Changed lines 22-25 from:



to:
 This function uses the Fruchterman-Reingold Algorithm to find the optimal
 node placement for a given network with respect to Communities.  But then
 uses the Kamada Kawai algorithm to place the nodes within each community.

 Inputs:

 A is the adjacency matrix for the network

 gn are a vector of group numbers, i.e. every node that has the number 1
 is in group 1.

 episilon is the accuracy at which you would like the algorithm to act,
 .01 tends to work well.

 seed is the number used in the random number generator for placing the
 communities, any four digit number will work.

factor1 is the number to multiply the community coordinates by, 2 tends to
work well, but you may want the communities farther apart.

factor2 is the number to multiply the node coordinates by within the
community, if there are more than five nodes within a particular community
it is helpful to normalize the coordinates and then multiply them by a
factor to redistribute them.  4 tends to work in most cases but you may
want to change it based on your data.

Outputs:

xynew are the vectors of the xy coordinates for each node in your network, this
is one of the inputs for graphplot2d.m

 XY are the vectors of xy coordinates for the communties, this is one of
 the inputs for drawForceCPie.m

xyc is the cellarray of xy coordinates for the nodes within each community
that are centered at zero.

Calling this Function:

[xynew, XY, xyc]=FRKK(A,gn,epsilon)
              or
[xynew, XY, xyc]=FRKK(A,gn,epsilon, seed, factor1, factor2)




Added lines 69-102:

This code follows the algorithm in the article written by Tomihisa Kamada
and Satoru Kawai entitled "An Algorithm For Drawing General Undirected
Graphs" while respecting individual communities.  It uses the Fructerman
and Reingold algorithm to place the nodes within each community.

This code outputs the xy coordinates for the nodes of a given network
Inputs:

A is the adjacency matrix for the network

gn is a list of group numbers for identifying each node by the community
they belong in. For example, if you have 20 nodes, gn should be a 20x1
matrix.  If node 5 is in the 2nd community, then at (5,1) the value is 2.
The community detection program LeadEigs.m spits out the gn as maxgroups. This can be found on the Kamada-Kawai page at
http://netwiki.amath.unc.edu/Code/Kamada-Kawai 

epsilon determines how precise you want to be in your node placement.
We suggest epsilon being .01

seed is the seed for the random number generator for the initial
placement of the communities

Outputs:
xynew is the set of coordinates for each node, the first column is the x coordinates and the second column is the y coordinates.

Calling this function:
 
After running LeadEigs.m on your symmetric sparse matrix, the proper
prompt to run this program is the following:
[xynew]=KKFR(A,gn,epsilon, seed)


September 14, 2009, at 01:20 PM by 152.23.118.196 -
Changed lines 13-14 from:
All of this code requires that your adjacency matrix be sparse, and that you download the package from this website:
to:
All of this code requires that your adjacency matrix(or matrix that shows the connections between people) be sparse.  To do this you can take your already created matrix A in Matlab and type sparse(A).  This code also requires that you download the package from this website:
Changed lines 17-19 from:
Typing help and then the name of the program gives specific instructions on the inputs and outputs of each program.

to:
Typing help and then the name of each program below gives specific instructions on the inputs and outputs of each program, which are also shown below.

Added lines 21-25:




July 02, 2009, at 11:24 AM by 152.23.62.61 -
Added lines 16-17:

Typing help and then the name of the program gives specific instructions on the inputs and outputs of each program.
July 02, 2009, at 11:20 AM by 152.23.62.61 -
Changed lines 23-26 from:
*fruc_rein (Fruchterman and Reingold placement of nodes, ignoring community structure) [[(Attach:)fruc_rein.m]]
to:
*fruc_rein (Fruchterman and Reingold placement of nodes, ignoring community structure) [[(Attach:)fruc_rein.m]]

Each of these programs has xy coordinates as one of the outputs which can be put into the below program to produce the graphs that are featured in the above article:
[[(Attach:)graphplot2D
.m]]
July 02, 2009, at 11:17 AM by 152.23.62.61 -
Changed line 11 from:
+'''Code'''+
to:
'''[+Code+]'''
July 02, 2009, at 11:13 AM by 152.23.62.61 -
Changed lines 18-19 from:
*FRKK (Fruchterman and Reingold placement of communities, Kamada Kawaii placement of nodes within each community)
[[(Attach:)FRKK.m]]
to:
*FRKK (Fruchterman and Reingold placement of communities, Kamada Kawaii placement of nodes within each community)  [[(Attach:)FRKK.m]]
Changed line 21 from:
*KamadaC (Kamada Kawaii placement of communities and then Kamada Kawaii placement of nodes within communities)  [(Attach:)KamadaC.m]]
to:
*KamadaC (Kamada Kawaii placement of communities and then Kamada Kawaii placement of nodes within communities)  [[(Attach:)KamadaC.m]]
July 02, 2009, at 11:11 AM by 152.23.62.61 -
Changed lines 11-12 from:
'''Code'''
to:
+'''Code'''+
Deleted line 17:
Changed lines 19-24 from:
[[(Attach:)FRKK.m]]
to:
[[(Attach:)FRKK.m]]
*KKFR (Kamada Kawaii placement of communities, Fruchterman and Reingold placement of nodes within communities)  [[(Attach:)KKFR.m]]
*fruc_reinC (Fruchterman and Reingold placement of communities and then Fruchterman and Reingold placement of nodes within communities)  [[(Attach:)fruc_reinC.m]]
*KamadaC (Kamada Kawaii placement of communities and then Kamada Kawaii placement of nodes within communities)  [(Attach:)KamadaC.m]]
*Kamada  (Kamada Kawaii placement of nodes, ignoring community structure) [[(Attach:)Kamada.m]]
*fruc_rein (Fruchterman and Reingold placement of nodes, ignoring community structure) [[(Attach:)fruc_rein
.m]]
July 02, 2009, at 11:00 AM by 152.23.62.61 -
Changed lines 11-12 from:
''Code
to:
'''Code'''
Changed line 19 from:
'''FRKK (Fruchterman and Reingold placement of communities, Kamada Kawaii placement of nodes within each community)
to:
*FRKK (Fruchterman and Reingold placement of communities, Kamada Kawaii placement of nodes within each community)
July 02, 2009, at 10:58 AM by 152.23.62.61 -
Changed lines 1-2 from:
This is the page at which the visualization code will eventually be!
to:
This is the page for the Visualization Code Featured in the below publications:
Changed lines 8-20 from:
[[(Attach:)nonlinear.pdf]]
to:
[[(Attach:)nonlinear.pdf]]


''Code

All of this code requires that your adjacency matrix be sparse, and that you download the package from this website:

http://www.mathworks.com/matlabcentral/fileexchange/10922



'''FRKK (Fruchterman and Reingold placement of communities, Kamada Kawaii placement of nodes within each community)
[[(Attach:)FRKK.m
]]
July 01, 2009, at 11:06 AM by 152.23.62.61 -
Changed lines 1-8 from:
This is the page at which the visualization code will eventually be!
to:
This is the page at which the visualization code will eventually be!

Gallery of Nonlinear Images Winner
[[(Attach:)Poster.pdf]]


One Page Paper for Chaos
[[(Attach:)nonlinear.pdf]]
June 29, 2009, at 01:33 PM by 152.23.48.190 -
Added line 1:
This is the page at which the visualization code will eventually be!