CustomNode.java.wp - Revision history

Seoc at 22:41, 22 June 2006

2006-06-22T22:41:55Z

← Older revision		Revision as of 22:41, 22 June 2006
Line 7:		Line 7:
	* Modified on June 18, 2006, 13:55 by Jack		* Modified on June 18, 2006, 13:55 by Jack
	* Modified June 22, 2006 00:16 by Andrew		* Modified June 22, 2006 00:16 by Andrew
			* Modified June 22, 2006 16:40 by Jack
	*		*
	* This class contains the parameters and methods		* This class contains the parameters and methods
Line 46:		Line 47:
	// 0 = democratic		// 0 = democratic
	// 1 = meritocratic		// 1 = meritocratic
	public static int voteType;		// public static int voteType;

			// intVoteValue, the intrinsic value of an agent's vote
			// vote weight = intVoteValue + (1-intVoteValue)*reputation
			// now have continuous scale between democratic and meritocratic,
			// and also avoid divide by zero for zero rep agents voting.
			// 1 = democratic
			// 0 = complete meritocratic
			public static double intVoteValue;

	// the degree by which the historical opinion is weighted		// the degree by which the historical opinion is weighted
Line 145:		Line 154:
	}		}

	///////////////////////////////////////////////////////

			///////////////////////////////////////////////////////
			// formOpinion
			// Input: double success, the focus' real skill
			// Output: double vote, the voter's estimate of focus' skill
			public double formOpinion(double fSkill, double prevOp, double fRep){
			double op = fSkill + model.getNormalDouble(0, getNoiseFromSkill(this.skill));
			op = histWeightprevOp + repWeightfRep + (1 - histWeight- repWeight)*op;
			return op;
			}
			// it should /really/ be (arguably, of course):
			// opinion = (1 - weight) * (focus' real skill + noise)
			// + weight * [opinion-weighted average of common nbrs opinions of focus]

			/*
			///////////////////////////////////////////////////////
	// formOpinion		// formOpinion
	// Input: double success, the focus' real skill		// Input: double success, the focus' real skill
Line 167:		Line 192:
	}		}

	~~// it should /really/ be (arguably, of course):~~
	~~// opinion = (1 - weight)~~ * ~~(focus' real skill + noise)~~		*/
	/~~/ + weight * [opinion-weighted average of common nbrs opinions of focus]~~

	////////////////////////////////////////////////////////		////////////////////////////////////////////////////////
	// voteAll		// voteAll
Line 180:		Line 203:
	CustomEdge edge = (CustomEdge) edgeList.get(i);		CustomEdge edge = (CustomEdge) edgeList.get(i);
	CustomNode node = (CustomNode) edge.getTo();		CustomNode node = (CustomNode) edge.getTo();
	opinion = formOpinion(node.getSkill(), edge.getOpinion());		opinion = formOpinion(node.getSkill(), edge.getOpinion(), node.getReputation());
	edge.setOpinion(opinion);		edge.setOpinion(opinion);
	if (opinion > 0.5)		if (opinion > 0.5)
Line 191:		Line 214:

	// new voteAll		// new voteAll
			/*
	public void voteAll2(){		public void voteAll2(){
	ArrayList edgeList = this.getOutEdges();		ArrayList edgeList = this.getOutEdges();
Line 207:		Line 231:
	edge.setVote(opinion); // Java lines get semicolons, dipshit.		edge.setVote(opinion); // Java lines get semicolons, dipshit.
	}		}
	}		}*/

	////////////////////////////////////////////////////////		////////////////////////////////////////////////////////
Line 220:		Line 244:
	CustomEdge edge = (CustomEdge) edgeList.get(i);		CustomEdge edge = (CustomEdge) edgeList.get(i);
	CustomNode node = (CustomNode) edge.getFrom();		CustomNode node = (CustomNode) edge.getFrom();
			repSum += edge.getVote() (intVoteValue + (1-intVoteValue)node.getReputation());
			normSum += (intVoteValue + (1-intVoteValue)*node.getReputation());
			/*
	if (voteType ==0){		if (voteType ==0){
	repSum += edge.getVote();		repSum += edge.getVote();
Line 227:		Line 254:
	repSum += edge.getVote() * node.getReputation();		repSum += edge.getVote() * node.getReputation();
	normSum += node.getReputation();		normSum += node.getReputation();
	}		}*/
	}		}
	reputation = repSum/normSum;		reputation = repSum/normSum;
