Пример #1
0
    void IndexBuilder::run() {
        Client::initThread(name().c_str());
        LOG(2) << "IndexBuilder building index " << _index;

        OperationContextImpl txn;

        Lock::ParallelBatchWriterMode::iAmABatchParticipant(txn.lockState());

        txn.getClient()->getAuthorizationSession()->grantInternalAuthorization();

        txn.getCurOp()->reset(HostAndPort(), dbInsert);
        NamespaceString ns(_index["ns"].String());

        ScopedTransaction transaction(&txn, MODE_IX);
        Lock::DBLock dlk(txn.lockState(), ns.db(), MODE_X);
        Client::Context ctx(&txn, ns.getSystemIndexesCollection());

        Database* db = dbHolder().get(&txn, ns.db().toString());

        Status status = _build(&txn, db, true, &dlk);
        if ( !status.isOK() ) {
            error() << "IndexBuilder could not build index: " << status.toString();
            fassert(28555, ErrorCodes::isInterruption(status.code()));
        }

        txn.getClient()->shutdown();
    }
Пример #2
0
void PreflateSeqChain::_reshift() {
  const unsigned short delta = 0x7e00;
  unsigned remaining = (1 << 16) - (delta + 8);
  // If the head of large sequence is shifted out,
  // but the tail remains in the cache, 
  // we need to adapt the head and all pointers to it,
  // that is all members, the next non-member pointing to it
  // or heads
  if (prev[delta + 8].distToNext != 0xffff && prev[delta + 8].length < PreflateConstants::MIN_MATCH) {
    unsigned d = prev[delta + 8].distToNext;
    prev[delta + 8].distToNext = 0xffff;
    prev[delta + 8].length = prev[delta + 8 - d].length - d;
    for (unsigned i = 3; i < prev[delta + 8].length; ++i) {
      prev[delta + 8 + i - 2].distToNext -= d;
    }
    uint8_t c = *_input.curChars(-(int)remaining);
    if (heads[c] == delta + 8 - d) { 
      heads[c] += d;
    } else {
      for (unsigned i = prev[delta + 8].length; i < remaining;  ++i) {
        if (prev[delta + 8 + i].distToNext == i + d) {
          prev[delta + 8 + i].distToNext -= d;
          break;
        }
      }
    }
  }
  for (unsigned i = 0; i < 256; ++i) {
    heads[i] = std::max(heads[i], delta) - delta;
  }
  memmove(prev + 8, prev + (delta + 8), sizeof(SeqChainEntry) * remaining);
  totalShift += delta;
  _build(8 + remaining, std::min<uint32_t>(delta, _input.remaining()));
}
Пример #3
0
// Process
void Tree::Process() {

	switch (_step) {

		case 0:
			if (_initialize()) _step++;
			else return;
		case 1:
			if (_count()) _step++;
			else throw std::runtime_error("read error");
		case 2:
			if (_sum()) _step++;
			else return;
		case 3:
			if (_build()) _step++;
			else throw std::runtime_error("build error");
		case 4:
			if (_subtrees()) _step++;
			else throw std::runtime_error("subtree error");
		default:
			_fptree.free();
			FinishProcess();

	}

}
Пример #4
0
void BoundingBoxHierarchy::build(vector<RTShape*> shapes) {

  vector<RTShape*> flattened = flatten(shapes);

  _build(flattened.begin(), flattened.end(), 0);

}
Пример #5
0
void SystemClass::loadTable(BaseGame *gameRef, BasePersistenceManager *persistMgr) {
	_savedID = persistMgr->getDWORD();
	int numInstances = persistMgr->getDWORD();

	for (int i = 0; i < numInstances; i++) {
		int instID = persistMgr->getDWORD();
		if (_persistent) {

			if (i > 0) {
				gameRef->LOG(0, "Warning: attempting to load multiple instances of persistent class %s (%d)", _name.c_str(), numInstances);
				continue;
			}

			Instances::iterator it = _instances.begin();
			if (it != _instances.end()) {
				(it->_value)->setSavedID(instID);
				SystemClassRegistry::getInstance()->addInstanceToTable((it->_value), (it->_value)->getInstance());
			} else {
				gameRef->LOG(0, "Warning: instance %d of persistent class %s not found", i, _name.c_str());
			}
		}
		// normal instances, create empty objects
		else {
			void *emptyObject = _build();
			if (!emptyObject) {
				warning("HALT");
			}

			addInstance(emptyObject, SystemClassRegistry::getInstance()->getNextID(), instID);
		}

	}
}
Пример #6
0
PreflateSeqChain::PreflateSeqChain(
    const std::vector<unsigned char>& input_)
  : _input(input_)
  , totalShift(-8)
  , curPos(0) {
  prev = new SeqChainEntry[1 << 16];
  memset(heads, 0x00, sizeof(heads));
  _build(8, std::min<uint32_t>((1 << 16) - 8, _input.remaining()));
}
Пример #7
0
const Font::Glyph * FontFreeType::build(c32 chr) {
    GlyphMap::iterator it = m_glyphMap.insert(std::make_pair(chr, (GlyphEx *)0)).first;
	if (it->second) {
		it->second->pass = m_currentPass;
	} else {
		_build(chr, it);
	}
	return it->second;
}
Пример #8
0
void GraphOperation::build()
{
	if(_source && !_built)
	{
		const_cast<Graph*>(_source)->build();
		_build();

		_built = true;

		connectGraphSignals();
	}
}
Пример #9
0
	bool	BasicShader::build()
	{
		bool	ret;
		_build();
		_bindAttribLocation(0, "vPosition");
		_bindAttribLocation(1, "vColor");
		_bindAttribLocation(2, "vNormal");
		_bindAttribLocation(3, "vTexCoord");
		ret = _linkProgram();
		if (ret)
			_bindTextureUnit(0, "fTexture0");
		return (ret);
	}
