The Working Of Java In The Simulation Of The Learning Curve; The Logic Reasoning Behind It And How It Flows
The learning curve input description
|
Simulator inputs |
Description |
|
Number of days |
Number of periods in the market. Each seller can change its price at the end of the day |
|
Number of buyers |
The size of the buyer population over the entire market |
|
Market mechanism |
Posted price or first price auction |
|
Buyer segmentation |
The buyer population can optionally be divided into two groups, either in a 50-50 or 75-25 ratio |
|
Number of sellers |
Number of those selling |
|
Number of goods |
Initial inventory for each seller |
|
Fixed cost |
Cost of producing the inventory |
|
Marginal cost |
The additional cost of selling each good. This is often zero in finite markets |
|
Initial price offered |
The initial price all the sellers will offer in the market. This parameter can be adjusted on a per seller basis on the seller strategies screen. |
|
Buyer behavior |
|
|
Daily price distribution |
The demand distribution of buyers on a single day. available choices are normal distribution, positive slope, negative slope, or segmented into a high and low grouping |
|
Price variation per day |
The buyers’ reservation prices vary ±the variance in a single day. the variance determines the range of the daily distribution in price |
|
Percentage comparison shoppers |
The percentage of the comparison of the buyers population (0-100%) who compare each seller’s offer price and purchase from the seller with the greatest % discount below its reservation price for the seller |
|
Preference for certain sellers |
The entire buyer population can have a preference for one or more of the sellers, which is represented by a higher-reservation price for that individual seller. This is a method for expressing product and seller differentiation |
|
Lifetime |
Number of days a single a single seller will be in market, actively looking for a seller. Regardless of lifetime, once a buyer purchases it leaves the market |
|
Buyer valuation over time |
Over the course of the market, the demand of the buyer will change and the valuation/time curve expresses how the demand will change over time. the shape of the curve can be either flat, increasing, decreasing, mid-peaking, or mid-pinning over time |
|
Minimum/maximum buyer prices over time |
The range of prices for the buyer valuation curve. These values are the minimum reservation prices over the market. |
|
Buyer behavior |
|
|
Seller strategies |
The different pricing strategies sellers use in the market, either Goal-Directed or Derivative-Following |
|
Initial prices |
The different prices sellers offer on the first day of the market before adjusting price through the chosen strategy |
|
Available inventory per day |
Amount of inventory a seller can sell in one day. this can be limited to represent shelving costs and to prevent 100% inventory sell off in a single day. |
Simulator code design
After outlining the simulator functionality from the perspective of the interface, the code design is presented here as an overview for the underlying workings of the simulator.
The learning curve simulator is constructed in three tiers:
- General market framework
- A detailed framework for the learning curve aspects of the market and
- A graphical user interface
The three tiers are constructed in Java 1.3 hence forming the java packages:
- Marketplace
- lc and
- gui respectively
|
Simulator’s java packages |
Core packages classes |
|
gui |
LearningCurveIO |
|
lc |
SimulatorDriver |
|
Marketplace |
Engine |
The interaction between the three functional tiers is directed by the communication between the core classes of java ‘lc.SimulatorDriver,’ gui.LearningCurveIO and marketplace.Engine.
When the user makes an interaction with the simulator he/she interfaces with the swing interface, the object of java which is named LearningCurveIO. When the simulator inputs have been gathered, the LearningCurveIO passes the inputs to the SimulationDriver. The SimulationDriver manages the creation of the learning curve buyers and sellers and then it sends the players of the market to the core of the simulator, the engine class; the engine iterates through every market simulation, managing the matching of the buyers and sellers.
At the end of every day, the engine stores information about each successful transaction of the market and informs the seller and the buyers to update their prices. At the market end, the engines then give a report of the result to the SimulationDriver which in return send the results the LearningCurveIO which then presents visually the results to the user.
The market place and the lc packages have several additional classes, which are given in below table. Each table’s class are categorized by their role in the simulator, depending on whether they are pieces of framework, utilities or market players. The classes of marketplace offer a structure for any form of marketplace, since it assumes nothing about the characteristics or behaviors of the buyer or the sellers.
The marketplace classes give an outline about the structure of a market by offering a definition to the java interfaces for buyers and sellers which then are implemented in detail in the lc package. In case other forms of market were to be implemented the marketplace package for java interfaces can serve as a beginning point and a designer would implement the java interfaces in the market place and any additional classes which are found to be necessary.
|
MARKETPLACE PACKAGE |
|
|
Java class |
Functional description |
|
Market framework |
|
|
State of simulation |
Framework piece coordinating the simulator state; the current day and which buyers and sellers are actively looking for transactions |
|
Engine |
A piece of framework which runs the simulated market. Based on the information from the simulation state, it locates buyers and pairs then for a negotiation. |
|
Market players |
|
|
Transaction party |
A generic player in the market (java interface) |
|
Buyer |
A generic player who is buying (java interface) |
|
Seller |
A generic player who is selling (java interface) |
|
Good |
The object being exchanged between market players |
|
Utilities of the market |
|
|
Seller Strategy |
A generic interface for a seller strategy |
|
Strategy |
A generic player strategy |
|
Lifetime |
Gives a player a random lifetime based on a duration value |
|
Negotiation |
Mechanism for matching up buyers and sellers based on different market mechanisms. It returns the price of sale or 0, depending on the result of the negotiation |
|
Distribution |
It is a generic utility for number generation in a specific distribution, and it is based on an histogram model. |
|
Results |
It a utility to store simulation results |
|
Receipt |
It is an utility for storing each receipt of sales; the receipts are created by the seller and they contain all information about a sale of a seller |
|
Day |
Utility for organizing simulation results by the day’s events |
The ‘lc’ package outlines the specific behavior of the sellers and buyers by implementation of classes of buyer and seller in the marketplace package as the LCBuyer and LCSeller classes. The package of lc is structured such that variety of different sellers strategies can be implemented in the simulator. This is accompanied by defining each strategy as a class which implements the marketplace.SellerStrategy interface. This design makes the addition of new strategies to look trivial.
|
LC PACKAGE |
|
|
Java Class Name |
Functional description |
|
Learning curve players |
|
|
LCBuyer |
It is a specific implementation of a buyer in the learning curve simulator. Each buyer object has the different characteristics e.g. an array of reservation prices for every seller, a beginning and ending day in the market, a preference for certain buyers, a designation as a comparison shopper or not. The reservation of the buyer price is calculated every day based on all its features |
|
LCSeller |
LCSeller is the specific implementation of a seller in the learning Simulator curve. Different sellers have specific amount of inventory, a designated strategy an initial offer price and its receipts from its sales. Every day the seller uses its sales receipts and its strategy for calculation of a new offer price. |
|
Learning utilities |
|
|
SimulationDriver |
It initializes the simulator by directing the input variables to the market place.Engine and creating the populations of the buyers and sellers. |
|
LearningCurve |
It is for running the simulator from a command line (vs. the GUI) |
|
Inputvariables |
It coordinates all of the input variables for the simulator, gathering them either from the gui or the command line. |
|
DemandCurve |
It calculates the average reserve price for the buyer population on a given day, provided the specified shape of the valuation/time curve |
|
SStrategyFP SStrategyDF SStrategyDFA SStrategyGO SStrategyGOA SStrategyGOQ |
Each of the classes implements the seller strategy interface. The seller strategies determine the reserve price that is offered by the seller on a given day. The strategies use the sales receipt information of the seller to calculate a new offer price. FP – Fixed price DF – Derivative Following DFA – Derivative following adjusted for market day GO – Goal directed (oriented) GOA Goal oriented adjusted for market day GOQ – Goal-Directed quantity |
