FirmMultiTechnologies

class abce.agents.FirmMultiTechnologies

Bases: object

create_ces(output, gamma, multiplier=1, shares=None)

creates a CES production function

A production function is a production process that produces the given input goods according to the CES formula to the output good:

\(Q = F \cdot \left[\sum_{i=1}^n a_{i}X_{i}^{\gamma}\ \right]^{\frac{1}{\gamma}}\)

Production_functions are than used as an argument in produce, predict_vector_produce and predict_output_produce.

Args:

‘output’:

Name of the output good

gamma:

elasticity of substitution \(= s =\frac{1}{1-\gamma}\)

multiplier:

CES multiplier \(F\)

shares:

\(a_{i}\) = Share parameter of input i, \(\sum_{i=1}^n a_{i} = 1\) when share_parameters is not specified all inputs are weighted equally and the number of inputs is flexible.

Returns:

A production_function that can be used in produce etc.

Example:

self.stuff_production_function = self.create_ces('stuff', gamma=0.5, multiplier=1, shares={'labor': 0.25, 'stone':0.25, 'wood':0.5})
self.produce(self.stuff_production_function, {'stone' : 20, 'labor' : 1, 'wood': 12})

create_cobb_douglas(output, multiplier, exponents)

creates a Cobb-Douglas production function

A production function is a production process that produces the given input goods according to the Cobb-Douglas formula to the output good. Production_functions are than used as an argument in produce, predict_vector_produce and predict_output_produce.

Args:

‘output’:

Name of the output good

multiplier:

Cobb-Douglas multiplier

{‘input1’: exponent1, ‘input2’: exponent2 …}:

dictionary containing good names ‘input’ and corresponding exponents

Returns:

A production_function that can be used in produce etc.

Example:

def init(self):

self.plastic_production_function = self.create_cobb_douglas(‘plastic’, {‘oil’ : 10, ‘labor’ : 1}, 0.000001)

…

def producing(self):

self.produce(self.plastic_production_function, {‘oil’ : 20, ‘labor’ : 1})

create_leontief(output, utilization_quantities)

creates a Leontief production function

A production function is a production process that produces the given input goods according to the Leontief formula to the output good. Production_functions are than used as an argument in produce, predict_vector_produce and predict_output_produce.

Args:

‘output’:

Name of the output good

multiplier:

dictionary of multipliers it min(good1 * a, good2 * b, good3 * c…)

{‘input1’: exponent1, ‘input2’: exponent2 …}:

dictionary containing good names ‘input’ and corresponding exponents

Returns:

A production_function that can be used in produce etc.

Example: self.car_production_function = self.create_leontief(‘car’, {‘wheel’ : 4, ‘chassi’ : 1}) self.produce(self.car_production_function, {‘wheel’ : 20, ‘chassi’ : 5})

create_production_function_many_goods(formula, use)

creates a production function that produces many goods

A production function is a production process that produces several output goods from several input goods. It does so according to the formula given. Input goods are usually partially or completely used up. Production_functions can then ben used as an argument in abce.FirmMultiTechnologies.produce(), abce.FirmMultiTechnologies._predict_produce_output() abce.FirmMultiTechnologies._predict_produce_input()

create_production_function_fast is faster but more complicated

Args:

formula:

this is a method, that takes a goods dictionary as an input and returns a dictionary with the newly created goods.

use:

a dictionary of how much percent of each good is used up in the process

Returns:

A production_function that can be used in produce etc.

Example:

def init(self):
    ...
    def production_function(goods)
        output = {'soft_rubber': goods['a'] ** 0.25 * goods['b'] ** 0.5 * goods['c'] ** 0.25,
                  'hard_rubber': goods['a'] ** 0.1 * goods['b'] ** 0.2 * goods['c'] ** 0.01,
                  'waste': goods['b'] / 2}
        return output

    use = {'a': 1, 'b': 0.1, 'c': 0}

    self.production_function = self.create_production_function(production_function, use)

def production(self):
    self.produce(self.production_function, {'a' : 1, 'b' : 2, 'c': 5})

create_production_function_one_good(formula, output, use)

creates a production function, that produces one good

A production function is a production process that produces the given input goods according to the formula to the output goods and uses up some or all of the input goods. Production_functions are than used as an argument in produce, predict_vector_produce and predict_output_produce.

create_production_function_fast is faster but more complicated

Args:

formula:

this is a method, that takes the possession dictionary as an input and returns a float.

output:

the name of the good ‘string’

use:

a dictionary of how much percent of each good is used up in the process

Returns:

A production_function that can be used in produce etc.

Example:

def init(self):
    ...
    def production_function(goods)
        return goods['a'] ** 0.25 * goods['b'] ** 0.5 * goods['c'] ** 0.25

    use = {'a': 1, 'b': 0.1, 'c': 0}

    self.production_function = self.create_production_function(production_function, use)

def production(self):
    self.produce(self.production_function, {'a' : 1, 'b' : 2}

net_value(produced_goods, used_goods, price_vector)

Calculates the net_value of a goods_vector given a price_vector

goods_vectors are vector, where the input goods are negative and the output goods are positive. When we multiply every good with its according price we can calculate the net_value of the corresponding production. goods_vectors are produced by predict_produce(.)

Args:

produced_goods:

a dictionary with goods and quantities

used_goods: e.G. {‘car’: 1, ‘metal’: -1200, ‘tire’: -4, ‘plastic’: -21} price_vector: a dictionary with goods and prices (see example)

Example:

prices = {'car': 50000, 'tire': 100, 'metal': 10, 'plastic':  0.5}
value_one_car = net_value(predict_produce(car_production_function, one_car), prices)
value_two_cars = net_value(predict_produce(car_production_function, two_cars), prices)
if value_one_car > value_two_cars:
   produce(car_production_function, one_car)
else:
   produce(car_production_function, two_cars)

predict_net_value(production_function, input_goods, price_vector)

Predicts the net value of a production, given a price vector

Args:

production_function:

a production function

input_goods:

the goods to be used in the simulated production

price_vector:

vector of prices for input and output goods

Example:

input_goods = {'wheels': 4, 'chassi': 1}
price_vector = {'wheels': 10, 'chassi': 100, 'car':1000}
self.predict_net_value(self.consumption_good_production_function, input_goods, price_vector)

>>> 860

predict_produce_input(production_function, input_goods)

Returns a vector with input of goods

Predicts the use of input goods, for a production.

Args:

production_function:

A production_function produced with create_production_function, create_cobb_douglas or create_leontief

input_goods: {‘input_good1’: amount1, ‘input_good2’: amount2 …}:

dictionary containing the amount of input good used for the production.

Example:

print(A._predict_produce_input(car_production_function, two_cars))

>>> {'wheels': 4, 'chassi': 1}

predict_produce_output(production_function, input_goods)

Predicts the output of a certain input vector and for a given

production function

Predicts the production of produce(production_function, input_goods)

Args:

production_function:
    A production_function produced with
    create_production_function, create_cobb_douglas or create_leontief
input_goods {'input_good1': amount1, 'input_good2': amount2 ...}:
    dictionary containing the amount of input good used for the production.

Returns:

A dictionary of the predicted output

Example:

print(A._predict_produce_output(car_production_function, two_cars))
>>> {'car': 2}

produce(production_function, input_goods)

Produces output goods given the specified amount of inputs.

Transforms the Agent’s goods specified in input goods according to a given production_function to output goods. Automatically changes the agent’s belonging. Raises an exception, when the agent does not have sufficient resources.

Args:

production_function:

A production_function produced with py:meth:~abceagent.FirmMultiTechnologies..create_production_function, py:meth:~abceagent.FirmMultiTechnologies..create_cobb_douglas or py:meth:~abceagent.FirmMultiTechnologies..create_leontief

input goods {dictionary}:

dictionary containing the amount of input good used for the production.

Raises:

NotEnoughGoods:

This is raised when the goods are insufficient.

Example:

car = {'tire': 4, 'metal': 2000, 'plastic':  40}
bike = {'tire': 2, 'metal': 400, 'plastic':  20}
try:
    self.produce(car_production_function, car)
except NotEnoughGoods:
    A.produce(bike_production_function, bike)

produce_use_everything(production_function)

Produces output goods from all input goods, used in this production_function, the agent owns.

Args:

production_function: A production_function produced with
py:meth:`~abceagent.FirmMultiTechnologies.create_production_function`, py:meth:`~abceagent.FirmMultiTechnologies.create_cobb_douglas` or
py:meth:`~abceagent.FirmMultiTechnologies.create_leontief`

Example:

self.produce_use_everything(car_production_function)

sufficient_goods(input_goods)

checks whether the agent has all the goods in the vector input