Пример #10
0
/** rebuild list */
void ui_setup_ledlist_refresh(
        NiftyconfChain * c)
{
        if(!c)
                return;

        /* clear ledlist */
        ui_setup_ledlist_clear();

        _build(c);

        /* redraw */
        renderer_all_queue_draw();
}
Пример #11
0
InventoryPanel::InventoryPanel(Inventory* inventory)
{
    Node::init();

    _inventory = inventory;
    _inventory->retain();

    _build();
    _update();

    auto eventDispatcher = cocos2d::Director::getInstance()->getEventDispatcher();
    _inventoryChangedListener = eventDispatcher->addCustomEventListener(Inventory::ITEM_COUNT_CHANGED, [this](cocos2d::EventCustom* e) {
        _update();
    });
}
Пример #12
0
                // discrete features
                // vs continuous features
                void buildTree(const vector < vector <T1> > & feature_set, const vector < T2 > & label_set) {
                    // row: ds, col: fs
                    size_t data_size, feature_size; 
                    vector < bool > selected; // has been selected as branch feature or not

                    data_size = feature_set.size();
                    assert(data_size > 0);
                    feature_size = feature_set[0].size();
                    selected.resize(feature_size, false);

                    // build tree
                    _root = _build(feature_set, label_set, selected);
#ifdef DEBUG
                    cerr << _root.getNodeType() << endl;
                    cerr << _root.getNumInstances() << endl;
#endif

                }
Пример #13
0
  void RandomTree::buildTest(DataFrame & data, unsigned int numFactors)
  {
    unsigned int nodeSize = 1;
    _factPerNode = numFactors;

    std::vector<unsigned int> indices;
    indices.resize(data.getNumDataVectors());

    for(unsigned int i = 0; i < indices.size(); i++)
    {
      indices[i] = i;
    }

    _root = new TreeNode();
    _root->leftChild = NULL;
    _root->rightChild = NULL;
    _root->isPure = false;

    _build(data, indices, _root, nodeSize);
  }