Line 291:		Line 318:


	public static int getVoteType() {return voteType;}		//public static int getVoteType() {return voteType;}
	public static void setVoteType(int i) {voteType = i;}		//public static void setVoteType(int i) {voteType = i;}

			public static double getIntVoteValue() {return intVoteValue;}
			public static void setIntVoteValue(double i) {intVoteValue = i;}

	public static double getHistWeight() {return histWeight;}		public static double getHistWeight() {return histWeight;}
Line 303:		Line 333:
	public static void setNoiseSlope(double i) {noiseSlope = i;}		public static void setNoiseSlope(double i) {noiseSlope = i;}
	}		}

	</pre>		</pre>

AndrewStout at 06:18, 22 June 2006

2006-06-22T06:18:08Z

@@ Line 6: / Line 6: @@
   * Created on January 22, 2005, 2:41 PM
   * Modified on June 18, 2006, 13:55 by Jack
+  *
   * This class contains the parameters and methods
@@ Line 48: / Line 49: @@
      // the degree by which the historical opinion is weighted
      public static double histWeight;
      // the (negative of) slope of skill vs variance of noise
@@ Line 151: / Line 154: @@
 	return op;
+     }
      ////////////////////////////////////////////////////////
@@ Line 170: / Line 189: @@
+	}
+     }
      ////////////////////////////////////////////////////////
@@ Line 258: / Line 296: @@
      public static double getHistWeight() {return histWeight;}
      public static void   setHistWeight(double i) {histWeight = i;}
      public static double getNoiseSlope() {return noiseSlope;}

Seoc at 23:09, 18 June 2006

2006-06-18T23:09:04Z

← Older revision		Revision as of 23:09, 18 June 2006
Line 1:		Line 1:
	[[WikiPeerCode]]		[[WikiPeerCode]]
	<pre>/*		<pre>
			/*
	* CustomNode.java		* CustomNode.java
	*		*
	* Created on January 22, 2005, 2:41 PM		* Created on January 22, 2005, 2:41 PM
	* Modified on June 17, 2006, 17:20 by Jack		* Modified on June 18, 2006, 13:55 by Jack
	*		*
	* This class contains the parameters and methods		* This class contains the parameters and methods
Line 48:		Line 49:
	// the degree by which the historical opinion is weighted		// the degree by which the historical opinion is weighted
	public static double histWeight;		public static double histWeight;

			// the (negative of) slope of skill vs variance of noise
			public static double noiseSlope;


Line 245:		Line 249:
	// Outputs: double, the noise variance		// Outputs: double, the noise variance
	public static double getNoiseFromSkill(double skill){		public static double getNoiseFromSkill(double skill){
	return skill~~/1.0~~;		return (1-skill)*noiseSlope;
	}		}

Line 254:		Line 258:
	public static double getHistWeight() {return histWeight;}		public static double getHistWeight() {return histWeight;}
	public static void setHistWeight(double i) {histWeight = i;}		public static void setHistWeight(double i) {histWeight = i;}

			public static double getNoiseSlope() {return noiseSlope;}
			public static void setNoiseSlope(double i) {noiseSlope = i;}
	}		}

	</pre>		</pre>

Seoc at 23:21, 17 June 2006

2006-06-17T23:21:26Z

Show changes

Seoc at 22:41, 15 June 2006

2006-06-15T22:41:47Z

← Older revision		Revision as of 22:41, 15 June 2006
Line 1:		Line 1:
			[[WikiPeerCode]]
	<pre>		<pre>
	/*		/*

Seoc at 22:40, 15 June 2006

2006-06-15T22:40:55Z

← Older revision		Revision as of 22:40, 15 June 2006
Line 1:		Line 1:
			<pre>
	/*		/*
	* CustomNode.java		* CustomNode.java
Line 208:		Line 209:
	}		}
	}		}
			</pre>

Seoc at 22:37, 15 June 2006

2006-06-15T22:37:32Z

New page

/*
* CustomNode.java
*
* Created on January 22, 2005, 2:41 PM
* Modified on June 14, 2006
*
* This class contains the parameters and methods
* for an agent acting on the network
*/

package RepMod;
import uchicago.src.sim.gui.NetworkDrawable;
import uchicago.src.sim.network.DefaultDrawableNode;
import uchicago.src.sim.gui.DrawableNonGridNode;
import uchicago.src.sim.util.Random;
import uchicago.src.sim.gui.OvalNetworkItem;
import java.awt.Color;
import uchicago.src.sim.gui.ColorMap;
import uchicago.src.sim.engine.CustomProbeable;
import java.util.ArrayList;

/**
*
* @author Jack Waddell
*
*/

