Example #1
0
    def test_quantile(self):
        from numpy import array, ma

        a = array([35, 6, 22, 1, 60])
        b = array([6, 3, 5, 9, 1, 7, 10, 2, 8, 4, 0])
        self.assertEqual(ma.allequal(quantile(a, array([0.2, 0.9, 0.5])), array([1, 35, 6])), True)
 def test_join_datasets_with_2_ids(self):
     from numpy import ma
     storage = StorageFactory().get_storage('dict_storage')
     
     storage.write_table(
         table_name='data1',
         table_data={
             'id1':array([2,4,2]),
             'id2':array([1,2,3]),
             'attr1':array([4,7,1]),
             'attr2':array([100,0,1000]),
             }
         )
     storage.write_table(
         table_name='data2',
         table_data={
             'id1':array([4,2,2]),
             'id2':array([2,3,1]),
             'attr1':array([50,60,70])
             }
         )
     
     ds1 = Dataset(in_storage=storage, in_table_name='data1', id_name=['id1', 'id2'], dataset_name='data1')
     ds2 = Dataset(in_storage=storage, in_table_name='data2', id_name=['id1', 'id2'], dataset_name='data2')
     ds1.join(ds2, 'attr1')
     self.assertEqual(ma.allequal(ds1.get_attribute('attr1'), array([70,50,60])), True)
     self.assertEqual(ma.allequal(ds1.get_attribute('attr2'), array([100,0,1000])), True)
    def test_load_specification_with_definition_nest_and_equations(self):
        specification = {
             "_definition_": [
                 ("pop = urbansim.gridcell.population", "bpop"),
                 "inc = urbansim.gridcell.average_income",
                 "art = urbansim.gridcell.is_near_arterial",
                 ],
              -2: {
                   'name': 'nest_id',
                   1: {1: [
                     "pop", 
                     "inc", 
                     "constant" ],
                      2: [ "art"]
                      },
                   2: {3:["pop", 
                          "inc"
                          ]}
                             }
              }
        result = load_specification_from_dictionary(specification)
        vars = result.get_variable_names()
        coefs = result.get_coefficient_names()
        eqs = result.get_equations()
        other = result.get_other_fields()
 
        self.assert_(alltrue(coefs == array(["bpop", "inc", "constant", "art", "bpop", "inc"])),
                     msg = "Error in test_load_specification_with_definition_nest_and_equations (coefficients)")
        self.assert_(alltrue(vars == array(["pop", "inc", "constant",  "art", "pop", "inc"])),
                     msg = "Error in test_load_specification_with_definition_nest_and_equations (variables)")
        self.assert_(ma.allequal(eqs, array([1,1,1,2,3,3])),
                     msg = "Error in test_load_specification_with_definition_nest_and_equations (equations)")
        self.assert_(ma.allequal(other['dim_nest_id'], array([1,1,1,1,2,2])),
                     msg = "Error in test_load_specification_with_definition_nest_and_equations (nests)")
    def test_agent_times_choice(self):
        expression = "agent_x_choice.agent_times_choice(attr)"
        storage = StorageFactory().get_storage("dict_storage")
        storage.write_table(
            table_name="agents",
            table_data={
                "id": array([1, 2, 3, 4, 5]),
                "attr_2": array([3, 2, 4, 10, 20]),
                "attr_3": array([10, 100, 1000, 500, 0]),
                "attr_4": array([100, 500, 0, 20, -30]),
            },
        )
        storage.write_table(table_name="choices", table_data={"id": array([1, 2, 3, 4])})
        agents = Dataset(in_storage=storage, in_table_name="agents", dataset_name="agent", id_name="id")
        choices = Dataset(in_storage=storage, in_table_name="choices", dataset_name="choice", id_name="id")
        ids = InteractionDataset(dataset1=agents, dataset2=choices, index1=array([0, 1, 3, 4]), index2=array([1, 2, 3]))
        result = ids.compute_variables(expression)
        should_be = array([[3, 10, 100], [2, 100, 500], [10, 500, 20], [20, 0, -30]])
        self.assertEqual(ma.allequal(result, should_be), True)

        agents.touch_attribute("attr_2")  # in order to recompute the expression
        choices.add_primary_attribute(name="name", data=array(["bus", "car", "tran", "walk"]))
        agents.add_primary_attribute(name="attr_tran", data=array([100, 1000, 10000, 5000, 10]))
        result = ids.compute_variables(expression)
        should_be = array([[3, 100, 100], [2, 1000, 500], [10, 5000, 20], [20, 10, -30]])
        self.assertEqual(ma.allequal(result, should_be), True)
 def test_load_specification(self):
     specification = {1: [
              ("urbansim.gridcell.population", "BPOP"),
              ("urbansim.gridcell.average_income", "BINC"),
                          ],
                      2: [
              ("urbansim.gridcell.is_near_arterial", "BART"),
              ("urbansim.gridcell.is_near_highway", "BHWY"),
                          ],
                      3: [
              ("lage = ln(urbansim.gridcell.average_age+1)", "BAGE")
                          ]
     }
     result = load_specification_from_dictionary(specification)
     vars = result.get_variable_names()
     coefs = result.get_coefficient_names()
     subm = result.get_submodels()
     fixedval = result.get_fixed_values()
     self.assert_(alltrue(coefs == array(["BPOP", "BINC", "BART", "BHWY", "BAGE"])),
                  msg = "Error in test_load_specification (coefficients)")
     self.assert_(alltrue(vars ==
                              array(["population", "average_income", "is_near_arterial", "is_near_highway", "lage"])),
                  msg = "Error in test_load_specification (variables)")
     self.assert_(ma.allequal(subm, array([1, 1, 2, 2, 3])),
                  msg = "Error in test_load_specification (submodels)")
     self.assert_(fixedval.size == 0, msg = "Error in test_load_specification (fixed_values should be empty)")
     
     # add a variable with a fixed value coefficient
     specification[3].append(("constant", "C", 1))
     result = load_specification_from_dictionary(specification)
     fixedval = result.get_fixed_values()
     self.assert_(ma.allequal(fixedval, array([0, 0, 0, 0, 0, 1])), 
                  msg = "Error in test_load_specification (fixed_values)")
