void WebImage::loaded(Event* e)
{
if (_ref_counter <= 1)//if it is already dead
{
releaseRef();
return;
}
dispatchEvent(e);
file::buffer bf;
_http->getResponseSwap(bf.data);
Image mt;
if (mt.init(bf, true))
{
_rs.init(&mt);
_image->setResAnim(&_rs);
fit();
}
_http = 0;
releaseRef();
}
polynomFitDialog::polynomFitDialog( QWidget* parent, const char* name, bool modal, WFlags fl )
: QDialog( parent, name, modal, fl )
{
if ( !name )
setName( "polynomFitDialog" );
setCaption(tr("QtiPlot - Polynomial Fit Options"));
setSizeGripEnabled(true);
setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
GroupBox1 = new QButtonGroup( 2,QGroupBox::Horizontal,tr(""),this,"GroupBox1" );
GroupBox1->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
new QLabel( tr("Polynomial Fit of"), GroupBox1, "TextLabel1",0 );
boxName = new QComboBox(GroupBox1, "boxShow" );
new QLabel( tr("Order (1 - 9, 1 = linear)"), GroupBox1, "TextLabel2",0 );
boxOrder = new QSpinBox(1,9,1,GroupBox1, "boxOrder" );
boxOrder->setValue(2);
new QLabel( tr("Fit curve # pts"), GroupBox1, "TextLabel3",0 );
boxPoints = new QSpinBox(1,1000,50,GroupBox1, "boxPoints" );
new QLabel( tr("Fit curve Xmin"), GroupBox1, "TextLabel4",0 );
boxStart = new QLineEdit(GroupBox1, "boxStart" );
boxStart->setText(tr("0"));
new QLabel( tr("Fit curve Xmax"), GroupBox1, "TextLabel5",0 );
boxEnd = new QLineEdit(GroupBox1, "boxEnd" );
new QLabel( tr("Color"), GroupBox1, "TextLabel52",0 );
boxColor = new ColorBox( FALSE, GroupBox1);
boxColor->setColor(QColor(red));
new QLabel( tr( "Show Formula on Graph?" ), GroupBox1, "TextLabel6",0 );
boxShowFormula = new QCheckBox(GroupBox1, "boxShow" );
boxShowFormula->setChecked( FALSE );
GroupBox2 = new QButtonGroup(1,QGroupBox::Horizontal,tr(""),this,"GroupBox2" );
GroupBox2->setFlat (TRUE);
GroupBox2->setLineWidth (0);
buttonFit = new QPushButton(GroupBox2, "buttonFit" );
buttonFit->setAutoDefault( TRUE );
buttonFit->setDefault( TRUE );
buttonCancel = new QPushButton(GroupBox2, "buttonCancel" );
buttonCancel->setAutoDefault( TRUE );
QHBoxLayout* hlayout = new QHBoxLayout(this,5,5, "hlayout");
hlayout->addWidget(GroupBox1);
hlayout->addWidget(GroupBox2);
languageChange();
setMaximumHeight(GroupBox1->height());
// signals and slots connections
connect( buttonFit, SIGNAL( clicked() ), this, SLOT( fit() ) );
connect( buttonCancel, SIGNAL( clicked() ), this, SLOT( reject() ) );
connect( boxName, SIGNAL( activated(int) ), this, SLOT(activateCurve(int)));
}
int pathfinder_prepare(Waypoint *path, int path_length, void (*fit)(Waypoint,Waypoint,Spline*), int sample_count, double dt,
double max_velocity, double max_acceleration, double max_jerk, TrajectoryCandidate *cand) {
if (path_length < 2) return -1;
cand->saptr = malloc((path_length - 1) * sizeof(Spline));
cand->laptr = malloc((path_length - 1) * sizeof(double));
double totalLength = 0;
int i;
for (i = 0; i < path_length-1; i++) {
Spline s;
fit(path[i], path[i+1], &s);
double dist = pf_spline_distance(&s, sample_count);
cand->saptr[i] = s;
cand->laptr[i] = dist;
totalLength += dist;
}
TrajectoryConfig config = {dt, max_velocity, max_acceleration, max_jerk, 0, path[0].angle,
totalLength, 0, path[0].angle, sample_count};
TrajectoryInfo info = pf_trajectory_prepare(config);
int trajectory_length = info.length;
cand->totalLength = totalLength;
cand->length = trajectory_length;
cand->path_length = path_length;
cand->info = info;
cand->config = config;
return 0;
}
int main()
{
int i;
int max, mid, min;
while(scanf("%d",&n)==1,n)
{
memset(map,0,sizeof(map));
for(i = 0; i < n; i++)
{
scanf("%s",adj[i]);
}
get_graph();
min = 1;max = n;
while(min<max)
{
memset(c,-1,sizeof(c));
mid = (max+min)/2;
if(fit(0,mid))
max = mid;
else
min = mid+(min==mid);
}
printf("%d channel",min);
if(min!=1)
putchar('s');
puts(" needed.");
}
return 1;
}
/* ---------------------------------------------------------------------- */
float Population::get_best_fitness() {
int size=this->get_size();
std::vector<float> fit(size);
for(int i=0; i<size; i++) { fit[i]=flock[i].get_fitness(); }
return *(std::min_element(fit.begin(), fit.end()));
}
void LMS::fit_quadratic( //fit sample
float outlier_threshold, //min outlier size
double &out_a, //x squared
float &out_b, //output line
float &out_c) {
inT32 trials; //no of medians
double test_a;
float test_b, test_c; //candidate line
float test_error; //error of test line
if (samplecount < 3) {
out_a = 0;
fit(out_b, out_c);
return;
}
pick_quadratic(a, m, c);
line_error = compute_quadratic_errors (outlier_threshold, a, m, c);
for (trials = 1; trials < lms_line_trials * 2; trials++) {
pick_quadratic(test_a, test_b, test_c);
test_error = compute_quadratic_errors (outlier_threshold,
test_a, test_b, test_c);
if (test_error < line_error) {
line_error = test_error; //find least median
a = test_a;
m = test_b;
c = test_c;
}
}
fitted = TRUE;
out_a = a;
out_b = m;
out_c = c;
}
int Row::insert_string(CHAR *str, int inlen) {
register int c;
// xpand the buffer if needed
fit( inlen );
// we are growing
len += inlen;
// slide right
for( c = len ; c > pos; c-- )
text[c] = text[c-inlen];
// termination
text[len+1] = EOT;
// new string at current position
for( c = 0; c < inlen; c++ )
text[pos+c] = str[c];
// advance position
// pos += inlen;
return len;
}
void fincr(_MIPD_ flash x,int n,int d,flash y)
{ /* increment x by small fraction n/d - y=x+(n/d) */
#ifdef MR_OS_THREADS
miracl *mr_mip=get_mip();
#endif
if (mr_mip->ERNUM) return;
MR_IN(43)
if (d<0)
{
d=(-d);
n=(-n);
}
numer(_MIPP_ x,mr_mip->w1);
denom(_MIPP_ x,mr_mip->w2);
mr_mip->check=OFF;
premult(_MIPP_ mr_mip->w1,d,mr_mip->w5);
premult(_MIPP_ mr_mip->w2,d,mr_mip->w6);
premult(_MIPP_ mr_mip->w2,n,mr_mip->w0);
add(_MIPP_ mr_mip->w5,mr_mip->w0,mr_mip->w5);
mr_mip->check=ON;
if (d==1 && fit(mr_mip->w5,mr_mip->w6,mr_mip->nib))
fpack(_MIPP_ mr_mip->w5,mr_mip->w6,y);
else
mround(_MIPP_ mr_mip->w5,mr_mip->w6,y);
MR_OUT
}
void main(void)
{
static char mesg[] = "Привет! Я Ваша тетя.";
puts(Rus(mesg));
fit(mesg, 10);
puts(Rus(mesg));
}
int main(int argc, const char * argv[])
{
BloomFilter fit(10, 8);
fit.add("aaaaaaaaaaaaaaaaaa");
fit.add("grhuifdhgfhduighruid");
fit.add("re98y5uygr7wtyn985igh");
fit.add("FHUIEWTN4Y8NRHUGFHKD");
fit.add("^&TT*GJGTY%*&*%^FJVHJ");
fit.add("5479692065892067586754092");
fit.add("1");
printf("%d, %d, %d, %d, %d, %d, %d\n",
fit.find("aaaaaaaaaaaaaaaaaa"),
fit.find("grhuifdhgfhduighruid"),
fit.find("re98y5uygr7wtyn985igh"),
fit.find("FHUIEWTN4Y8NRHUGFHKD"),
fit.find("^&TT*GJGTY%*&*%^FJVHJ"),
fit.find("5479692065892067586754092"),
fit.find("1"));
char str[10];
while(std::cin >> str)
{
std::string s(str);
if (s == "1")
{
return 0;
}
}
return 0;
}
int main(void)
{
long idum=(-1984);
int i,mwt=1;
float a,abdev,b,chi2,q,siga,sigb;
float *x,*y,*sig;
x=vector(1,NDATA);
y=vector(1,NDATA);
sig=vector(1,NDATA);
for (i=1;i<=NPT;i++) {
x[i]=0.1*i;
y[i] = -2.0*x[i]+1.0+SPREAD*gasdev(&idum);
sig[i]=SPREAD;
}
fit(x,y,NPT,sig,mwt,&a,&b,&siga,&sigb,&chi2,&q);
printf("\nAccording to routine FIT the result is:\n");
printf(" a = %8.4f uncertainty: %8.4f\n",a,siga);
printf(" b = %8.4f uncertainty: %8.4f\n",b,sigb);
printf(" chi-squared: %8.4f for %4d points\n",chi2,NPT);
printf(" goodness-of-fit: %8.4f\n",q);
printf("\nAccording to routine MEDFIT the result is:\n");
medfit(x,y,NPT,&a,&b,&abdev);
printf(" a = %8.4f\n",a);
printf(" b = %8.4f\n",b);
printf(" absolute deviation (per data point): %8.4f\n",abdev);
printf(" (note: gaussian SPREAD is %8.4f)\n",SPREAD);
free_vector(sig,1,NDATA);
free_vector(y,1,NDATA);
free_vector(x,1,NDATA);
return 0;
}
int
main (int argc, char *argv[])
{
std::string pcd_file;
if (argc > 1)
{
pcd_file = argv[1];
}
else
{
printf ("\nUsage: pcl_example_nurbs_fitting_curve pcd-file \n\n");
printf (" pcd-file point-cloud file\n");
exit (0);
}
// #################### LOAD FILE #########################
printf (" loading %s\n", pcd_file.c_str ());
pcl::PointCloud<pcl::PointXYZ>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZ>);
pcl::PCLPointCloud2 cloud2;
if (pcl::io::loadPCDFile (pcd_file, cloud2) == -1)
throw std::runtime_error (" PCD file not found.");
fromPCLPointCloud2 (cloud2, *cloud);
// convert to NURBS data structure
pcl::on_nurbs::NurbsDataCurve2d data;
PointCloud2Vector2d (cloud, data.interior);
viewer.setSize (800, 600);
viewer.addPointCloud<pcl::PointXYZ> (cloud, "cloud");
// #################### CURVE PARAMETERS #########################
unsigned order (3);
unsigned n_control_points (10);
pcl::on_nurbs::FittingCurve2d::Parameter curve_params;
curve_params.smoothness = 0.000001;
curve_params.rScale = 1.0;
// #################### CURVE FITTING #########################
ON_NurbsCurve curve = pcl::on_nurbs::FittingCurve2d::initNurbsPCA (order, &data, n_control_points);
pcl::on_nurbs::FittingCurve2d fit (&data, curve);
fit.assemble (curve_params);
Eigen::Vector2d fix1 (0.1, 0.1);
Eigen::Vector2d fix2 (1.0, 0.0);
// fit.addControlPointConstraint (0, fix1, 100.0);
// fit.addControlPointConstraint (curve.CVCount () - 1, fix2, 100.0);
fit.solve ();
// visualize
VisualizeCurve (fit.m_nurbs, 1.0, 0.0, 0.0, true);
viewer.spin ();
return 0;
}
vector< ASMFitResult > ASMModel::fitAll(
const Mat & img,
const vector< cv::Rect > & detectedObjs,
int verbose) {
vector< ASMFitResult > fitResultV;
for (uint i=0; i<detectedObjs.size(); i++){
cv::Rect r = detectedObjs[i];
r.y -= r.height*searchYOffset;
r.x -= r.width*searchXOffset;
if (r.x<0) r.x = 0;
if (r.y<0) r.y = 0;
r.width *= searchWScale;
r.height *= searchHScale;
if (r.x+r.width>img.cols) r.width = img.cols-r.x;
if (r.y+r.height>img.rows) r.height = img.rows-r.y;
// Fit it!
ASMFitResult fitResult = fit(img(r), verbose);
SimilarityTrans s2;
s2.Xt = r.x;
s2.Yt = r.y;
s2.a = 1;
fitResult.transformation = s2 * fitResult.transformation;
fitResultV.push_back(fitResult);
}
return fitResultV;
}
cv::Mat fourier::convolve(const cv::Mat &data, const cv::Mat &kernel) {
cv::Size size = data.size();
cv::Size optimal = fit(size);
cv::Mat data_f = transform(data, optimal);
cv::Mat kernel_f = transform(kernel, optimal);
cv::Mat fourier = data_f.mul(kernel_f);
return inverse(fourier, size);
}
/**
* \brief Constructor.
* \param f The font used to display the text.
* \param label The text displayed in the button.
*/
bear::gui::button::button( const font_type& f, const std::string& label )
: visual_component(), m_text( NULL ), m_icon( NULL ), m_margin(0)
{
create();
m_text->set_font(f);
m_text->set_text(label);
fit(m_margin);
} // button::button()
std::auto_ptr<FitResult> Fitter::fit(const DataVector &data, IFMLFunction &f) const
{
std::auto_ptr<IFMLDataIterator> it = data.createIterator();
if(!it.get()) return std::auto_ptr<FitResult>();
return fit(*it.get(),f);
}
void fitall(){
double p0[4],p[4],half,width;
int i,j,k,ud,info;
char str1[256];
FitGraceinit();
half=0.0;
GracePrintf("focus g0");
for(j=0;j<4;j++){
for(k=0;k<NCH;k++){
mn=10000000;
mx=0;
for(i=0;i<NPOINTS;i++){
fitdat[i]=data[j][k][i];
if(fitdat[i]>=mx) mx=fitdat[i];
if(fitdat[i]<=mn) mn=fitdat[i];
}
half=(mn+mx)/2.0;
if((j==0) || (j==2)){
fitud=1;
for(i=0;i<NPOINTS-1;i++){
if((fitdat[i]>=half) && (fitdat[i+1]<=half)){
/*printf("LoMid = %i\n",i);*/
p0[1]=x[i]; /* center */
p0[2]=60.0; /* width (V) */
p0[0]=(mx-mn)/2;/* height */
p0[3]=mn; /* baseline */
}
}
}
if((j==1) || (j==3)){
fitud=-1;
for(i=0;i<NPOINTS-1;i++){
if((fitdat[i]<=half) && (fitdat[i+1]>=half)){
/*printf("LoMid = %i\n",i);*/
p0[1]=x[i]; /* center */
p0[2]=60.0; /* width (V) */
p0[0]=(mx-mn)/2;/* height */
p0[3]=mn; /* baseline */
}
}
}
printf("Before: p0=%g p1=%g p2=%g p3=%g\n",p0[0],p0[1],p0[2],p0[3]);
fit(p0,&info);
printf("After: p0=%g p1=%g p2=%g p3=%g info=%i\n",p0[0],p0[1],p0[2],p0[3],info);
for(i=0;i<4;i++) fits[j][k][i]=p0[i];
/*printf("Center=%g width=%g max=%g min=%g info=%i\n",fits[j][k][1],fits[j][k][2],fits[j][k][0]+fits[j][k][3],info);*/
sprintf(str1,"g0.s%i point %g, %g",j,fits[j][k][1],fits[j][k][2]);
GracePrintf(str1);
}
GracePrintf("autoscale");
GracePrintf("redraw");
}
if(save_fits()) printf("save fits error\n");
}
void TypeInferenceVisitor::visitBlockNode(BlockNode* node) {
_scopes.push(node->scope());
Scope::FunctionIterator fit(node->scope());
while(fit.hasNext()) {
processFunction(fit.next());
}
node->visitChildren(this);
_scopes.pop();
}
PolynomFitDialog::PolynomFitDialog(QWidget *parent, Qt::WFlags fl)
: QDialog(parent, fl) {
setWindowTitle(tr("Polynomial Fit Options"));
setSizeGripEnabled(true);
QGroupBox *gb1 = new QGroupBox();
QGridLayout *gl1 = new QGridLayout(gb1);
gl1->addWidget(new QLabel(tr("Polynomial Fit of")), 0, 0);
boxName = new QComboBox();
gl1->addWidget(boxName, 0, 1);
gl1->addWidget(new QLabel(tr("Order (1 - 9, 1 = linear)")), 1, 0);
boxOrder = new QSpinBox();
boxOrder->setRange(1, 9);
boxOrder->setValue(2);
gl1->addWidget(boxOrder, 1, 1);
gl1->addWidget(new QLabel(tr("Fit curve Xmin")), 2, 0);
boxStart = new QLineEdit(tr("0"));
gl1->addWidget(boxStart, 2, 1);
gl1->addWidget(new QLabel(tr("Fit curve Xmax")), 3, 0);
boxEnd = new QLineEdit();
gl1->addWidget(boxEnd, 3, 1);
gl1->addWidget(new QLabel(tr("Color")), 4, 0);
boxColor = new ColorBox();
boxColor->setColor(QColor(Qt::red));
gl1->addWidget(boxColor, 4, 1);
boxShowFormula = new QCheckBox(tr("Show Formula on Graph?"));
boxShowFormula->setChecked(false);
gl1->addWidget(boxShowFormula, 5, 1);
gl1->setRowStretch(6, 1);
buttonFit = new QPushButton(tr("&Fit"));
buttonFit->setDefault(true);
buttonCancel = new QPushButton(tr("&Close"));
QVBoxLayout *vl = new QVBoxLayout();
vl->addWidget(buttonFit);
vl->addWidget(buttonCancel);
vl->addStretch();
QHBoxLayout *hlayout = new QHBoxLayout(this);
hlayout->addWidget(gb1);
hlayout->addLayout(vl);
languageChange();
connect(buttonFit, SIGNAL(clicked()), this, SLOT(fit()));
connect(buttonCancel, SIGNAL(clicked()), this, SLOT(reject()));
connect(boxName, SIGNAL(activated(const QString &)), this,
SLOT(activateCurve(const QString &)));
}
/**
* \brief Constructs a button with an icon and no text.
* \param icon The icon.
*/
bear::gui::button::button( const visual::sprite& icon )
: visual_component(), m_text( NULL ), m_icon( NULL ), m_margin(0)
{
create();
m_icon->set_size( icon.get_size() );
m_icon->set_picture( icon );
fit(m_margin);
} // button::button()
int main(int argc, char *argv[])
{
setIO("sample");
while(~scanf("%d%d",&m,&n)){
if(n == 0 && m == 0) break;
init();
for(int i=1;i<=m;++i) scanf("%s",map[i]+1);
for(int i = 1;i<=m;++i){
cur[i] = 0;
for(int j = 1 ; j <= n; ++ j)
if(map[i][j] == 'H')
cur[i] += (1<<(j-1));
}
CLEAR(dp,0xff);
for(int i = 1;i<=top;++i)
{
num[i] = count(stk[i]);
if(fit(stk[i],1))
dp[1][1][i] = num[i];
}
for(int i =2;i<=m;++i)
for(int t = 1;t<=top;++t){
if(!fit(stk[t],i)) continue;
for(int j = 1;j<=top;++j){
if(stk[t]&stk[j]) continue;
for(int k = 1;k<=top;++k)
{
if(stk[t] & stk[k]) continue;
if(dp[i-1][j][k]==-1)continue;
dp[i][k][t] = max(dp[i][k][t],dp[i-1][j][k]+num[t]);
}
}
}
int ans = 0;
for(int i = 1;i<=m;++i)
for(int j =1;j<=top;++j)
for(int k = 1;k<=top;++k)
ans = max(ans,dp[i][j][k]);
printf("%d\n",ans);}
closeIO();
return EXIT_SUCCESS;
}
void PluginCollection::scanPlugins() {
QMap<QString,QString> backup = _installedPluginNames;
bool changed = false;
_installedPlugins.clear();
_installedPluginNames.clear();
QStringList dirs = KGlobal::dirs()->resourceDirs("kstplugins");
dirs += KGlobal::dirs()->resourceDirs("kstpluginlib");
for (QStringList::ConstIterator it = dirs.begin(); it != dirs.end(); ++it) {
//kdDebug() << "Scanning [" << *it << "] for plugins." << endl;
QDir d(*it);
d.setFilter(QDir::Files | QDir::NoSymLinks);
d.setNameFilter("*.xml");
const QFileInfoList *list = d.entryInfoList();
if (!list) {
continue;
}
QFileInfoListIterator fit(*list);
QFileInfo *fi;
while ((fi = fit.current()) != 0L) {
if (_parser->parseFile(*it + fi->fileName()) == 0) {
// dupe? - prefer earlier installations
if (_installedPluginNames.contains(_parser->data()._name)) {
++fit;
continue;
}
_installedPlugins[*it + fi->fileName()] = _parser->data();
_installedPluginNames[_parser->data()._name] = *it + fi->fileName();
if (!backup.contains(_parser->data()._name)) {
emit pluginInstalled(_parser->data()._name);
changed = true;
} else {
backup.remove(_parser->data()._name);
}
} else {
KstDebug::self()->log(i18n("Error parsing XML file '%1'; skipping.").arg(*it + fi->fileName()), KstDebug::Warning);
}
++fit;
}
}
while (!backup.isEmpty()) {
KstDebug::self()->log(i18n("Detected disappearance of '%1'.").arg(backup.begin().key()));
emit pluginRemoved(backup.begin().key());
backup.remove(backup.begin());
changed = true;
}
if (changed) {
emit pluginListChanged();
}
}
void ClosureAnalyzer::visitBlockNode(BlockNode *node) {
_scope = node->scope();
embraceVars(node->scope());
node->visitChildren(this);
Scope::FunctionIterator fit(node->scope());
while( fit.hasNext())
visitAstFunction(fit.next());
_scope = node->scope()->parent();
}
void
WorkerStemFit::run()
{
Stem_fit fit(_cloud,_min_height, _bin_width, _epsilon);
std::vector<pcl::ModelCoefficients> cylinders = fit.getCylinders();
std::vector<float> distances = compute_distances(cylinders);
std::vector<float> distances_only_fitted_points = reduce_distances(distances,cylinders);
float dist = squared_mean(distances_only_fitted_points);
get_optimization()->updateCoeff(dist, _bin_width, _epsilon);
}
void AABoundingBox::fit(vector<AABoundingBox> AABBList)
{
vector<Vector> pointList;
for(vector<AABoundingBox>::iterator i = AABBList.begin(); i != AABBList.end(); i++)
{
pointList.push_back(i->getMinVertex());
pointList.push_back(i->getMaxVertex());
}
fit(pointList);
}
/*
* perform the actual conversion
* return true if the conversion is successfull, false on the contrary
*/
bool operator()()
{
// initialize the reference
const NL::Vector & coeff = fitter.result();
fit();
if ( !check_bound(1, coeff[0], coeff[1], coeff[2], coeff[3], coeff[4]) )
return false;
if ( !(make_elliptiarc()) ) return false;
return true;
}
BSpline<T> fitBSpline( const std::vector<T> &samples, int degree, int outputSamples )
{
BSplineFit<typename T::TYPE> fit( T::DIM, (int)samples.size(), &(samples[0].x), degree, outputSamples );
vector<T> points;
for( int c = 0; c < fit.getControlQuantity(); ++c ) {
points.push_back( ( T( &fit.getControlData()[c * T::DIM] ) ) );
}
return BSpline<T>( points, fit.getDegree(), false, true );
}
int dag(int x){
if(dp[x]>-1)return dp[x];
dp[x]=0;
int i;
for(i=1;i<=m;i++){
if(i==x)continue;
if(fit(x,i))dp[x]=max(dp[x],dag(i)+1);
}
return dp[x];
}
FittedLearner* CGBMEngine::FitLearner(double* func_estimate) {
// Initialize adjustments to function estimate
std::vector<double> delta_estimates(datacontainer_.get_data().nrow(), 0);
// Bag data
datacontainer_.BagData();
// Set up tree
std::auto_ptr<CCARTTree> tree(new CCARTTree(tree_params_));
// Compute Residuals and fit tree
datacontainer_.ComputeResiduals(&func_estimate[0], residuals_);
tree->Grow(residuals_, datacontainer_.get_data(), datacontainer_.get_bag(),
delta_estimates);
// Now I have adF, adZ, and vecpTermNodes (new node assignments)
// Fit the best constant within each terminal node
// Adjust terminal node predictions and shrink
datacontainer_.ComputeBestTermNodePreds(&func_estimate[0], residuals_,
*tree.get());
tree->Adjust(delta_estimates);
// Compute the error improvement within bag
double oobag_improv = datacontainer_.ComputeBagImprovement(
&func_estimate[0], tree->get_shrinkage_factor(), delta_estimates);
// Update the function estimate
#pragma omp parallel for schedule(static, tree->get_array_chunk_size()) \
num_threads(tree->get_num_threads())
for (unsigned long i = 0; i < datacontainer_.get_data().get_trainsize();
i++) {
func_estimate[i] += tree->get_shrinkage_factor() * delta_estimates[i];
}
// Make validation predictions
double train_error = datacontainer_.ComputeDeviance(&func_estimate[0], false);
tree->PredictValid(datacontainer_.get_data(),
datacontainer_.get_data().get_validsize(),
delta_estimates);
#pragma omp parallel for schedule(static, tree->get_array_chunk_size()) \
num_threads(tree->get_num_threads())
for (unsigned long i = datacontainer_.get_data().get_trainsize();
i < datacontainer_.get_data().get_trainsize() +
datacontainer_.get_data().get_validsize();
i++) {
func_estimate[i] += delta_estimates[i];
}
double valid_error = datacontainer_.ComputeDeviance(&func_estimate[0], true);
std::auto_ptr<FittedLearner> fit(new FittedLearner(
tree, datacontainer_.get_data(), train_error, valid_error, oobag_improv));
return fit.release();
}
int main()
{
FILE *fi = fopen("ttwo.in", "r");
FILE *fo = fopen("ttwo.out", "w");
int i, j, fx, fy, cx, cy, cd, fd, rst = 0;
char temp[20];
for(i = 0; i < 10; ++i) {
fscanf(fi, "%s", temp);
for(j = 0; j < 10; ++j) {
if(temp[j] == '*')
map[j][i] = 0;
else map[j][i] = 1;
if (temp[j] == 'F') {
fx = j;
fy = i;
}
else if (temp[j] == 'C') {
cx = j;
cy = i;
}
}
}
cd = fd = 0;
while (!flag[fx][fy][fd][cx][cy][cd]) {
flag[fx][fy][fd][cx][cy][cd] = 1;
++rst;
if(fit(fx, fy, fd)) {
fx += di[fd][0];
fy += di[fd][1];
} else fd = (fd + 1) % 4;
if(fit(cx, cy, cd)) {
cx += di[cd][0];
cy += di[cd][1];
} else cd = (cd + 1) % 4;
if ((cx == fx) && (cy == fy)) {
fprintf(fo, "%d\n", rst);
return 0;
}
}
fprintf(fo, "%d\n", 0);
return 0;
}
