leet the solver drift

app/models/bundle.py

@@ -15,14 +15,14 @@ class Bundle(BaseModel):
     type: str
 
     def tif(self, irt_model: IRTModel, theta: float) -> float:
-        return 0.9
-        # return TestInformationFunction(irt_model).calculate(self.items,
-        #                                                     theta=theta)
+        val = TestInformationFunction(irt_model).calculate(self.items, theta=theta)
+
+        return round(val, 2)
 
     def trf(self, irt_model: IRTModel, theta: float) -> float:
-        return 0.9
-        # return TestResponseFunction(irt_model).calculate(self.items,
-        #                                                  theta=theta)
+        val = TestResponseFunction(irt_model).calculate(self.items, theta=theta)
+
+        return round(val, 2)
 
     def tif_trf_sum(self, solver_run):
         return self.__trf_sum(solver_run) + self.__tif_sum(solver_run)

app/models/item.py

@@ -14,14 +14,14 @@ class Item(BaseModel):
     b_param: float = 0.00
 
     def iif(self, solver_run, theta):
-        return 0.9
-        # return ItemInformationFunction(solver_run.irt_model).calculate(
-        #     b_param=self.b_param, theta=theta)
+        val = ItemInformationFunction(solver_run.irt_model).calculate(b_param=self.b_param, theta=theta)
+
+        return round(val, 2)
 
     def irf(self, solver_run, theta):
-        return 0.9
-        # return ItemResponseFunction(solver_run.irt_model).calculate(
-        #     b_param=self.b_param, theta=theta)
+        val = ItemResponseFunction(solver_run.irt_model).calculate(b_param=self.b_param, theta=theta)
+
+        return round(val, 2)
 
     def get_attribute(self, ref_attribute):
         for attribute in self.attributes:

app/models/target.py

@@ -9,8 +9,14 @@ class Target(BaseModel):
 
     @classmethod
     def max_drift(cls):
-        return 10 # 10% elasticity
+        return 120 # let it drift...
 
     @classmethod
     def max_drift_increment(cls):
-        return 1 # 1%
+        return 10 # 10%
+
+    def minimum(self, drift_percent = 0.0) -> float:
+        return round(self.value - (self.value * drift_percent), 2)
+
+    def maximum(self, drift_percent = 0.0) -> float:
+        return round(self.value + (self.value * drift_percent), 2)