// DefaultDrawableNode lets us draw it in the GUI
// CustomProbeable lets us define which attributes appear when
// probed in the GUI
public class CustomNode extends DefaultDrawableNode implements CustomProbeable {
//***********************************
// Static Parameters

// tracks next unique id
public static int nextID = 0;

public static GUIModel guiModel = null;
public static RepMod model;

//********************************8**
// Instance parameters

// Two colormaps are generated for color-coding the nodes in GUI
public static ColorMap centerColorMap;
public static ColorMap edgeColorMap;
public static final int colorMapSize = 16;
public static final int colorMapMax = colorMapSize - 1;

private int id; // uniquely ids node
public Color myColor; // used to draw color in GUI
public String myPajekColor = "Red"; // color to appear in Pajek output
public double reputation; // current wealth or stored reputation
public double skill; // skill parameter
public int numVotes; // the number of vote rounds

public double success; // most recent success

///////////////////////////////////////////////////////////////
// constructor
// Inputs: NetworkDrawable drawable, to draw in GUI
// double skill, the skill parameter
public CustomNode (NetworkDrawable drawable, double skill) {
super(drawable);
id = nextID++; // set id and iterate to next
this.skill = skill;
reputation = 50; // Generalize. Currently hard-coded
if (guiModel != null)
setNodeEdgeColorFromSkill();
numVotes = 0;
success = 0;
}

///////////////////////////////////////////////////////////
// getProbedProperties
// Required to implement CustomProbeable
// Inputs: none
// Outputs: array of strings holding parameter names
public String[] getProbedProperties(){
return new String[] {"id", "reputation", "skill", "success"};
}

//////////////////////////////////////////////////////////
// step
// Input: none
// Output: none
// (Can be) Called by main model to have nodes execute a single step
public void step(){
}

//////////////////////////////////////////////////////////
// setNodeColorFromReputation
// Input: maxReputation, the highest reputation from all agents
// Output: none
// Sets the node color to the colormap leval depending on reputation
public void setNodeColorFromReputation(double maxReputation){
int i = (int) Math.round(colorMapMax*(reputation)/ (maxReputation));
this.setColor(centerColorMap.getColor(i));
}

//////////////////////////////////////////////////////////
// setNodeEdgeColorFromSkill
// Input: none
// Output: none
// Sets the node edge color to the colormap level depending on skill
public void setNodeEdgeColorFromSkill(){
int i = (int) Math.round(colorMapMax*skill);
this.setBorderColor(edgeColorMap.getColor(i));
this.setBorderWidth(3);
}

///////////////////////////////////////////////////////
// getDegree
// Input: none
// Output: int degree
// Calculates the degree of the node (assuming symmetric)
public int getDegree(){
return (this.getOutNodes()).size();
}

///////////////////////////////////////////////////////
// vote
// Input: double success, the focus' real success
// Output: double vote, the voter's estimate of focus' success
public double vote(double fSuccess){
if (fSuccess > skill)
return Math.min(1, 1.1*fSuccess);
else
return fSuccess;
}

///////////////////////////////////////////////////////
// updateReputation
// Input: double, rep Latest reputation vote
// Output: none
public void updateReputation(double rep){
double preRep = reputation * (double) numVotes;
numVotes ++;
reputation = (preRep + rep) / ((double) numVotes);
}

///////////////////////////////////////////////////////
// challenge
// Input: double difficulty
// Output: none
public void challenge(double difficulty){
if (difficulty > skill)
success = 0;
else
success = skill - difficulty;
}

//***************************************************************
// Getters and Setters
public int getID() {return id;}

public void setMyPajekColor(String i) {myPajekColor = i;}
public String getMyPajekColor() {return myPajekColor;}

public double getReputation() {return reputation;}
public void setReputation(double i) {reputation = i;}

public double getSkill() {return skill;}
public void setSkill(double i) {skill = i;}

public double getSuccess() {return success;}
public void setSuccess(double i) {success = i;}

//***************************************************************
// Static Methods

public static void setModel(RepMod m) {model = m;}

//////////////////////////////////////////////////////////
// setUpNodeDrawing
// Input: GUIModel m, a pointer to the GUIModel
// Output: none
public static void setUpNodeDrawing (GUIModel m) {
guiModel = m;
centerColorMap = new ColorMap();
edgeColorMap = new ColorMap();
double minColor = 0.1;

for (int i = 0; i < colorMapSize; i++){
double fracColor = minColor + ( (1.0-minColor)*i/colorMapMax );

centerColorMap.mapColor(i, 0, 0, fracColor);
edgeColorMap.mapColor(i, 0, fracColor, 0);
}
}

///////////////////////////////////////////////////////////
// resetNextID
// Inputs: none
// Outputs: none
// Resets nextID. Called when the model is reset, and a
// new set of nodes is generated
public static void resetNextID(){
nextID = 0;
}
}