Пример #14
0
const Font::Glyph * CellBasedFont::build(const str32 &code) {
    GlyphMap::iterator it = m_glyphMap.insert(std::make_pair(code, (GlyphEx *)0)).first;
	if (it->second) {
		it->second->pass = m_currentPass;
	} else {
        GlyphEx *glyph = m_glyphList.back();
        if (glyph->pass == m_currentPass) {
            return 0;
        }
        if (glyph->mapIt != m_glyphMap.end()) {
            m_glyphMap.erase(glyph->mapIt);
        }
        glyph->pass = m_currentPass;
        m_glyphList.erase(glyph->lstIt);
        m_glyphList.push_front( glyph );
        glyph->lstIt = m_glyphList.begin();
        glyph->mapIt = it;
        it->second = glyph;
        _build(code, glyph);
    }
    return it->second;
}
Пример #15
0
 Manageable::MethodMap& Manageable::manageableMmethodMap()
 {
   _build();
   return *manageable::methodMap;
 }
Пример #16
0
 index(Indices... indices)
 {
     static_assert(sizeof...(Indices) == N,
                   "Wrong number of arguments to construct the index.");
     _build(indices...);
 }
Пример #17
0
	void MeshGroup::Build()
	{
		_build(0);
		_build(1);
	}
Пример #18
0
                TreeNode < T1 > _build(const vector < vector <T1> > & feature_set, const vector < T2 > & label_set, vector < bool > & selected) {
                    TreeNode < T1 > temp;
#ifdef DEBUG
                    for(auto d: feature_set) {
                        for(auto f: d) {
                            cerr << f << ", ";
                        } cerr << endl;
                    }
#endif

                    // label->size: data size
                    // select->size: feature size

                    // related instance number
                    temp.setNumInstances(label_set.size());
                    
                    // check input 
                    bool feature_the_same = true;
                    for(size_t fdx = 0; fdx < selected.size(); fdx++) {
                        if(selected[fdx] == false) {
                            set < T1 > cur_values;
                            for(size_t ddx = 0; ddx < label_set.size(); ddx++) {
                                cur_values.insert(feature_set[ddx][fdx]);
                            }
                            if(cur_values.size() != 1) {
                                feature_the_same = false;
                            }
                        }
                    }

                    // all features have the same value
                    if(feature_the_same) {
                        temp.setNodeType(AIS);
                        return temp;
                    }

                    // check output
                    set < T2 > output_set;
                    for(size_t ddx = 0; ddx < label_set.size(); ddx++) { // maybe wrong
                        output_set.insert(label_set[ddx]);
                    }

                    // labels are the same
                    if(output_set.size() == 1) {
                        temp.setNodeType(AOS);
                        return temp;
                    }

                    // find maximum information gain
                    temp.setNodeType(MIG);

                    map < T1, int > count_label;
                    for(auto l: label_set) {
                        count_label[l]++;
                    }

                    // H(Y) = - sigma(p(y) * log(p(y))
                    double h_y = 0;
                    for(auto c: count_label) {
                        double p = c.second * 1. / label_set.size();
                        h_y += p * log(p);
                    }
                    h_y = - h_y;

#ifdef DEBUG
                    cerr << "H(Y): " << h_y << endl;
#endif

                    int best_feature = -1;
                    double best_ig = -1.;
                    for(size_t fdx = 0; fdx < selected.size(); fdx++) {
                        if(selected[fdx] == false) {
                            // TODO
                            // IG(Xi) = H(Y) - H(Y|Xi)
                            // H(Y) = - sigma(p(y) * log(p(y))
                            // H(Y|Xi) = sigma(p(xij) * H(Y|xij))
                            // = sigma(p(xij) * [- sigma(p(y|xij) * log(p(y|xij)))]
                            // = -sigma"y, xij"(p(xij, y) * log(p(y|xij)))
                            // = -sigma"y, xij"(p(xij, y) * log(p(xij, y)/p(xij)))
                            map < T1, map < T2, int > > count_value_with_label;
                            for(size_t ddx = 0; ddx < label_set.size(); ddx++) {
                                count_value_with_label[feature_set[fdx][ddx]][label_set[ddx]]++;
                            }
                            double h_y_x = 0.;
                            for(auto x: count_value_with_label) {
                                double p_x_with_no_fraction = x.second.size() * 1.;
                                for(auto x_y: x.second) {
                                    double p_x_y_w_n_f = x_y.second * 1. / label_set.size();
                                    h_y_x += p_x_y_w_n_f * log(p_x_y_w_n_f / p_x_with_no_fraction);
                                }
                            }
                            h_y_x = - h_y_x;
                            double ig = h_y - h_y_x;
#ifdef DEBUG
                            cerr << "IG: " << h_y << endl;
#endif
                            if(best_ig < ig) {
                                best_ig = ig;
                                best_feature = fdx;
                            }
                        }
                    }

                    assert(best_feature != -1);
                    // split
                    temp.setFeatureId(best_feature);

                    // choose branches (discrete)
                    set < T1 > values_of_feature;
                    for(size_t ddx = 0; ddx < label_set.size(); ddx++) {
                        values_of_feature.insert(feature_set[ddx][best_feature]);
                    }

                    selected[best_feature] = true;
                    for(auto v: values_of_feature) {
                        vector < vector <T1> > children_feature_set;
                        vector < T2 > children_label_set;
                        for(size_t ddx = 0; ddx < label_set.size(); ddx++) {
                            if(feature_set[ddx][best_feature] == v) {
                                children_feature_set.push_back(feature_set[ddx]);
                                children_label_set.push_back(label_set[ddx]);
                            }
                        }
                        temp.addChild(_build(children_feature_set, children_label_set, selected), v);
                    }

                    return temp;
                }
