Decision-Making Models Interactive System
Decision-Making Models Interactive System
Explore, analyze, and apply decision-making frameworks through interactive tools and visualizations
Decision Model Types
Rational Model
Systematic approach assuming perfect information and unlimited processing capacity
Bounded Rationality
Recognizes cognitive limitations and seeks satisfactory rather than optimal solutions
Intuitive Model
Relies on experience, pattern recognition, and subconscious processing
Interactive Decision Process
Decision Matrix Generator
| Options/Criteria |
|---|
3D Decision Space Visualization
Decision Algorithm Implementation
Rational Decision Algorithm
class RationalDecisionModel {
constructor(options, criteria, weights) {
this.options = options;
this.criteria = criteria;
this.weights = weights;
}
calculateUtility(option) {
let totalUtility = 0;
for (let i = 0; i < this.criteria.length; i++) {
const score = option.scores[i];
const weight = this.weights[i];
totalUtility += score * weight;
}
return totalUtility;
}
findOptimalDecision() {
let bestOption = null;
let bestUtility = -Infinity;
for (const option of this.options) {
const utility = this.calculateUtility(option);
if (utility > bestUtility) {
bestUtility = utility;
bestOption = option;
}
}
return {
option: bestOption,
utility: bestUtility,
confidence: this.calculateConfidence(bestUtility)
};
}
calculateConfidence(bestUtility) {
const utilities = this.options.map(opt => this.calculateUtility(opt));
utilities.sort((a, b) => b - a);
const gap = utilities[0] - utilities[1];
return Math.min(gap / utilities[0], 1);
}
}
Bounded Rationality Implementation
class BoundedRationalityModel {
constructor(options, criteria, satisficingThreshold, timeLimit) {
this.options = options;
this.criteria = criteria;
this.threshold = satisficingThreshold;
this.timeLimit = timeLimit;
this.searchOrder = this.generateSearchOrder();
}
generateSearchOrder() {
// Randomize or use heuristics to order search
return this.options.sort(() => Math.random() - 0.5);
}
satisficingSearch() {
const startTime = Date.now();
for (const option of this.searchOrder) {
// Check time constraint
if (Date.now() - startTime > this.timeLimit) {
break;
}
const scores = this.evaluateOption(option);
const meetsThreshold = this.checkSatisficing(scores);
if (meetsThreshold) {
return {
option: option,
satisficing: true,
searchTime: Date.now() - startTime,
optionsEvaluated: this.searchOrder.indexOf(option) + 1
};
}
}
// Return best found if no satisficing option
return {
option: this.getBestEvaluated(),
satisficing: false,
searchTime: Date.now() - startTime
};
}
checkSatisficing(scores) {
return scores.every(score => score >= this.threshold);
}
evaluateOption(option) {
return option.scores.map(score =>
score + (Math.random() - 0.5) * 0.1 // Add noise for bounded processing
);
}
}
Decision Visualization Engine
class DecisionVisualizationEngine {
constructor(container) {
this.container = container;
this.scene = new THREE.Scene();
this.camera = new THREE.PerspectiveCamera(75,
container.offsetWidth / container.offsetHeight, 0.1, 1000);
this.renderer = new THREE.WebGLRenderer({ antialias: true });
this.setupScene();
}
setupScene() {
this.renderer.setSize(this.container.offsetWidth, this.container.offsetHeight);
this.renderer.setClearColor(0x1a1a1a);
this.container.appendChild(this.renderer.domElement);
// Add lighting
const ambientLight = new THREE.AmbientLight(0x404040, 0.6);
this.scene.add(ambientLight);
const directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);
directionalLight.position.set(10, 10, 5);
this.scene.add(directionalLight);
// Setup camera
this.camera.position.set(0, 5, 10);
this.controls = new THREE.OrbitControls(this.camera, this.renderer.domElement);
this.controls.enableDamping = true;
this.animate();
}
visualizeDecisionSpace(options, criteria) {
// Clear previous visualization
this.clearScene();
// Create 3D scatter plot of options
options.forEach((option, index) => {
const geometry = new THREE.SphereGeometry(0.2, 16, 16);
const material = new THREE.MeshStandardMaterial({
color: this.getOptionColor(index),
transparent: true,
opacity: 0.8
});
const sphere = new THREE.Mesh(geometry, material);
// Position based on first 3 criteria scores
sphere.position.set(
option.scores[0] * 5 - 2.5,
option.scores[1] * 5 - 2.5,
option.scores[2] * 5 - 2.5
);
sphere.userData = { option: option, index: index };
this.scene.add(sphere);
});
this.addAxes();
this.addLabels(criteria);
}
getOptionColor(index) {
const colors = [0x2E86C1, 0xE74C3C, 0x28B463, 0xF39C12, 0x8E44AD];
return colors[index % colors.length];
}
animate() {
requestAnimationFrame(() => this.animate());
this.controls.update();
this.renderer.render(this.scene, this.camera);
}
}
Interactive Case Studies
Business Investment Decision
Analyze a technology startup investment using multiple decision models
Career Path Selection
Navigate career decisions with bounded rationality and intuitive models
Emergency Response Planning
Apply rapid decision-making models under time pressure and uncertainty
留言
發佈留言