Example #6
0
    def test_ematch(self):
        from numpy import array, ma

        self.assertEqual(ma.allequal(ematch(array(["abcde", "abcd"]), "abcd"), array([1])), True,
                         msg = "Error in ematch.")
        self.assertEqual(ma.allequal(ematch(array(["ab(c]de", "abcd"]), "ab(c]de"), array([0])), True,
 def test_ZonalMean_exec(self):
     lo=ZonalMean_exec(self.l12,self.l13)
     res=np.asarray([[3,3,3,4],[4,4,2,2],[2,5,5,5],[6,6,5,6]])
     self.assertTrue(allequal(lo._data,res))
     lo=ZonalMean_exec(self.l14,self.l13)
     res=np.asarray([[-3,-3,-3,-4],[-4,-4,-2,-2],[-2,-5,-5,-5],[-6,-6,-5,-6]])
     self.assertTrue(allequal(lo._data,res))
 def _check_dataset_methods_on_dataset_view(self, ds, years_to_merge):
     self.assert_(ds is not None)
     ds.load_dataset(attributes='*',
                     in_table_name='tests',
                     in_storage=AttributeCache()
                     )
     id = ds.get_attribute('id')
     attr1 = ds.get_attribute('attr1')
     
     # Does compute_variables work?
     ds.compute_variables(['opus_core.test.attr1_times_2'])
     attr1_times_2 = ds.get_attribute('attr1_times_2')
     
     # Are values as expected?
     self.assert_(ma.allequal(attr1*2, attr1_times_2))
     
     # Does results have expected number of elements?
     self.assertEqual(len(years_to_merge)*3, len(attr1_times_2))
     
     # Does _compute_if_needed work?
     ds._compute_if_needed(
         'opus_core.test.attr2_times_2',
         dataset_pool=SessionConfiguration().get_dataset_pool()
     )
     attr2_times_2 = ds.get_attribute('attr2_times_2')
     attr2 = ds.get_attribute('attr2')
     self.assert_(ma.allequal(attr2*2, attr2_times_2))
 def test_focalsum(self):
     lo = FocalSum(self.l1, buffersize=1)
     res = np.asarray([[4,6,6,4],[6,9,9,6],[6,9,9,6],[4,6,6,4]])
     self.assertTrue(allequal(lo._data, res))
     lo = FocalSum(self.l1, buffersize=2)
     res = np.asarray([[9,12,12,9],[12,16,16,12],[12,16,16,12],[9,12,12,9]])
     self.assertTrue(allequal(lo._data, res))
 def test_simple_lag_variable(self):
     test_data = {
         1000:{
             'tests':{
                 'id':array([1,2,3]),
                 'attr1':array([10,20,30]),
                 },
             },
         1001:{
             'tests':{
                 'id':array([1,2,3]),
                 'attr1':array([111,222,333]),
                 },
             },
         }
     cache_creator = CreateTestAttributeCache()
     cache_creator.create_attribute_cache_with_data(self._temp_dir, test_data)
     
     SimulationState().set_current_time(1001)
     
     attribute_cache = AttributeCache()
     SessionConfiguration(new_instance=True,
                          package_order=['opus_core'],
                          in_storage=attribute_cache)
     
     ds = Dataset(in_storage = attribute_cache, 
                  in_table_name = 'tests', 
                  id_name = ['id'], 
                  dataset_name = 'tests')
     
     ds.compute_variables(['opus_core.tests.attr1'])
     self.assert_(ma.allequal(ds.get_attribute('attr1'), array([111,222,333])))
     
     ds.compute_variables(['opus_core.tests.attr1_lag1'])
     self.assert_(ma.allequal(ds.get_attribute('attr1_lag1'), array([10,20,30])))
    def test_change_three_elements(self):
        """3 values are in common - change them to -1. Other attributes stay unchanged."""
        data = {
           'my_id': array([1,2,3,4,5]),
           'attr':  array([10,2,3,50,2]),
           'attr2': array([4,3,2,5,3])    
                }
        data2 = {
            'attr': array([2,6,7,3])
                 }
        storage = StorageFactory().get_storage('dict_storage')

        storage.write_table(table_name='dataset', table_data=data)
        dataset = Dataset(in_storage = storage, 
                           in_table_name='dataset',
                           id_name='my_id'
                           )
        storage.write_table(table_name='dataset2', table_data=data2)
        dataset2 = Dataset(in_storage = storage, 
                           in_table_name='dataset2',
                           id_name='attr'
                           )
        JoinAttributeModificationModel().run(dataset,dataset2, value=-1)
        self.assertEqual(ma.allequal(dataset.get_attribute('attr'), array([10,-1,-1,50,-1])), True)
        self.assertEqual(ma.allequal(dataset.get_attribute('attr2'), data['attr2']), True)
     def test(self):
         opus_core_path = OpusPackage().get_opus_core_path()
         dbf_directory = os.path.join(
             opus_core_path, 'tests', 'data', 'dbf')
         table_name = 'test_logical'
         cache_directory = self._temp_dir
         year = 1000
 
         exporter = ExportDbfTableToCacheCommand(
             dbf_directory = dbf_directory,
             table_name = table_name,
             cache_directory = cache_directory,
             year = year,
             )
         exporter.execute()
         
         attribute_cache = AttributeCache(cache_directory=cache_directory)
         
         old_time = SimulationState().get_current_time()
         SimulationState().set_current_time(year)
         
         values = attribute_cache.load_table(table_name)
         
         self.assertEqual(set(['keyid', 'works']), set(values.keys()))
         self.assert_(ma.allequal(array([1,2,3,4,5]), values['keyid']))
         self.assert_(ma.allequal(array([1,1,-1,0,0]), values['works']))
         
         SimulationState().set_current_time(old_time)
 def test_agent_times_choice(self):
     expression = 'agent_x_choice.agent_times_choice(attr)'
     storage = StorageFactory().get_storage('dict_storage')
     storage.write_table(table_name='agents', 
         table_data={'id': array([1, 2, 3, 4, 5]), 'attr_2': array([3,   2,   4,   10, 20]), 
                                                   'attr_3': array([10, 100, 1000, 500, 0]),
                                                   'attr_4': array([100, 500, 0, 20, -30])
                     }
         )
     storage.write_table(table_name='choices', 
         table_data={'id': array([1, 2, 3, 4])}
         )
     agents = Dataset(in_storage=storage, in_table_name='agents', dataset_name='agent', id_name='id')
     choices = Dataset(in_storage=storage, in_table_name='choices', dataset_name='choice', id_name='id')
     ids = InteractionDataset(dataset1=agents, dataset2=choices, index1=array([0,1,3,4]), index2=array([1,2,3])) 
     result = ids.compute_variables(expression)
     should_be = array([[3, 10, 100], [2,100,500], [10,500, 20], [20, 0, -30]])
     self.assertEqual(ma.allequal(result, should_be), True)
     
     agents.touch_attribute('attr_2') # in order to recompute the expression
     choices.add_primary_attribute(name='name', data=array(['bus', 'car', 'tran', 'walk']))
     agents.add_primary_attribute(name='attr_tran', data=array([100, 1000, 10000, 5000,10]))
     result = ids.compute_variables(expression)
     should_be = array([[3, 100, 100], [2,1000,500], [10,5000, 20], [20, 10, -30]])
     self.assertEqual(ma.allequal(result, should_be), True)
Example #14
0
    def test_transformation(self):
        from numpy import array, ma

        a = array([9, 4, 25, 36])
        self.assertEqual(ma.allequal(try_transformation(a, "sqrt"), array([3, 2, 5, 6])), True)
        self.assertEqual(ma.allequal(try_transformation(a, "*2"), array([18, 8, 50, 72])), True)
 def test_focalmaximum(self):
     lo = FocalMaximum(self.l1,self.l2, buffersize=0)
     self.assertTrue(allequal(lo._data, self.l2._data))
     lo = FocalMaximum(self.l1,self.l2, buffersize=2)
     self.assertTrue(allequal(lo._data, self.l2._data))
     lo = FocalMaximum(self.l1,self.l2, buffersize=2,decomposition=columndecomposition)
     self.assertTrue(allequal(lo._data, self.l2._data))
 def test_ZonalMinimum_exec(self):
     lo=ZonalMinimum_exec(self.l12,self.l13)
     res=np.asarray([[1,1,1,2],[2,2,1,1],[1,1,1,1],[1,1,1,1]])
     self.assertTrue(allequal(lo._data,res))
     lo=ZonalMinimum_exec(self.l14,self.l13)
     res=np.asarray([[-5,-5,-5,-6],[-6,-6,-3,-3],[-3,-7,-7,-7],[-9,-9,-7,-9]])
     self.assertTrue(allequal(lo._data,res))
 def test_ZonalMaximum_exec(self):
     lo=ZonalMaximum_exec(self.l12,self.l13)
     res=np.asarray([[5,5,5,6],[6,6,3,3],[3,7,7,7],[9,9,7,9]])
     self.assertTrue(allequal(lo._data,res))
     lo=ZonalMaximum_exec(self.l14,self.l13)
     res=np.asarray([[-1,-1,-1,-2],[-2,-2,-1,-1],[-1,-1,-1,-1],[-1,-1,-1,-1]])
     self.assertTrue(allequal(lo._data,res))
 def test_add_nothing(self):
     projects = None
     m = AddProjectsToBuildings()
     m.run(projects, self.buildings)
     self.assertEqual(ma.allequal(self.buildings.get_attribute("residential_units"), array(10*[200, 0, 0])), True)
     self.assertEqual(ma.allequal(self.buildings.get_attribute("commercial_job_spaces"), array(10*[0, 100, 0])), True)
     self.assertEqual(ma.allequal(self.buildings.get_attribute("industrial_job_spaces"), array(10*[0, 0, 100])), True)
 def test_focalmean_np_exec(self):
     lo = FocalMean_np_exec(self.l1, buffersize=1)
     res = np.asarray([[1]*4]*4)
     self.assertTrue(allequal(lo._data, res))
     lo = FocalMean_np_exec(self.l2, buffersize=3,decomposition=columndecomposition)
     res = np.asarray([[2]*4]*4)
     self.assertTrue(allequal(lo._data, res))
 def test_create(self):
     proposals = self.dataset_pool.get_dataset("development_project_proposal")
     where_valid_units = where(proposals.get_attribute("units_proposed") > 0)[0]
     self.assert_(ma.allequal(self.dataset.get_id_attribute(), proposals.get_id_attribute()[where_valid_units]))
     self.assert_(ma.allequal(self.dataset.get_attribute("parcel_id"), 
                              proposals.get_attribute("parcel_id")[where_valid_units]))
     self.assert_(ma.allequal(self.dataset.get_attribute("template_id"), 
                              proposals.get_attribute("template_id")[where_valid_units]))
 def test_ZonalSum_exec(self):
     lo=ZonalSum_exec(self.l12,self.l13)
     res=np.asarray([[9,9,9,12],[12,12,6,6],[6,20,20,20],[18,18,20,18]])
     self.assertTrue(allequal(lo._data,res))
     lo=ZonalSum_exec(self.l14,self.l13)
     #To ensure ZonalSum operation by executor gives the correct output with negative values
     res=np.asarray([[-9,-9,-9,-12],[-12,-12,-6,-6],[-6,-20,-20,-20],[-18,-18,-20,-18]])
     self.assertTrue(allequal(lo._data,res))
 def test_zonalsum(self):
     lo=zonalsum(self.l12,self.l13)
     res=np.asarray([[9,9,9,12],[12,12,6,6],[6,20,20,20],[18,18,20,18]])
     self.assertTrue(allequal(lo._data,res))
     #To check ZonalSum operation with negative zonal values
     lo=zonalsum(self.l14,self.l13)
     res=np.asarray([[-9,-9,-9,-12],[-12,-12,-6,-6],[-6,-20,-20,-20],[-18,-18,-20,-18]])
     self.assertTrue(allequal(lo._data,res))
 def test_zonalmean(self):
     lo=zonalmean(self.l12,self.l13)
     res=np.asarray([[3,3,3,4],[4,4,2,2],[2,5,5,5],[6,6,5,6]])
     self.assertTrue(allequal(lo._data,res))
     #To check ZonalMean operation with negative zonal values
     lo=zonalmean(self.l14,self.l13)
     res=np.asarray([[-3,-3,-3,-4],[-4,-4,-2,-2],[-2,-5,-5,-5],[-6,-6,-5,-6]])
     self.assertTrue(allequal(lo._data,res))
 def test_zonalmaximum(self):
     lo=zonalmaximum(self.l12,self.l13)
     res=np.asarray([[5,5,5,6],[6,6,3,3],[3,7,7,7],[9,9,7,9]])
     self.assertTrue(allequal(lo._data,res))
     #To check ZonalMaximum operation with negative zonal values
     lo=zonalmaximum(self.l14,self.l13)
     res=np.asarray([[-1,-1,-1,-2],[-2,-2,-1,-1],[-1,-1,-1,-1],[-1,-1,-1,-1]])
     self.assertTrue(allequal(lo._data,res))
 def test_zonalminimum(self):
     lo=zonalminimum(self.l12,self.l13)
     res=np.asarray([[1,1,1,2],[2,2,1,1],[1,1,1,1],[1,1,1,1]])
     self.assertTrue(allequal(lo._data,res))
     #To check ZonalMinimum operation with negative zonal values
     lo=zonalminimum(self.l14,self.l13)
     res=np.asarray([[-5,-5,-5,-6],[-6,-6,-3,-3],[-3,-7,-7,-7],[-9,-9,-7,-9]])
     self.assertTrue(allequal(lo._data,res))
 def test_flush_dataset_correct_data(self):
     job_set = Dataset(self.job_set_resources, dataset_name="jobs")
     job_set.add_attribute(self.job_id, "job_id", metadata=AttributeType.PRIMARY)
     job_set.add_attribute(self.expected_sic_data, "sic", metadata=AttributeType.COMPUTED)
     job_set.flush_dataset()
     returned_sic_data = job_set.get_attribute("sic")
     returned_id_data = job_set.get_attribute("job_id")
     self.assert_(ma.allequal(returned_id_data,self.job_id))
     self.assert_(ma.allequal(returned_sic_data,self.expected_sic_data))
 def test_focalminimum_np(self):
     lo = FocalMinimum_np(self.l1,self.l2, buffersize=0)
     self.assertTrue(allequal(lo._data, self.l1._data))
     lo = FocalMinimum_np(self.l1,self.l2, buffersize=2)
     self.assertTrue(allequal(lo._data, self.l1._data))
     lo1=FocalMinimum_np(self.l1,lo, buffersize=1)
     self.assertTrue(allequal(lo1._data,lo._data))
     lo1=FocalMaximum(self.l1,lo, buffersize=1,decomposition=columndecomposition)
     self.assertTrue(allequal(lo1._data,lo._data))
 def test_ZonalMinority_exec(self):
     lo=ZonalMinority_exec(self.l12,self.l13)
     res=np.asarray([[1,1,1,2],[2,2,1,1],[1,1,1,1],[1,1,1,1]])
     self.assertTrue(allequal(lo._data,res))
     l12 = lst_to_layer([[5,5,5,6],[4,2,2,2],[3,6,6,6],[9,9,9,1]])
     l13 = lst_to_layer([[1,1,1,1],[2,2,2,2],[3,3,3,3],[4,4,4,4]])
     lo=ZonalMinority_exec(l12,l13)
     res=np.asarray([[6,6,6,6],[4,4,4,4],[3,3,3,3],[1,1,1,1]])
     self.assertTrue(allequal(lo._data,res))
Example #29
0
    def test_clip_to_zero_if_needed(self):
        from numpy import array, ma

        logger.enable_hidden_error_and_warning_words()
        result = clip_to_zero_if_needed(array([0,3,6,-4,8]), "test1")
        logger.disable_hidden_error_and_warning_words()
        self.assertEqual(ma.allequal(result, array([0,3,6,0,8])), True, msg = "Error in test_clip_to_zero_if_needed" )

        result = clip_to_zero_if_needed(array([0,3,6,4,8.5]), "test2")
 def test_focalMajority(self):
     lo = FocalMajority(self.l1, buffersize=0)
     self.assertTrue(allequal(lo._data, self.l1._data))
     lo = FocalMajority(self.l1, buffersize=1)
     self.assertTrue(allequal(lo._data, self.l1._data))
     res = np.asarray([[1,1,2,3],[1,1,2,3],[1,1,2,2],[1,1,3,2]])
     lo = FocalMajority(self.l11, buffersize=1)
     self.assertTrue(allequal(res,lo._data))
     lo = FocalMajority(self.l11, buffersize=1,decomposition=columndecomposition)
     self.assertTrue(allequal(res,lo._data))
    def test_my_inputs(self):
        number_of_commercial_jobs = array([12, 39, 0, 10])
        commercial_sqft = array([1200, 16, 3900, 15])
        commercial_sqft_per_job = array([20, 3, 30, 0])

        values = VariableTestToolbox().compute_variable(self.variable_name, {
            "zone": {
                "number_of_commercial_jobs": number_of_commercial_jobs,
                "buildings_commercial_sqft": commercial_sqft,
                "commercial_sqft_per_job": commercial_sqft_per_job
            }
        },
                                                        dataset="zone")
        should_be = array([1200 / 20.0 - 12, 0, 3900 / 30.0, 0])

        self.assertEqual(ma.allequal(values, should_be),
                         True,
                         msg="Error in " + self.variable_name)
Example #32
0
 def test_load_specification_with_definition_with_implicit_coefficients(
         self):
     """Coeficient names should be aliases of the variables."""
     specification = {
         "_definition_": [
             "urbansim.gridcell.population",
             "urbansim.gridcell.average_income",
             "urbansim.gridcell.is_near_arterial",
             "lage = ln(urbansim.gridcell.average_age+1)",
         ],
         1: ["population", "average_income", "lage"],
         2: [
             "is_near_arterial",
             ("urbansim.gridcell.is_near_highway", "BHWY"),
         ],
     }
     result = load_specification_from_dictionary(specification)
     vars = result.get_variable_names()
     coefs = result.get_coefficient_names()
     subm = result.get_submodels()
     self.assert_(
         alltrue(coefs == array([
             "population", "average_income", "lage", "is_near_arterial",
             "BHWY"
         ])),
         msg=
         "Error in test_load_specification_with_definition_with_implicit_coefficients (coefficients)"
     )
     self.assert_(
         alltrue(vars == array([
             "population", "average_income", "lage", "is_near_arterial",
             "is_near_highway"
         ])),
         msg=
         "Error in test_load_specification_with_definition_with_implicit_coefficients (variables)"
     )
     self.assert_(
         ma.allequal(subm, array([1, 1, 1, 2, 2])),
         msg=
         "Error in test_load_specification_with_definition_with_implicit_coefficients (submodels)"
     )
     # test data type
     self.assert_(subm.dtype.name == "int16",
                  msg="Error in data type of submodels.")
Example #33
0
 def test_load_specification_with_definition_with_equations(self):
     specification = {
         "_definition_": [
             "pop = urbansim.gridcell.population",
             "inc = urbansim.gridcell.average_income",
             "art = urbansim.gridcell.is_near_arterial",
         ],
         -2: {
             "equation_ids": (1, 2),
             "pop": ("bpop", 0),
             "inc": (0, "binc"),
             "art": ("bart", 0),
             "constant": ("asc", 0)
         }
     }
     result = load_specification_from_dictionary(specification)
     vars = result.get_variable_names()
     coefs = result.get_coefficient_names()
     eqs = result.get_equations()
     lvars = result.get_long_variable_names()
     self.assert_(
         alltrue(coefs == array(["asc", "bart", "bpop", "binc"])),
         msg=
         "Error in test_load_specification_with_definition_with_equations (coefficients)"
     )
     self.assert_(
         alltrue(vars == array(["constant", "art", "pop", "inc"])),
         msg=
         "Error in test_load_specification_with_definition_with_equations (variables)"
     )
     self.assert_(
         ma.allequal(eqs, array([1, 1, 1, 2])),
         msg=
         "Error in test_load_specification_with_definition_with_equations (equations)"
     )
     self.assert_(
         alltrue(lvars == array([
             "constant", "art = urbansim.gridcell.is_near_arterial",
             "pop = urbansim.gridcell.population",
             "inc = urbansim.gridcell.average_income"
         ])),
         msg=
         "Error in test_load_specification_with_definition_with_equations (long names of variables)"
     )
Example #34
0
    def test_my_inputs(self):
        storage = StorageFactory().get_storage('dict_storage')
        
        parcels_table_name = 'parcels'
        
        storage.write_table(
                table_name=parcels_table_name,
                table_data={
                    'parcel_id':array([1,2,3,4,5]),
                    'grid_id':array([1, 2, 1, 4, 3])
                    },
            )

        parcels = ParcelDataset(in_storage=storage, in_table_name=parcels_table_name)        
        
        city_storage = StorageFactory().get_storage('dict_storage')
        
        cities_table_name = 'cities'
        
        city_storage.write_table(
                table_name=cities_table_name,
                table_data={
                    'city_id':array([63000, 56000, 99999]),
                    'city_name':array(["seattle", "bellevue", "skykomish"])
                    },
            )

        cities = CityDataset(in_storage=city_storage, in_table_name=cities_table_name)
        
        values = VariableTestToolbox().compute_variable(self.variable_name, 
            data_dictionary = {
                'parcel':parcels,
                'city':cities,
                'gridcell':{
                            'grid_id':array([1,     2,     3, 4]),
                            'city_id':array([63000, 56000, 0, 63000])}
                }, 
            dataset = 'parcel'
            )
            
        should_be = array([True, False, True, True, False])
        
        self.assert_(ma.allequal(values, should_be),
            'Error in ' + self.variable_name)
Example #35
0
    def test_my_inputs(self):
        grid_id = array([2, 1, 3])
        faz_id = array([4, 5, 6])

        values = VariableTestToolbox().compute_variable(
            self.variable_name, {
                "development_project": {
                    "grid_id": grid_id
                },
                "gridcell": {
                    "faz_id": faz_id
                }
            },
            dataset="development_project")
        should_be = array([5, 4, 6])

        self.assertEqual(ma.allequal(values, should_be),
                         True,
                         msg="Error in " + self.variable_name)
Example #36
0
    def test_my_inputs(self):
        grid_id = array([2, 1, 3])
        faz_id = array([4, 5, 6])

        values = VariableTestToolbox().compute_variable(self.variable_name, {
            "household": {
                "grid_id": grid_id
            },
            "gridcell": {
                "grid_id": array([1, 2, 3], dtype="int32"),
                "faz_id": faz_id
            }
        },
                                                        dataset="household")
        should_be = array([5, 4, 6])

        self.assertEqual(ma.allequal(values, should_be),
                         True,
                         msg="Error in " + self.variable_name)
Example #37
0
    def test_my_inputs(self):

        values = VariableTestToolbox().compute_variable(
            self.variable_name,
            {
                "land_cover": {
                    #"lct":array([1, 2, 3]),
                    "devgrid_id": array([1, 1, 2, -9999])
                },
                "gridcell": {
                    "grid_id": array([1, 2, 3]),
                    "development_type_id": array([1, 5, 3])
                }
            },
            dataset="land_cover")
        should_be = array([1, 1, 5, -9999])

        self.assert_(ma.allequal(values, should_be),
                     msg="Error in " + self.variable_name)
Example #38
0
    def test_person_dataset(self):
        households_data = {
            "household_id":arange(4)+1,
            "building_id": array([3,6,1,2], dtype=int32),
            "persons": array([1,2,2,4], dtype=int32)
            }
        household_characteristics_for_ht_data = {
            "characteristic": array(2*['persons']),
            "min": array([1, 3]),
            "max": array([2,-1])
            }
        person_data = {
            "person_id": arange(9)+1,
            "household_id": array([1,2,2,3,3,4,4,4,4]),
            "job_id": array([30, 50, 0, 1, 23, 54, 78, 2, 6]),
                           }
        annual_household_control_totals_data = {
            "year": array(2*[2000]),
            "persons": array([0,1]),
            "total_number_of_households": array([0, 4])
            }
        
        storage = StorageFactory().get_storage('dict_storage')

        storage.write_table(table_name='hh_set', table_data=households_data)
        hh_set = HouseholdDataset(in_storage=storage, in_table_name='hh_set')

        storage.write_table(table_name='prs_set', table_data=person_data)
        prs_set = PersonDataset(in_storage=storage, in_table_name='prs_set')
        
        storage.write_table(table_name='hct_set', table_data=annual_household_control_totals_data)
        hct_set = ControlTotalDataset(in_storage=storage, in_table_name='hct_set', what="household", id_name=["year", "persons"])

        storage.write_table(table_name='hc_set', table_data=household_characteristics_for_ht_data)
        hc_set = HouseholdCharacteristicDataset(in_storage=storage, in_table_name='hc_set')

        model = HouseholdTransitionModel(debuglevel=3)
        model.run(year=2000, person_set=prs_set, household_set=hh_set, control_totals=hct_set, characteristics=hc_set)
        # The run should remove the first three households and first 5 persons and add 3 copies of the last household, i.e. 12 persons
        self.assertEqual(prs_set.size(), 16, "Error in size of the person_set. Should be 16, is %s." % prs_set.size())
        self.assertEqual(ma.allequal(prs_set.get_attribute('household_id'), array([4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7])), True,
                                    "Error in assigning household_id to new persons.")
    def test_my_inputs(self):
        #declare an array of four locations, each with the specified sector ID below

        commercial_sqft = array([1000, 500, 5000, 233])
        commercial_sqft_per_job = array([20, 0, 100, 33])

        values = VariableTestToolbox().compute_variable(self.variable_name, {
            "zone": {
                "buildings_commercial_sqft": commercial_sqft,
                "commercial_sqft_per_job": commercial_sqft_per_job
            }
        },
                                                        dataset="zone")

        #notice that the computation code above purposely truncates decimal results,
        #which makes sense because fractions of jobs don't exist
        should_be = array([50.0, 0.0, 50.0, 7.0])
        self.assertEqual(ma.allequal(values, should_be),
                         True,
                         msg="Error in " + self.variable_name)
    def test_my_inputs(self):
        storage = StorageFactory().get_storage('dict_storage')        
        
        storage.write_table(
            table_name='gridcells',
            table_data={
                'grid_id': array([1,2,3]),
                'is_in_development_type_group_mixed_use': array([0,1,1]),
            }
        )
        storage.write_table(
            table_name='households',
            table_data={
                'household_id': array([1,2,3,4,5,6]),
                'is_young': array([1,0,1,0,0,1])
            }
        )
        storage.write_table(
            table_name='urbansim_constants',
            table_data={
                "young_age": array([30]),
            }
        )
        
        dataset_pool = DatasetPool(package_order=['urbansim'],
                                   storage=storage)

        household_x_gridcell = dataset_pool.get_dataset('household_x_gridcell')
        household_x_gridcell.compute_variables(self.variable_name, 
                                               dataset_pool=dataset_pool)
        values = household_x_gridcell.get_attribute(self.variable_name)
        
        should_be = array([[0,1,1],
                           [0,0,0],
                           [0,1,1],
                           [0,0,0],
                           [0,0,0],
                           [0,1,1]])
        
        self.assert_(ma.allequal(values, should_be), 
                     msg="Error in " + self.variable_name)
    def test_my_inputs(self):
        """Total number of residential of buildings.
        """
        values = VariableTestToolbox().compute_variable(self.variable_name,
            data_dictionary = {
                'zone':{
                    'zone_id':array([1,2,3]),
                    },
                'building': {
                    'is_building_type_residential':array([1,0,1,0,1,1]),
                    'zone_id':array([2,3,1,1,2,1]),
                    'building_size':array([100, 350, 1000, 0, 430, 95])
                    },
                }, 
            dataset = 'zone'
            )
            
        should_be = array([1095, 530, 0])

        self.assert_(ma.allequal(values, should_be),
            'Error in ' + self.variable_name)
Example #42
0
    def test_lottery_choices_without_index_with_capacity_constrains_equal_units(
            self):
        probabilities = array(10 * [[0.3, 0.2, 0.1, 0.4]] +
                              10 * [[0.25, 0.25, 0.25, 0.25]] +
                              10 * [[0.7, 0.1, 0.1, 0.1]])
        capacity = array([10, 3, 5, 100000])
        units = array(30 * [1], dtype="int32")
        resources = Resources({"capacity": capacity, "agents_units": units})

        def run():
            lottery = lottery_choices()
            choices = lottery.run(probabilities, resources=resources)
            return lottery.get_choice_histogram(units, choices, capacity.size)

        for i in range(10):
            result = run()
            self.assertEqual(
                ma.allequal(result <= array([10, 3, 5, 100000]),
                            array([True, True, True, True])),
                True,
                msg="Error in lottery_choices when capacity constrains.")
Example #43
0
    def test_my_inputs(self):
        number_of_commercial_jobs = array([12, 39])
        commercial_sqft = array([1200, 16, 3900, 15])
        commercial_sqft_per_job = array([20, 3, 30, 0])

        values = VariableTestToolbox().compute_variable(self.variable_name, {
            "zone": {
                "number_of_commercial_jobs": number_of_commercial_jobs
            },
            "gridcell": {
                "commercial_sqft": commercial_sqft,
                "commercial_sqft_per_job": commercial_sqft_per_job,
                "zone_id": array([1, 1, 2, 2])
            }
        },
                                                        dataset="zone")
        should_be = array([93, 222])

        self.assertEqual(ma.allequal(values, should_be),
                         True,
                         msg="Error in " + self.variable_name)
    def test_full_tree(self):
        """This is an "interaction variable", i.e. it depends on both the gridcell and household
        datasets, and thus, it is in the household_x_gridcell "category"."""

        #declare five households, three of which whose age of head is 40, 4th is 50, 5th is 35
        age_of_head = array([40, 40, 40, 50, 35])
        #declare four gridcells, two of which are in Forecast Analysis Zone #1, and others in FAZ #2, #3
        gridcell_faz_id = array([1, 3, 2, 1])
        #assign gridcell id's to the five households. here, households #1 and #3 are in the same gridcell
        household_grid_id = array([2, 1, 2, 4, 4])

        #Imagine a 5x4 grid, where the origin is at the upper left. on the vertical axis are the five households,
        #and on the horizontal axis are the four gridcells, numbered 1-4 (grid id).
        #fill in each square by answering the question:
        #for the age of this row's household, how many other households in that column's gridcell faz are
        #have the same age? if the row's household lives in that faz, include it in the count.

        values = VariableTestToolbox().compute_variable(
            self.variable_name, {
                "gridcell": {
                    "faz_id": gridcell_faz_id
                },
                "household": {
                    "age_of_head": age_of_head,
                    "grid_id": household_grid_id
                },
                "faz": {
                    "faz_id": array([1, 2, 3])
                }
            },
            dataset="household_x_gridcell")

        #what the result says here is that for household #1 (age = 20), there is 1 household of the same age
        #in gridcelll #1's FAZ. there are 2 households of the same age in gridcell #2's FAZ...
        should_be = array([[1, 2, 0, 1], [1, 2, 0, 1], [1, 2, 0, 1],
                           [1, 0, 0, 1], [1, 0, 0, 1]])

        self.assertEqual(ma.allequal(values, should_be),
                         True,
                         msg="Error in " + self.variable_name)
Example #45
0
 def test_load_specification_with_definition(self):
     specification = {
         "_definition_":
         [("urbansim.gridcell.population", "BPOP"),
          ("urbansim.gridcell.average_income", "BINC"),
          ("urbansim.gridcell.is_near_arterial", "BART"),
          ("lage = ln(urbansim.gridcell.average_age+1)", "BAGE"),
          ("constant", "C", 1.5)],
         1: ["population", "average_income", "lage"],
         2: [
             "is_near_arterial",
             "constant",
             ("urbansim.gridcell.is_near_highway", "BHWY"),
         ],
     }
     result = load_specification_from_dictionary(specification)
     vars = result.get_variable_names()
     coefs = result.get_coefficient_names()
     subm = result.get_submodels()
     fixedval = result.get_fixed_values()
     self.assert_(
         alltrue(
             coefs == array(["BPOP", "BINC", "BAGE", "BART", "C", "BHWY"])),
         msg=
         "Error in test_load_specification_with_definition (coefficients)")
     self.assert_(
         alltrue(vars == array([
             "population", "average_income", "lage", "is_near_arterial",
             "constant", "is_near_highway"
         ])),
         msg="Error in test_load_specification_with_definition (variables)")
     self.assert_(
         ma.allequal(subm, array([1, 1, 1, 2, 2, 2])),
         msg="Error in test_load_specification_with_definition (submodels)")
     self.assert_(
         ma.allclose(fixedval, array([0, 0, 0, 0, 1.5, 0])),
         msg=
         "Error in test_load_specification_with_definition (fixed_values)")
Example #46
0
    def test_create(self):
        proposals_components = self.dataset_pool.get_dataset(
            "development_project_proposal_component")
        template_ids = self.proposal_components.get_attribute("template_id")

        self.assert_(
            ma.allequal(self.proposal_components.size(),
                        proposals_components.size()))
        self.assert_(
            self.proposal_components.get_attribute("proposal_id").sum(),
            proposals_components.get_attribute("proposal_id").sum())
        self.assert_(
            (template_ids == 1).sum(),
            (proposals_components.get_attribute("template_id") == 1).sum())
        self.assert_(
            (template_ids == 2).sum(),
            (proposals_components.get_attribute("template_id") == 2).sum())
        self.assert_(
            (template_ids == 3).sum(),
            (proposals_components.get_attribute("template_id") == 3).sum())
        self.assert_(
            self.proposal_components.get_attribute("component_id").sum(),
            proposals_components.get_attribute("component_id").sum())
Example #47
0
    def test_boundingbox_set_nparray(self):
        arr = np.asarray([[5] * 10] * 10) # Create a 10x10 array, each element has a value of 5
        self.bb4.set_nparray(arr,1,-10)
        #print arr
        #b1.set_nparray(arr, 1, 0)
        self.assertTrue(allequal(self.bb4._data, arr))
        self.assertEqual(self.bb4.cellsize,1)
        self.assertEqual(self.bb4.nodata_value,-10)
        self.assertEqual(self.bb4.data_structure,Datastructure.array)

        # Negative cellsize
        with self.assertRaises(PCMLInvalidInput):
            self.bb3.set_nparray(arr,-1,-10)
        # Zero cellsize
        with self.assertRaises(PCMLInvalidInput):
            self.bb3.set_nparray(arr,0,-10)
        # None cellsize
        with self.assertRaises(PCMLInvalidInput):
            self.bb3.set_nparray(arr,None,-10)
        # None array 
        nonearray=None
        with self.assertRaises(PCMLInvalidInput):
            self.bb2.set_nparray(nonearray,1,-10)
            def test(self):
                cache_dir = os.path.join(self.temp_dir, 'cache')
                data = {
                    self._id_name: array([1, 2, 3]),
                    'population': array([10, 20, 30]),
                }
                self._write_data_to_year(data, cache_dir, 2000)

                data = {
                    self._id_name: array([1, 2, 3]),
                    'population': array([11, 21, 31]),
                }
                self._write_data_to_year(data, cache_dir, 2001)

                data = {
                    self._id_name: array([1, 2, 3]),
                    'population': array([12, 23, 34]),
                }
                self._write_data_to_year(data, cache_dir, 2002)

                attribute_cache = AttributeCache(cache_directory=cache_dir)
                SimulationState(new_instance=True,
                                base_cache_dir=self.temp_dir)
                SimulationState().set_cache_directory(cache_dir)
                SessionConfiguration(new_instance=True,
                                     in_storage=attribute_cache)

                SimulationState().set_current_time(2002)
                dataset_pool_2002 = DatasetPool(package_order=['urbansim'],
                                                storage=attribute_cache)
                dataset = dataset_pool_2002.get_dataset(self._dataset_name)
                variable_name = '%s.%s.absolute_population_difference_from_2000' % (
                    self._package_name, self._dataset_name)
                dataset.compute_variables([variable_name],
                                          dataset_pool=dataset_pool_2002)
                pop_2002 = dataset.get_attribute(variable_name)
                self.assert_(ma.allequal(pop_2002, array([2, 3, 4])))
Example #49
0
    def test_load_specification_with_definition_nests(self):
        specification = {
            "_definition_": [
                ("pop = urbansim.gridcell.population", "bpop"),
                "inc = urbansim.gridcell.average_income",
                "art = urbansim.gridcell.is_near_arterial",
            ],
            -2: {
                'name': 'nest_id',
                1: ["pop", "inc", "constant"],
                2: ["art"]
            }
        }
        result = load_specification_from_dictionary(specification)
        vars = result.get_variable_names()
        coefs = result.get_coefficient_names()
        other = result.get_other_fields()

        self.assert_(
            alltrue(coefs == array([
                "bpop",
                "inc",
                "constant",
                "art",
            ])),
            msg=
            "Error in test_load_specification_with_definition_nests (coefficients)"
        )
        self.assert_(
            alltrue(vars == array(["pop", "inc", "constant", "art"])),
            msg=
            "Error in test_load_specification_with_definition_nests (variables)"
        )
        self.assert_(
            ma.allequal(other['dim_nest_id'], array([1, 1, 1, 2])),
            msg="Error in test_load_specification_with_definition_nests (nests)"
        )
    def test_my_inputs(self):
        storage = StorageFactory().get_storage('dict_storage')

        building_types_table_name = 'building_types'
        storage.write_table(table_name=building_types_table_name,
                            table_data={
                                'building_type_id':
                                array([1, 2]),
                                'name':
                                array(['residential', 'commercial']),
                                'units':
                                array(['residential_units', 'commercial_sqft'])
                            })

        building_types = BuildingTypeDataset(
            in_storage=storage, in_table_name=building_types_table_name)

        values = VariableTestToolbox().compute_variable(
            self.variable_name,
            data_dictionary={
                'zone': {
                    'zone_id': array([1, 2])
                },
                'gridcell': {
                    'developable_maximum_commercial_sqft':
                    array([1200, 16, 3900, 15]),
                    'zone_id':
                    array([1, 1, 2, 2])
                },
                'building_type': building_types
            },
            dataset='zone')

        should_be = array([1216, 3915])

        self.assert_(ma.allequal(values, should_be),
                     'Error in ' + self.variable_name)
Example #51
0
    def test_my_inputs(self):
        storage = StorageFactory().get_storage('dict_storage')

        storage.write_table(table_name='households',
                            table_data={
                                'household_id': array([1, 2, 3, 4]),
                                'income': array([45000, 50000, 75000, 100000]),
                            })

        dataset_pool = DatasetPool(package_order=['urbansim'], storage=storage)
        dataset_pool._add_dataset('urbansim_constant', MockConstant())

        household = dataset_pool.get_dataset('household')
        household.compute_variables(self.variable_name,
                                    dataset_pool=dataset_pool)
        values = household.get_attribute(self.variable_name)

        should_be = array([1, 1, 0, 0])

        self.assert_(ma.allequal(
            values,
            should_be,
        ),
                     msg="Error in " + self.variable_name)
Example #52
0
    def test_my_inputs(self):
        storage = StorageFactory().get_storage('dict_storage')

        storage.write_table(table_name='jobs',
                            table_data={
                                'job_id': array([1, 2, 3, 4]),
                                'sector_id': array([1, 3, 2, 3]),
                            })
        storage.write_table(table_name='employment_sectors',
                            table_data={
                                'sector_id': array([1, 2]),
                                'name': array(["basic", "retail"]),
                            })
        storage.write_table(table_name='employment_adhoc_sector_groups',
                            table_data={
                                'group_id': array([1, 2]),
                                'name': array(["basic", "retail"]),
                            })
        storage.write_table(
            table_name='employment_adhoc_sector_group_definitions',
            table_data={
                'sector_id': array([1, 2]),
                'group_id': array([1, 2]),
            })

        dataset_pool = DatasetPool(package_order=['urbansim'], storage=storage)
        dataset_pool._add_dataset('employment_sector', mock_employmentsector())

        job = dataset_pool.get_dataset('job')
        job.compute_variables(self.variable_name, dataset_pool=dataset_pool)
        values = job.get_attribute(self.variable_name)

        should_be = array([True, False, False, False])

        self.assert_(ma.allequal(values, should_be),
                     msg="Error in " + self.variable_name)
            def test_at_year_2000(self):
                cache_dir = os.path.join(self.temp_dir, 'cache')
                data = {
                    self._id_name: array([1, 2, 3]),
                    'population': array([10, 20, 30]),
                }
                self._write_data_to_year(data, cache_dir, 2000)

                attribute_cache = AttributeCache(cache_directory=cache_dir)
                SimulationState(new_instance=True,
                                base_cache_dir=self.temp_dir)
                SimulationState().set_cache_directory(cache_dir)
                SessionConfiguration(new_instance=True,
                                     in_storage=attribute_cache)

                SimulationState().set_current_time(2000)
                dataset_pool_2000 = DatasetPool(package_order=['urbansim'],
                                                storage=attribute_cache)
                dataset = dataset_pool_2000.get_dataset(self._dataset_name)
                variable_name = 'sanfrancisco.%s.percent_population_difference_from_2000_max_9999' % self._dataset_name
                dataset.compute_variables([variable_name],
                                          dataset_pool=dataset_pool_2000)
                pop_2000 = dataset.get_attribute(variable_name)
                self.assert_(ma.allequal(pop_2000, array([0, 0, 0])))
    def test(self):
        storage = StorageFactory().get_storage('dict_storage')

        storage.write_table(table_name='zones',
                            table_data={
                                'zone_id': array([1, 2, 3, 4, 5]),
                            })
        storage.write_table(table_name='buildings',
                            table_data={
                                'building_id': array([1, 2, 3, 4, 5, 6]),
                                'zone_id': array([1, 2, 3, 4, 2, 2]),
                            })

        dataset_pool = DatasetPool(package_order=['urbansim'], storage=storage)

        gridcell = dataset_pool.get_dataset('zone')
        gridcell.compute_variables(self.variable_name,
                                   dataset_pool=dataset_pool)
        values = gridcell.get_attribute(self.variable_name)

        should_be = array([1, 3, 1, 1, 0])

        self.assert_(ma.allequal(values, should_be),
                     msg="Error in " + self.variable_name)
    def test_add_three_projects(self):
        project_data = {
            'project_id': arange(1, 12),
            'zone_id': array([3, 5, 7, 8, 10] + range(1, 5) + [2, 10]),
            'building_type_id': array([1] * 5 + [2] * 4 + [3] * 2),
            'residential_units':
            array([100, 300, 1, 50, 6] + 4 * [0] + 2 * [0]),
            'commercial_job_spaces': array(5 * [0] + 3 * [20] + [5] + 2 * [0]),
            'industrial_job_spaces': array(5 * [0] + 4 * [0] + [50, 30]),
        }

        projects = self.get_projects(project_data)

        m = AddProjectsToBuildings()
        m.run(projects,
              self.buildings,
              quantity_attribute_names=[
                  "residential_units", "commercial_job_spaces",
                  "industrial_job_spaces"
              ])
        self.assertEqual(
            ma.allequal(
                self.buildings.get_attribute("residential_units"),
                array([
                    200,
                    0,
                    0,
                    200,
                    0,
                    0,
                    300,
                    0,
                    0,
                    200,
                    0,
                    0,
                    500,
                    0,
                    0,
                    200,
                    0,
                    0,
                    201,
                    0,
                    0,
                    250,
                    0,
                    0,
                    200,
                    0,
                    0,
                    206,
                    0,
                    0,
                ])), True)
        self.assertEqual(
            ma.allequal(self.buildings.get_attribute("commercial_job_spaces"),
                        array(3 * [0, 120, 0] + [0, 105, 0] +
                              6 * [0, 100, 0])), True)
        self.assertEqual(
            ma.allequal(
                self.buildings.get_attribute("industrial_job_spaces"),
                array([0, 0, 100, 0, 0, 150] + 7 * [0, 0, 100] + [0, 0, 130])),
            True)
Example #56
0
 def test_LocalMult_np(self):
     lo = LocalMult_np(self.l1, self.l2)
     self.assertTrue(allequal(lo._data, self.l2._data))
     lo = LocalMult_np(self.l2, self.l3)
     self.assertTrue(allequal(lo._data, [[10] * 4] * 4))
Example #57
0
 def test_add(self):
     lo = self.l1 + self.l2
     self.assertTrue(allequal(lo._data, [[3] * 4] * 4))
 def test_to_4(self):
     values = self.get_values(3, 4)
     should_be = array([7, 9])
     self.assert_(ma.allequal(values, should_be),
                  msg="Error in " + self.variable_name)
 def test_to_2(self):
     values = self.get_values(2, 2)
     should_be = array([0, 10])
     self.assert_(ma.allequal(values, should_be),
                  msg="Error in " + self.variable_name)
Example #60
0
 def test_mult(self):
     lo = self.l1 * self.l2
     self.assertTrue(allequal(lo._data, self.l2._data))
     lo = self.l2 * self.l3
     self.assertTrue(allequal(lo._data, [[10] * 4] * 4))