Пример #19
0
BubblesScene::BubblesScene(int width, int height) :
    Scene(width, height), _rotationAngle(0.), _dof(true)
{
    _build();
}
Пример #20
0
void LevelListScene::onEnter()
{
    cocos2d::Scene::onEnter();
    _build();
}
Пример #21
0
 Status IndexBuilder::buildInForeground(OperationContext* txn, Database* db) const {
     return _build(txn, db, false, NULL);
 }
Пример #22
0
WaveScene::WaveScene(int width, int height) :
    Scene(width, height)
{
    _build();
}
Пример #23
0
 MetaObject& Manageable::manageableMetaObject()
 {
   _build();
   return *manageable::metaObject;
 }
Пример #24
0
	bool Url::build(String* protocol, String* auth, String* host, String* path, Hash* query, String* fragment){
		return _build(protocol, auth, host, path, 0, query, fragment);
	}
Пример #25
0
	bool Url::build(String* protocol, String* auth, String* host, String* path, String* query_string, String* fragment){
		return _build(protocol, auth, host, path, query_string, 0, fragment);
	}
Пример #26
0
  void RandomTree::_build(DataFrame & data, std::vector<unsigned int> & dataSet, TreeNode * node, unsigned int nodeSize)
  {
    static unsigned int idCtr = 0;
    node->leftChild = NULL;
    node->rightChild = NULL;

    if(data.isDataSetPure(dataSet) || dataSet.size() <= nodeSize)  //Data is pure
    { 
      //If data set is all of same class then it is pure and done
      //Give it a class label
      
      node->classLabel = data.getTrainingLabel(dataSet[0]);
      node->isPure = true;
      node->purityDelta = 0;
      node->rangeMin = node->rangeMax = 0;

      node->dataList = dataSet;
      idCtr++;
      node->nodeId = idCtr; 
    }
    else  //Data is not pure
    {
      std::vector<unsigned int> factors;
      unsigned int splitIdx = 0;
      unsigned int fIdx = 0;
      double splitVal = 0.0;
      double purityDelta = 0.0;

      data.selectRandomFactors(_factPerNode, factors);

      bool splitPossible = _igc.findDataSplit(data, factors, dataSet, splitIdx, fIdx, splitVal, purityDelta);

      if(splitPossible)  //Data is not all same value
      {
        node->isPure = false;

        std::vector<unsigned int> leftSplit;
        std::vector<unsigned int> rightSplit;
        node->leftChild = new TreeNode();
        node->rightChild = new TreeNode();

        node->splitValue = splitVal;
        node->factorIndex = fIdx;
        node->purityDelta = purityDelta;
        node->nodeId = 0;
       
        double minVal, maxVal, mean, q1, q3;

        double bandwidth = data.computeBandwidthByFactor(fIdx, dataSet, minVal, 
          maxVal, mean, q1, q3);
        bandwidth = bandwidth;
//         node->rangeMin = mean - (6 * bandwidth);
//         node->rangeMax = mean + (6 * bandwidth);
//           double midVal = (maxVal - minVal) / 2.0;
//           node->rangeMin = minVal - (0.5 *(maxVal - minVal));
//           node->rangeMax = maxVal + (0.5 * (maxVal - minVal));
         double iqr = q3 - q1;
         node->rangeMin = q1 - ( 3 * iqr);
         node->rangeMax = q3 + (3 * iqr);

       
        data.sortIndicesOnFactorValue(dataSet, fIdx);

        for(unsigned int i = 0; i < splitIdx; i++)
        {
          leftSplit.push_back(dataSet[i]);
        }
        _build(data, leftSplit, node->leftChild, nodeSize);

        for(unsigned int i = splitIdx; i < dataSet.size(); i++)
        {
          rightSplit.push_back(dataSet[i]);
        }

        _build(data, rightSplit, node->rightChild, nodeSize);
      }
      else  //Data is all same value
      {
        //No split possible (all factors values same across all factors)
        //Vote on classes and make pure node.
        
        node->classLabel = data.getMajorityTrainingLabel(dataSet);
        node->isPure = true;
        node->purityDelta = 0;

        node->dataList = dataSet;
        idCtr++;
        node->nodeId = idCtr;
      }
    }
  }
