simulate to a thousands simulations

src/modules/feature/feature-board.ts

@@ -5,7 +5,7 @@ import { Strategy } from '@/modules/lean/strategy'
 import { FeatureState } from '@/store-type'
 import { getMean, pickRandomElement, popNElement, shuffleArray } from '@/utils'
 
-const MAX_FEATURES = 30
+const MAX_FEATURES = 200
 const HARD_STOP = 5000
 
 const hasQualityIssue = ({
@@ -22,7 +22,7 @@ const hasQualityIssue = ({
     daysWithProblemSolving
   )
 
-  let multiplicator = getOverburdenMultiplicator(tasksInParallel)
+  const multiplicator = getOverburdenMultiplicator(tasksInParallel)
   const quality = Math.random()
 
   return quality > qualityProbability / multiplicator

src/modules/simulation/SimulationControls.vue

@@ -1,7 +1,7 @@
 <script setup lang="ts">
 import { useSimulationStore } from '@/modules/simulation/simulation-store'
 const simulationStore = useSimulationStore()
-const NUMBER_OF_SIMULATION = 300
+const NUMBER_OF_SIMULATION = 1000
 </script>
 
 <template>

src/modules/simulation/SimulationDashboard.vue

@@ -31,6 +31,30 @@ const simulationStore = useSimulationStore()
             {{ simulationStore.meanPullDPSLeadTime }}
           </td>
         </tr>
+        <tr>
+          <td>Complexity</td>
+          <td>
+            {{ simulationStore.meanPushComplexity }}
+          </td>
+          <td>
+            {{ simulationStore.meanPullComplexity }}
+          </td>
+          <td>
+            {{ simulationStore.meanPullDPSComplexity }}
+          </td>
+        </tr>
+        <tr>
+          <td>Quality issue</td>
+          <td>
+            {{ simulationStore.meanPushQuality }}
+          </td>
+          <td>
+            {{ simulationStore.meanPullQuality }}
+          </td>
+          <td>
+            {{ simulationStore.meanPullDPSQuality }}
+          </td>
+        </tr>
       </tbody>
     </table>
   </div>

src/modules/simulation/simulation-store.ts

@@ -1,15 +1,30 @@
 import { featureSteps } from '@/modules/feature/feature-steps'
 import { Strategy } from '@/modules/lean/strategy'
 import { Dashboard, Meta } from '@/store-type'
-import { getMean } from '@/utils'
+import { getRound } from '@/utils'
 import { defineStore } from 'pinia'
 
+type Mean = {
+  leadTimeSum: number
+  complexitySum: number
+  qualityIssueSum: number
+  simulations: number
+}
+
 type State = {
   dashboards: Dashboard[]
   requestedSimulation: number
   simulationsDone: number
+  mean: Record<Strategy, Mean>
 }
 
+const newMean = (): Mean => ({
+  leadTimeSum: 0,
+  complexitySum: 0,
+  qualityIssueSum: 0,
+  simulations: 0
+})
+
 const instance = new ComlinkWorker<typeof import('../feature/feature-board')>(
   new URL('../feature/feature-board', import.meta.url)
 )
@@ -29,7 +44,12 @@ export const useSimulationStore = defineStore('dashboard', {
     return {
       dashboards: [],
       requestedSimulation: 0,
-      simulationsDone: 0
+      simulationsDone: 0,
+      mean: {
+        push: newMean(),
+        pull: newMean(),
+        'problem-solving': newMean()
+      }
     }
   },
   actions: {
@@ -55,7 +75,7 @@ export const useSimulationStore = defineStore('dashboard', {
         a.qualityIssue > b.qualityIssue ? -1 : 1
       )
 
-      this.newDashboard({
+      const dashboard: Dashboard = {
         uuid: new Date().getTime().toString(),
         meta: newState.meta,
         analysis: {
@@ -67,7 +87,13 @@ export const useSimulationStore = defineStore('dashboard', {
           worstFeature,
           strategy
         }
-      })
+      }
+
+      this.newDashboard(dashboard)
+      this.mean[strategy].leadTimeSum += dashboard.analysis.meanLeadTime
+      this.mean[strategy].complexitySum += dashboard.analysis.meanComplexity
+      this.mean[strategy].qualityIssueSum += dashboard.analysis.meanQualityIssue
+      this.mean[strategy].simulations++
     },
     async multiSimulation(simulations: number, strategy: Strategy) {
       this.requestedSimulation += simulations
@@ -82,26 +108,51 @@ export const useSimulationStore = defineStore('dashboard', {
   },
   getters: {
     meanPushLeadTime: (state) => {
-      return getMean(
+      return getRound(state.mean.push.leadTimeSum, state.mean.push.simulations)
-        state.dashboards
-          .filter((dashboard) => dashboard.analysis.strategy === 'push')
-          .map((dashboard) => dashboard.analysis.meanLeadTime)
-      )
     },
     meanPullLeadTime: (state) => {
-      return getMean(
+      return getRound(state.mean.pull.leadTimeSum, state.mean.pull.simulations)
-        state.dashboards
-          .filter((dashboard) => dashboard.analysis.strategy === 'pull')
-          .map((dashboard) => dashboard.analysis.meanLeadTime)
-      )
     },
     meanPullDPSLeadTime: (state) => {
-      return getMean(
+      return getRound(
-        state.dashboards
+        state.mean['problem-solving'].leadTimeSum,
-          .filter(
+        state.mean['problem-solving'].simulations
-            (dashboard) => dashboard.analysis.strategy === 'problem-solving'
       )
-          .map((dashboard) => dashboard.analysis.meanLeadTime)
+    },
+    meanPushComplexity: (state) => {
+      return getRound(
+        state.mean.push.complexitySum,
+        state.mean.push.simulations
+      )
+    },
+    meanPullComplexity: (state) => {
+      return getRound(
+        state.mean.pull.complexitySum,
+        state.mean.pull.simulations
+      )
+    },
+    meanPullDPSComplexity: (state) => {
+      return getRound(
+        state.mean['problem-solving'].complexitySum,
+        state.mean['problem-solving'].simulations
+      )
+    },
+    meanPushQuality: (state) => {
+      return getRound(
+        state.mean.push.qualityIssueSum,
+        state.mean.push.simulations
+      )
+    },
+    meanPullQuality: (state) => {
+      return getRound(
+        state.mean.pull.qualityIssueSum,
+        state.mean.pull.simulations
+      )
+    },
+    meanPullDPSQuality: (state) => {
+      return getRound(
+        state.mean['problem-solving'].qualityIssueSum,
+        state.mean['problem-solving'].simulations
       )
     }
   }

src/utils.ts

@@ -1,6 +1,9 @@
 export const getMean = (data: number[]) =>
   Math.round(100 * (sumElements(data) / data.length)) / 100
 
+export const getRound = (data: number, total: number) =>
+  Math.round(100 * (data / total)) / 100
+
 export const clone = (data: any) => JSON.parse(JSON.stringify(data))
 
 export const shuffleArray = <T>(array: T[]) => {