Diferenças

Aqui você vê as diferenças entre duas revisões dessa página.

--- geopro:pedro:mason [2007/07/03 04:06] – pedro
+++ geopro:pedro:mason [2007/08/06 13:53] (atual) – 150.163.2.54
@@ Linha 1: / Linha 1: @@
 ====== Mason ======
-//MASON is a fast discrete-event multiagent simulation library core in Java, designed to be the foundation for large custom-purpose Java simulations, and also to provide more than enough functionality for many lightweight simulation needs.//
+//MASON (Multi-Agent Simulator Of Neighborhoods... or Networks... or something...) is a fast discrete-event multiagent
+simulation library core in Java, designed to be the foundation for large custom-purpose Java simulations, and also to
+provide more than enough functionality for many lightweight simulation needs.//
+{{  http://leg.ufpr.br/~pedro/figures/mason-elements.jpg?650}}
 \\
@@ Linha 15: / Linha 18: @@
 \\
+MASON has execution speed as a high priority. MASON 1-35% faster than Repast.
 It has an example of Schelling's model in /home/pedro/codigo/mason/sim/app/schelling/Agent.java. The model is composed by reds, blues, empty sites where
@@ Linha 21: / Linha 24: @@
-        // get all the places I can go.  This will be slow as we have to rely on grabbing neighbors.
+    // get all the places I can go.  This will be slow as we have to rely on grabbing neighbors.
-        sch.neighbors.getNeighborsMaxDistance(loc.x,loc.y,sch.neighborhood,false,neighborsX,neighborsY);
+    sch.neighbors.getNeighborsMaxDistance(loc.x,loc.y,sch.neighborhood,false,neighborsX,neighborsY);
+    // compute value
+    double val = 0;
+    int threshold = sch.threshold;  // locals a little faster
+    int numObjs = neighborsX.numObjs;
+    int[] objsX = neighborsX.objs;
+    int[] objsY = neighborsY.objs;
+    int myVal = locs[x][y];
-        // compute value
+    for(int i=0;i<numObjs;i++)
-        double val = 0;
+    {
-        int threshold = sch.threshold;  // locals a little faster
+        if (locs[objsX[i]][objsY[i]] == myVal // just like me
-        int numObjs = neighborsX.numObjs;
+            && !(objsX[i] == x && objsY[i] == y))  // but it's NOT me
-        int[] objsX = neighborsX.objs;
+        {
-        int[] objsY = neighborsY.objs;
+            val += 1.0/Math.sqrt((x-objsX[i])*(x-objsX[i]) + (y-objsY[i])*(y-objsY[i]));
-        int myVal = locs[x][y];
+            if (val >= threshold) return;  // we're not moving
+        }
+    }
-        for(int i=0;i<numObjs;i++)
+    // find a new spot to live -- a random jump? Move to a nearby location?  Websites differ
-            {
+    int newLocIndex = state.random.nextInt(sch.emptySpaces.numObjs);
-            if (locs[objsX[i]][objsY[i]] == myVal // just like me
+    Int2D newLoc = (Int2D)(sch.emptySpaces.objs[newLocIndex]);
-                && !(objsX[i] == x && objsY[i] == y))  // but it's NOT me
+    sch.emptySpaces.objs[newLocIndex] = loc;
-                {
-                val += 1.0/Math.sqrt((x-objsX[i])*(x-objsX[i]) + (y-objsY[i])*(y-objsY[i]));
-                if (val >= threshold) return;  // we're not moving
-                }
-            }
-        // find a new spot to live -- a random jump? Move to a nearby location?  Websites differ
+    // swap colors
-        int newLocIndex = state.random.nextInt(sch.emptySpaces.numObjs);
+    int swap = locs[newLoc.x][newLoc.y];
-        Int2D newLoc = (Int2D)(sch.emptySpaces.objs[newLocIndex]);
+    locs[newLoc.x][newLoc.y] = locs[loc.x][loc.y];
-        sch.emptySpaces.objs[newLocIndex] = loc;
+    locs[loc.x][loc.y] = swap;
+    // adopt new position
-        // swap colors
+    loc = newLoc;
-        int swap = locs[newLoc.x][newLoc.y];
-        locs[newLoc.x][newLoc.y] = locs[loc.x][loc.y];
-        locs[loc.x][loc.y] = swap;
-        // adopt new position
-        loc = newLoc;
+====MASON: A New Multi-Agent Simulation Toolkit====
+|S Luke, C Cioffi-Revilla, L Panait, K Sullivan, 2004| Proceedings of the 2004 SwarmFest Workshop| [[http://leg.ufpr.br/~pedro/papers/Mason-SwarmFest04.pdf|pdf]]|
+\\
+**Abstract:** We introduce MASON, a fast, easily extendable, discrete-event multi-agent simulation toolkit in Java. MASON was
+designed to serve as the basis for a wide range of multi-agent simulation tasks ranging from swarm robotics to ma-
+chine learning to social complexity environments. MASON carefully delineates between model and visualization, al-
+lowing models to be dynamically detached from or attached to visualizers, and to change platforms mid-run. We de-
+scribe the MASON system, its motivation, and its basic architectural design. We then discuss ﬁve applications of MA-
+SON we have built over the past year to suggest its breadth of utility.
+\\
+Agents and the Schedule MASON employs a specific usage of the term agent: a computational entity which may
+be scheduled to perform some action, and which can manipulate the environment. Note that we do not explicitly
+state that the agent is physically in the environment, though
+it may be; in this case we would refer to the agent as an
+embodied agent. Agents are brains, and do not need to be
+bodies. MASON does not schedule events on the schedule to send to an agent; rather it schedules the agent itself.
+Fields MASON's fields relate arbitrary objects or values
+with locations in some notional space. Many of these fields
+are little more than wrappers for simple 2D or 3D arrays.
+Others provide sparse relationships. An object may exist in
+multiple fields at one time (and, for some fields, in the same
+field more than once). The use of fields is entirely optional.
+\\
+====doing====
+MASON was developed by the
+Evolutionary Computation Laboratory (ECLab) and the Centre for Social Complexity at
+George Mason University.        At present MASON does not provide functionality for
+dynamically charting (e.g. histograms, line graphs, pie charts, etc) model output during a
+simulation, or allow GIS data to be imported / exported (Luke et al., 2004). However, the
+developers of MASON are continuing to develop further functionality, and they hope users
+will develop and contribute tools themselves (e.g. GIS integration). Unfortunately there is
+little technical documentation and a relatively small user group in comparison to some of the
+other systems identified within this paper. However, how-to documentation, demonstration
+models (e.g. the seminal heat bugs example, network models, etc), and several publications
+detailing the implementation and / or application of MASON are available for a prospective
+modeller to evaluate the system further (MASON, 2006).
+====MASON: A Multiagent Simulation Environment====
+|S. Luke and C. Cioffi-Revilla and L. Panait and K. Sullivan and G. Balan, 2005|Simulation|[[http://leg.ufpr.br/~pedro/papers/mason-simulation-environment.pdf|pdf]]|
+\\
+**Abstract:** MASON is a fast, easily extensible, discrete-event multi-agent simulation toolkit in Java, designed
+to serve as the basis for a wide range of multi-agent simulation tasks ranging from swarm robotics
+to machine learning to social complexity environments. MASON carefully delineates between model
+and visualization, allowing models to be dynamically detached from or attached to visualizers, and
+to change platforms mid-run. This paper describes the MASON system, its motivation, and its basic
+architectural design. It then compares MASON to related multi-agent libraries in the public domain,
+and discusses six applications of the system built over the past year which suggest its breadth of
+utility.
+\\
+MASON was designed as a smaller and faster alternative to Repast, with a clear focus on computationally
+demanding models with many agents executed over many
+iterations. Design appears to have been driven largely by
+the objectives of maximizing execution speed and assuring complete reproducibility across hardware. The abilities
+to detach and re-attach graphical interfaces and to stop a
+simulation and move it among computers are considered
+a priority for long simulations. MASON’s developers ap-
+pear intent on including only general, not domain-speciﬁc,
+tools.