Пример #27
0
 Manageable::SignalMap& Manageable::manageableSignalMap()
 {
   _build();
   return *manageable::signalMap;
 }
Пример #28
0
void init_building_data()
{
  for (int i = 0; i < BUILD_MAX; i++) {
    Building_data[i] = new Building_datum;
    Building_data[i]->uid = i;
  }

  int cur_id;

  _build(BUILD_PARK);
    _name("park");
    _cost(RES_GOLD, 300);
    _build_time(3);
    _destroy_cost(20);
    _upkeep(4);
    _base_morale(3);
    _description("\
A park is a well-groomed area of nature, with carefully designed paths and \
seating areas.\
");

  _build(BUILD_PLAZA);
    _name("plaza");
    _cost(RES_GOLD,  500);
    _cost(RES_STONE, 500);
    _build_time(5);
    _destroy_cost(150);
    _upkeep(4);
    _base_morale(1);
    _description("\
A plaza is an urban area that combines the pleasant environment and seating \
and strolling areas of a <link=park>park</link>, with the \
<link=building>business</link> space of a <link=marketplace>marketplace</link>.\
");

  _build(BUILD_MARKETPLACE);
    _name("marketplace");
    _cost(RES_GOLD,   800);
    _cost(RES_STONE, 1500);
    _build_time(7);
    _destroy_cost(350);
    _upkeep(2);
    _description("\
A marketplace is an area designed purely for business, with lots of space for \
<link=building>buildings</link> of various natures.\
");

  _build(BUILD_HOVEL);
    _name("hovels");
    _plural();
    _cost(RES_GOLD, 300);
    _cost(RES_WOOD, 300);
    _build_time(3);
    _destroy_cost(250);
    _upkeep(5);
    _housing(CIT_PEASANT, 100);
    _description("\
Hovels are simple homes, sacrificing comfort and style to be a purely \
utilitarian living space for <link=peasants>peasants</link>.\
");

  _build(BUILD_HOUSE);
    _name("houses");
    _plural();
    _cost(RES_GOLD, 800);
    _cost(RES_WOOD, 500);
    _build_time(10);
    _destroy_cost(600);
    _upkeep(10);
    _housing(CIT_MERCHANT, 100);
    _description("\
Houses are respectable homes with a moderate degree of comfort, suitable for \
the <link=merchants>middle classes</link>.\
");

  _build(BUILD_MANOR);
    _name("manor");
    _cost(RES_GOLD,  1200);
    _cost(RES_WOOD,   500);
    _cost(RES_STONE, 1000);
    _build_time(30);
    _destroy_cost(1250);
    _upkeep(20);
    _housing(CIT_BURGHER, 50);
    _description("\
A manor is a large, well-furnished home.  Its high degree of comfort and low-\
density quarters are ideal for the <link=burghers>upper class</link>.\
");

  _build(BUILD_KEEP);
    _name("keep");
    _cost(RES_GOLD,  3000);
    _cost(RES_STONE, 4000);
    _build_time(90);
    _destroy_cost(2500);
    _upkeep(30);
    _housing(CIT_BURGHER,   5);
    _housing(CIT_MERCHANT, 50);
    _housing(CIT_PEASANT, 100);
    _description("\
A keep is the center of any city.  It provides a home for the \
<link=nobles>nobility</link> as well as space for some <link=citizens>citizens\
</link>.  It also has space to support several <link=building>businesses\
</link>.\
");

  _build(BUILD_FARM);
    _name("farm");
    _cost(RES_GOLD, 250);
    _build_time(1);
    _destroy_cost(50);
    _upkeep(1);
    _jobs(CIT_PEASANT, 15);
    _wages(1);
    _produces(RES_FARMING, 1);
    _description("\
A farm is a tilled piece of land designed for growing <link=crop>crops</link>.\
");

  _build(BUILD_HUNTING_CAMP);
    _name("hunting camp");
    _cost(RES_GOLD, 200);
    _build_time(1);
    _destroy_cost(100);
    _upkeep(3);
    _jobs(CIT_PEASANT, 10);
    _wages(1);
    _produces(RES_HUNTING, 1);
    _description("\
A hunting camp is a base of operations for <link=hunting>hunters</link>, \
allowing them to catch <link=animals>game</link> in the land upon which it is \
built.\
");

  _build(BUILD_MINE);
    _name("mine");
    _cost(RES_GOLD, 500);
    _cost(RES_WOOD, 400);
    _build_time(10);
    _destroy_cost(1500);
    _upkeep(8);
    _jobs(CIT_PEASANT, 8);
    _wages(2);
    _produces(RES_MINING, 5);
    _description("\
A mine is set of several shafts dug into the land, allowing <link=mining>miners\
</link> to pull <link=minerals>minerals</link> from the ground.\
");

  _build(BUILD_SAWMILL);
    _name("sawmill");
    _forbidden(RACE_ELF);
    _cost(RES_GOLD,  200);
    _cost(RES_STONE, 350);
    _build_time(5);
    _destroy_cost(350);
    _upkeep(3);
    _jobs(CIT_PEASANT, 6);
    _wages(1);
    _produces(RES_LOGGING, 5);
    _description("\
A sawmill is a site for the processing of <link=logging>logging</link> \
operations.  It should be built on a <link=city map tile>map tile</link> that \
has <link=trees>trees</link> growing on it; it will remove the trees and turn \
them into <link=wood>wood</link> for use.  Once the trees are cleared, the \
sawmill will automatically close.\
");

  _build(BUILD_PASTURE);
    _name("pasture");
    _cost(RES_GOLD, 100);
    _cost(RES_WOOD, 100);
    _build_time(1);
    _destroy_cost(20);
    _upkeep(1);
    _livestock(500);
    _description("\
A pasture is a fenced-in area used for keeping <link=livestock>livestock\
</link>.  The terrain it is built upon does not matter.\
");

  _build(BUILD_BARRACKS);
    _name("barracks");
    _plural();
    _cost(RES_GOLD, 800);
    _cost(RES_WOOD, 650);
    _build_time(14);
    _destroy_cost(800);
    _upkeep(15);
    _military(50);
    _description("\
Barracks are a space for the housing and training of <link=army>military units\
</link>.\
");

  _build(BUILD_MASONRY);
    _category(BUILDCAT_MANUFACTURING);
    _name("masonry");
    _cost(RES_GOLD, 250);
    _cost(RES_WOOD, 600);
    _build_time(5);
    _upkeep(3);
    _jobs(CIT_PEASANT, 3);
    _wages(1);
    _recipe(RES_STONE, 1);
      _units_per_day(3);
      _max_deficit(0);
      _uses_mineral(MINERAL_STONE, 1);
    _description("\
A masonry is a <link=building>building</link> where uncut <link=stone>stone\
</link> is cut into useful blocks.\
");

  _build(BUILD_SMELTERY);
    _category(BUILDCAT_MANUFACTURING);
    _name("smeltery");
    _cost(RES_GOLD,   500);
    _cost(RES_STONE, 1000);
    _build_time(6);
    _unlock(CITY_ACHIEVE_ORES, 0, 0);
    _jobs(CIT_PEASANT, 10);
    _wages(2);
    _recipe(RES_TIN, 1);
      _recipe_name("Smelt tin (burn wood)");
      _units_per_day(1);
      _max_deficit(0);
      _uses_mineral(MINERAL_TIN, 1);
      _uses_resource(RES_WOOD, 3);
    _recipe(RES_TIN, 3);
      _recipe_name("Smelt tin (burn coal)");
      _units_per_day(3);
      _max_deficit(0);
      _uses_mineral(MINERAL_TIN, 3);
      _uses_mineral(MINERAL_COAL, 1);
    _recipe(RES_COPPER, 1);
      _recipe_name("Smelt copper (burn wood)");
      _units_per_day(1);
      _max_deficit(0);
      _uses_mineral(MINERAL_COPPER, 1);
      _uses_resource(RES_WOOD, 3);
    _recipe(RES_COPPER, 3);
      _recipe_name("Smelt copper (burn coal)");
      _units_per_day(3);
      _max_deficit(0);
      _uses_mineral(MINERAL_COPPER, 3);
      _uses_mineral(MINERAL_COAL, 1);
    _recipe(RES_IRON, 1);
      _recipe_name("Smelt iron (burn wood)");
      _days_per_unit(2);
      _max_deficit(0);
      _uses_mineral(MINERAL_IRON, 1);
      _uses_resource(RES_WOOD, 3);
    _recipe(RES_IRON, 3);
      _recipe_name("Smelt iron (burn coal)");
      _units_per_day(2);
      _max_deficit(0);
      _uses_mineral(MINERAL_IRON, 3);
      _uses_mineral(MINERAL_COAL, 1);
    _description("\
A smeltery is a high-temperature furnace used to melt metals out of the \
<link=minerals>ores</link> they naturally appear in.  These ores are virtually \
useless before smelting; thus a smeltery is a vital addition to any mining \
operation.  It is possible to smelt ores using <link=wood>wood</link> as a \
fuel; however, it is much faster and more efficient to burn <link=coal>coal\
</link> if it is available.\
");

  _build(BUILD_MINT);
    _category(BUILDCAT_MANUFACTURING);
    _name("mint");
    _cost(RES_GOLD,   500);
    _cost(RES_STONE, 1000);
    _cost(RES_IRON,   200);
    _build_time(6);
    _unlock( CITY_ACHIEVE_POP, CIT_MERCHANT, 1 );
    _upkeep(6);
    _jobs(CIT_MERCHANT, 3);
    _wages(4);
    _recipe(RES_GOLD, 1);
      _recipe_name("Gold (burn wood)");
      _units_per_day(3);
      _max_deficit(0);
      _uses_mineral(MINERAL_GOLD, 1);
      _uses_resource(RES_WOOD, 3);
    _recipe(RES_GOLD, 3);
      _recipe_name("Gold (burn coal)");
      _units_per_day(3);
      _max_deficit(0);
      _uses_mineral(MINERAL_GOLD, 3);
      _uses_mineral(MINERAL_COAL, 1);
    _description("\
A mint is a <link=building>building</link> where raw <link=gold>gold</link> \
ore can be forged into spendable coins and bars.  Doing so requires a fuel \
source; <link=wood>wood</link> can be used, but <link=coal>coal</link> is more \