Пример #1
0
void pB()
{
	switch (ch) {
	case 'b':
		pb(); pB();
		break;
	case 'c':
		pc(); pC();
		break;
	default :
		error();
	}
}
Пример #2
0
void pA()
{
	switch (ch) {
	case 'a':
		pa(); pA();
		break;
	case 'b':
		pb(); pB();
		break;
	default:
		error();
	}
}
Пример #3
0
  template<class K> Object intersection_unoptimized(const Rectangle_2<K> &a, const Rectangle_2<K> &b) {
    typedef K::Point_2                        Point_2;
    typedef std::vector<Point_2>              Container;
    typedef Polygon_2<K, Container>           Polygon_2;
    typedef Polygon_with_holes_2<K,Container> Polygon_with_holes_2;

    if(a.is_degenerate() || b.is_degenerate()) return Object();
    Container pa(a.center()ontainer(true)), pb(b.center()ontainer(true));
    std::vector<Polygon_with_holes_2> res;
    Polygon_2 polya(pa.begin(),pa.end()), polyb(pb.begin(),pb.end());
    intersection(polya,polyb,std::back_inserter(res));
    return (res.empty())?Object():make_object(res.back().outer_boundary().container());
  }
Пример #4
0
    //-----------------------------------------------------------------------
    void RenderTarget::writeContentsToFile(const String& filename)
    {
        PixelFormat pf = suggestPixelFormat();

        uchar *data = OGRE_ALLOC_T(uchar, mWidth * mHeight * PixelUtil::getNumElemBytes(pf), MEMCATEGORY_RENDERSYS);
        PixelBox pb(mWidth, mHeight, 1, pf, data);

        copyContentsToMemory(pb, pb);

        Image().loadDynamicImage(data, mWidth, mHeight, 1, pf, false, 1, 0).save(filename);

        OGRE_FREE(data, MEMCATEGORY_RENDERSYS);
    }
Пример #5
0
void	pushswap(t_struct **la, t_struct **lb)
{
	int			min;

	while (*la)
	{
		min = find_min(*la);
		while ((*la)->val != min)
			ra(la);
		pb(lb, la);
	}
	while (*lb)
		pa(la, lb);
}
Пример #6
0
void splay(int x){
	int s = 1,i = x,y; tmp[1] = i;
	while(!isroot(i)) tmp[++s] = i = f[i];
	while(s) pb(tmp[s--]);
	while(!isroot(x)){
		y = f[x];
		if (!isroot(y)){
			if ((son[f[y]][0] == y) ^ (son[y][0] == x))
			rotate(x); else rotate(y);
		}
		rotate(x);
	}
	up(x);
}
/// the Poisson bracket of two polynomials in this algebra
Polynomial ClassicalLieAlgebra::poissonBracket(const Polynomial& polA,
                                               const Polynomial& polB) const {
  if (!(hasElt(polA) && hasElt(polB)))
    throw LieAlgebraSizeMismatchError();
  assert(polA.hasSameNumVars(polB));
  Polynomial pb(zero());
  Polynomial pbA(zero());
  Polynomial pbB(zero());
  for (Index d = 0; d < dof_; ++d) {
    pbA = (polA.diff(iQ(d)) * polB.diff(iP(d)));
    pbB = (polA.diff(iP(d)) * polB.diff(iQ(d)));
    pb += (pbA - pbB);
  }
  return pb;
}
Пример #8
0
void Programmer::WriteInfoPage(const uint8_t chipID[5])
{
	// first parse the chipID

	// do an erase all
	// we must do this for the chip to allow an InfoPage erase
	EraseAll();

	ProgressBar pb("Writing IP");
	
	// send the erase page command
	req_erase_page_t erasePage;
	erasePage.page_num = 0;
	erasePage.length = sizeof erasePage;
	erasePage.request = reqErasePageIP;
	reqSetChecksum(erasePage);
	
	SendRequest(erasePage);

	pb.Refresh(0.3);
	
	// validate the response
	resp_simple_t resp;
	ReadResponse1(resp);

	if (resp.response != req2resp(reqErasePageIP))
		throw std::string("Unexpected response from programmer while erase page in WriteInfoPage()");

	// now init and send the new InfoPage
	req_write_flash_t writeFlash;
	writeFlash.length = sizeof writeFlash;
	writeFlash.address = 0;
	writeFlash.request = reqWriteInfoPage;
	memset(writeFlash.data, 0xff, sizeof writeFlash.data);
	memcpy(writeFlash.data + 0x0B, chipID, CHIP_ID_BYTES);
	reqSetChecksum(writeFlash);
	SendRequest(writeFlash);

	pb.Refresh(0.6);
	
	// validate
	ReadResponse1(resp);

	if (resp.response != req2resp(reqWriteInfoPage))
		throw std::string("Unexpected response from programmer while writing page in WriteInfoPage()");
		
	pb.Refresh(1);
}
Пример #9
0
    Usart3::Usart3(
            uint32_t baudRate_,
            uint16_t wordLength_,
            uint16_t parity_,
            uint16_t stopBits_,
            uint16_t flowControl_,
            uint16_t mode_) : UsartPeripheral(USART3,DMA1_Channel2,DMA1_Channel3,2,USART3_IRQn) {

        RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);

        GpioPort pb(GPIOB);
        pb.initialise(GPIO_Speed_50MHz,GPIO_Mode_AF_PP,GPIO_Pin_TX);                 // TX
        pb.initialise(GPIO_Speed_50MHz,GPIO_Mode_IN_FLOATING,GPIO_Pin_RX);     // RX

        initialisePeripheral(baudRate_,wordLength_,parity_,stopBits_,flowControl_,mode_);
    }
Пример #10
0
  // bool publishFrame(Ogre::RenderWindow * render_object, const std::string frame_id)
  bool publishFrame(Ogre::RenderTexture * render_object, const std::string frame_id)
  {
    if (pub_.getTopic() == "")
    {
      return false;
    }
    if (frame_id == "")
    {
      return false;
    }
    // RenderTarget::writeContentsToFile() used as example
    int height = render_object->getHeight();
    int width = render_object->getWidth();
    // the results of pixel format have to be used to determine
    // image.encoding
    Ogre::PixelFormat pf = render_object->suggestPixelFormat();
    uint pixelsize = Ogre::PixelUtil::getNumElemBytes(pf);
    uint datasize = width * height * pixelsize;

    // 1.05 multiplier is to avoid crash when the window is resized.
    // There should be a better solution.
    uchar *data = OGRE_ALLOC_T(uchar, datasize * 1.05, Ogre::MEMCATEGORY_RENDERSYS);
    Ogre::PixelBox pb(width, height, 1, pf, data);
    render_object->copyContentsToMemory(pb, Ogre::RenderTarget::FB_AUTO);

    sensor_msgs::Image image;
    image.header.stamp = ros::Time::now();
    image.header.seq = image_id_++;
    image.header.frame_id = frame_id;
    image.height = height;
    image.width = width;
    image.step = pixelsize * width;
    if (pixelsize == 3)
      image.encoding = sensor_msgs::image_encodings::RGB8;  // would break if pf changes
    else if (pixelsize == 4)
      image.encoding = sensor_msgs::image_encodings::RGBA8;  // would break if pf changes
    else
    {
      ROS_ERROR_STREAM("unknown pixe format " << pixelsize << " " << pf);
    }
    image.is_bigendian = (OGRE_ENDIAN == OGRE_ENDIAN_BIG);
    image.data.resize(datasize);
    memcpy(&image.data[0], data, datasize);
    pub_.publish(image);

    OGRE_FREE(data, Ogre::MEMCATEGORY_RENDERSYS);
  }
Пример #11
0
void		ft_algo(t_tab **op, t_swap **ba, t_swap **bb, unsigned int i)
{
	if (i / 8)
		ft_algo(op, ba, bb, (i / 8));
	if (i % 8 < 3)
		op[i % 8](ba);
	else if (i % 8 == 3 && *bb)
		pb(bb, ba);
	else if (i % 8 == 4 && *ba)
		pa(ba, bb);
	else if (i % 8 == 5)
		op[3](bb);
	else if (i % 8 == 6)
		op[4](bb);
	else if (i % 8 == 7)
		op[5](bb);
}
Пример #12
0
void Partition::FindPartitionFace(SFace* Fa, SFace* Fb)
{
	//比较两个面是否有相邻curve_edge, 如果有那么就判断两面是否是分割面 否则continue
	for(auto i = Fa->faceBounds_.begin(); i != Fa->faceBounds_.end(); i++)
	{
		for(auto ia = ((*i)->edgeLoop_).begin(); ia != ((*i)->edgeLoop_).end(); ia++)
		{
			size_t curveFaceAId = (*ia)->edgeCurveId_;
			for(auto j = Fb->faceBounds_.begin(); j != Fb->faceBounds_.end(); j++)
			{
				for(auto jb = ((*j)->edgeLoop_).begin(); jb != ((*j)->edgeLoop_).end(); jb++)
				{
					size_t curveFaceBId = (*jb)->edgeCurveId_;
					orientationFaceA oriA;
					oriA.advancedFaceOri = Fa->adFaceSameSense_;
					oriA.boundsOri = (*i)->boundsOri_;
					oriA.orientedEdgeOri = (*ia)->orientedEdgeOri_;
					oriA.edgeCurveOri = (*ia)->edgeCurvesameSense_;

					char* curveName = (*ia)->curveName_;
					EdgeCurveVertex curveA, curveB;
					curveA.cartesianStart = (*ia)->edgeStart_;
					curveA.cartesianEnd = (*ia)->edgeEnd_;
					curveA.cartesianStart = (*jb)->edgeStart_;
					curveA.cartesianEnd = (*jb)->edgeEnd_;
					CPoint3D pointA = ((CIRCLE*)(*ia))->position_.point;//圆心
					if(curveFaceBId == curveFaceAId)
					{
						//判断是否是分割面
						bool isPartitionFace = JudgeIntersection(Fa, Fb, curveName,
							oriA, curveA, curveB, pointA);
						if(isPartitionFace)
						{
							pair<size_t, SFace*> pa(Fa->entityID_, Fa);
							pair<size_t, SFace*> pb(Fb->entityID_, Fb);
							partitionFaceList_.insert(pa);
							partitionFaceList_.insert(pb);
						}
						else
							continue;
					}
				}
			}
		}
	}
}
Пример #13
0
    virtual void run()
    {
        python_bridge pb( "processor", "processor" );
        for( int i=0; i<N; i++ )
        {
            // check input event
            const eva::event& e = _inp->next();
            assert( e.get_header()._id == i );

            pb.exec( e.get_raw(), eva::event::size, next().get_raw(), eva::event::size );

            // produce output event
            //next().get_header()._id = i;

            commit();
        }
    }
Пример #14
0
    ATOOLS::Vec4D_Vector  Combine
    (const Cluster_Amplitude &ampl,int i,int j,int k,const ATOOLS::Flavour &mo)
    {
      Mass_Selector *p_ms=ampl.MS();
      if (i>j) std::swap<int>(i,j);
      Vec4D_Vector after(ampl.Legs().size()-1);
      double mb2(0.0);
      if (i<2) {
	mb2=ampl.Leg(1-i)->Mom().Abs2();
	double mfb2(p_ms->Mass2(ampl.Leg(1-i)->Flav()));
	if ((mfb2==0.0 && IsZero(mb2,1.0e-6)) || IsEqual(mb2,mfb2,1.0e-6)) mb2=mfb2;
      }
      Vec4D pi(ampl.Leg(i)->Mom()), pj(ampl.Leg(j)->Mom());
      Vec4D pk(ampl.Leg(k)->Mom()), pb(i<2?ampl.Leg(1-i)->Mom():Vec4D());
      double mi2=pi.Abs2(), mfi2=p_ms->Mass2(ampl.Leg(i)->Flav());
      double mj2=pj.Abs2(), mfj2=p_ms->Mass2(ampl.Leg(j)->Flav());
      double mk2=pk.Abs2(), mfk2=p_ms->Mass2(ampl.Leg(k)->Flav());
      if ((mfi2==0.0 && IsZero(mi2,1.0e-6)) || IsEqual(mi2,mfi2,1.0e-6)) mi2=mfi2;
      if ((mfj2==0.0 && IsZero(mj2,1.0e-6)) || IsEqual(mj2,mfj2,1.0e-6)) mj2=mfj2;
      if ((mfk2==0.0 && IsZero(mk2,1.0e-6)) || IsEqual(mk2,mfk2,1.0e-6)) mk2=mfk2;
      double mij2=p_ms->Mass2(mo);
      Kin_Args lt;
      if (i>1) {
	if (k>1) lt=ClusterFFDipole(mi2,mj2,mij2,mk2,pi,pj,pk,2);
	else lt=ClusterFIDipole(mi2,mj2,mij2,mk2,pi,pj,-pk,2);
	if ((k==0 && lt.m_pk[3]<0.0) ||
	    (k==1 && lt.m_pk[3]>0.0) || lt.m_pk[0]<0.0) return Vec4D_Vector();
      }
      else {
	if (k>1) {
	  lt=ClusterIFDipole(mi2,mj2,mij2,mk2,mb2,-pi,pj,pk,-pb,2);
	}
	else lt=ClusterIIDipole(mi2,mj2,mij2,mk2,-pi,pj,-pk,2);
	if ((i==0 && lt.m_pi[3]<0.0) ||
	    (i==1 && lt.m_pi[3]>0.0) || lt.m_pi[0]<0.0) return Vec4D_Vector();
      }
      if (lt.m_stat<0) return Vec4D_Vector();
      for (size_t l(0), m(0);m<ampl.Legs().size();++m) {
	if (m==(size_t)j) continue;
	if (m==(size_t)i) after[l]=i>1?lt.m_pi:-lt.m_pi;
	else if (m==(size_t)k) after[l]=k>1?lt.m_pk:-lt.m_pk;
	else after[l]=lt.m_lam*ampl.Leg(m)->Mom();
	++l;
      }
      return after;
    }
Пример #15
0
void	tri_simple(t_lst *l, t_options *options, int *tri)
{
	while ((l->a)->length > 0)
	{
		more_effective_moving(l, find_min(&l->a), options);
		pb(l);
		if (options->v == 1)
			show_piles(l, "pb");
	}
	while ((l->b)->length > 0)
	{
		pa(l);
		if (options->v == 1)
			show_piles(l, "pa");
	}
	*tri = 2;
}
Пример #16
0
 void maxsmt_solver_base::commit_assignment() {
     expr_ref tmp(m);
     expr_ref_vector fmls(m);
     rational k(0), cost(0);
     vector<rational> weights;
     for (soft const& s : m_soft) {
         if (s.is_true()) {
             k += s.weight;
         }
         else {
             cost += s.weight;
         }
         weights.push_back(s.weight);
         fmls.push_back(s.s);
     }       
     pb_util pb(m);
     tmp = pb.mk_ge(weights.size(), weights.c_ptr(), fmls.c_ptr(), k);
     TRACE("opt", tout << "cost: " << cost << "\n" << tmp << "\n";);
Пример #17
0
int main(int , char **)
{
    std::cout << "Tests on gfa library" << std::endl;

    std::cout << "Create Point3D and assign to other Point3D" << std::endl;
    GFA::Point3D pa(1,2,3);
    GFA::Point3D pb(4,5,6);
    std::cout << pa.x << " " << pa.y << " " << pa.z << std::endl;
    std::cout << pb.x << " " << pb.y << " " << pb.z << std::endl;
    pa = pb;
    std::cout << pa.x << " " << pa.y << " " << pa.z << std::endl;
    GFA::Point3D pd(pb);
    std::cout << pd.x << " " << pd.y << " " << pd.z << std::endl;
    // This should give an error
    //GFA::Point3D pe(pc);
    
    return 0;
}
Пример #18
0
int  MediaMemoryAllocator<memorytype>::GetMediaBuffer(sp<IMediaBuffer>& Sample)
{
	AutolockEx _l(m_lock);
	if(m_availablememory.size())
	{
		Sample.clear();
		sp<IMediaBufferAllocator> p(this);
		sp<IMemory> pb((m_availablememory.begin())->get());
		Sample = new CMediaBuffer(p,pb);
		m_availablememory.erase(m_availablememory.begin());
		return OK;
	}
	
	LOGI("[VTMAL]MediaMemoryAllocator<%d> GetMediaBuffer fail,m_samplenums=%d,m_samplesize=%d",\
		memorytype,m_samplenums,m_samplesize);
	 return NO_MEMORY;

}
Пример #19
0
unsigned LAVar::setBound( const Real & v, bool upper )
{
  unsigned i = getBoundByValue( v, upper );
  if( i != 0 )
    return i;

  Delta * bound = NULL;

  Delta::deltaType bound_type = ( upper ? Delta::UPPER : Delta::LOWER );

  bound = new Delta( v );

  assert( bound );

  LAVarBound pb( bound, NULL, ( bound_type == Delta::UPPER ), false );

  addBoundAndUpdateSorting( pb );
  return getBoundByValue( v, upper );
}
Пример #20
0
void IcoCreatorView::on_button_save()
{
	CL_SaveFileDialog dlg(this);

	dlg.add_filter("ICO files", "*.ico", true);
	dlg.add_filter("All files", "*.*");

	dlg.set_initial_directory(CL_System::get_exe_path());

	if(dlg.show())
	{
		CL_String filename = dlg.get_filename();

		try
		{
			CL_IconSet icon_set;

			int count = 0;
			for(int i = 0; i < 11; ++i)
			{
				if(lineedit_selected_file[i]->get_text().empty() == false)
				{
					CL_PixelBuffer pb(lineedit_selected_file[i]->get_text());
					icon_set.add_image(pb);
					count++;
				}
			}

			CL_DataBuffer databuffer = icon_set.create_win32_icon();

			CL_File ico_file(filename, CL_File::create_always, CL_File::access_write);
			ico_file.write(databuffer.get_data(), databuffer.get_size());
			
			ico_file.close();

			label_result->set_text(cl_format("Saved %1 images into ico file: %2", count, filename));
		}
		catch(CL_Exception error)
		{
			label_result->set_text(cl_format("Save error: %1", error.message));
		}
	}
}
Пример #21
0
BOOL CCarlaLanguage::open(LPCTSTR lpszPathName)
{
	CString sPath(lpszPathName);
	// this isn't needed since the calling methods make sure it is here
	if(!theApp.askUserToFindFileIfNotFound(sPath, CLangModelsDoc::getRegFileTypeID()))
		return FALSE;




	CSimpleProgressBar pb(_T(""));
	pb.SetTextEx(_T("Loading"), getName(), _T(" Lang File..."));

	USES_CONVERSION_U8;
	SFMFile *pFile = new SFMFile(T2CA(sPath), getCommentChar());
	if(!pFile->ensureOpen(_T("Language Document")))
		return FALSE;
	m_mfs.m_sCtrlFilesDirectory = getDirectory(sPath);

	// rename?
	if(::_tcsicmp(m_mfs.m_sCtrlFilesDirectory.Right(14), _T("Control Files\\")))
	{
		int len = m_mfs.m_sCtrlFilesDirectory.GetLength();
		CString sOldDirName = m_mfs.m_sCtrlFilesDirectory.Left(len-1);
		CString sNewDirName = m_mfs.m_sCtrlFilesDirectory.Left(1+len-_tcslen(_T("Files\\"))) + CONTROL_FOLDER_SUFFIX;

		if(-1 == _taccess(sNewDirName, 00))	// directory not found
		{
			CString s;
			s.Format(_T("This version of CarlaStudio uses a new name for the folder that contains control files.\n\nThe folder named %s will now be renamed to %s"),
						(LPCTSTR)sOldDirName, (LPCTSTR)sNewDirName);
			AfxMessageBox(s, MB_ICONINFORMATION   );
			if(0 == _taccess(m_mfs.m_sCtrlFilesDirectory, 00))	// is the dir of the old name there?
			{
				// rename it
				TRY
				{
					CFile::Rename( sOldDirName, sNewDirName );
				}
				CATCH( CFileException, e )
				{
					::checkForFileError(m_mfs.m_sCtrlFilesDirectory);
				}
Пример #22
0
		virtual std::vector<csce::point<T>> compute_hull(std::vector<csce::point<T>>& points) {
			if(points.size() <= 3){
				return points;
			}

			std::size_t index = this->pivot_index(points);
			if(index != 0){
				std::swap(points[0], points[index]);
			}
			
			//sort the points by angle around the pivot point (points[0])
			std::sort(points.begin() + 1, points.end(), [&points](csce::point<T>& a, csce::point<T>& b) {
				csce::vector2d<T> pa(points[0], a);
				csce::vector2d<T> pb(points[0], b);
				return pa.ccw(pb);
			});
			
			std::vector<csce::point<T>> s;
			s.reserve(points.size() + 1);
			
			s.push_back(points[points.size() - 1]);
			s.push_back(points[0]);
			s.push_back(points[1]);
			
			int x=2;
			while(x < points.size()){
				std::size_t y = s.size() - 1;
				csce::vector2d<T> a(s[y-1], s[y]);
				csce::vector2d<T> b(s[y-1], points[x]);
				if(a.ccw(b)){
					s.push_back(points[x++]);
				} else {
					s.pop_back();
				}
			}
			
			if(s.front() == s.back()){
				s.pop_back(); //the polygon is closed, so remove the last element to remove the duplicate point
			}

			return s;
		}
Пример #23
0
void		big_pile_algo(void)
{
	unsigned	bigger_index;
	unsigned	size;

	size = pile_size(g_pilea);
	while (g_pilea)
	{
		bigger_index = position_of_higher(g_pilea);
		if (bigger_index > size / 2)
			while (bigger_index++ < size)
				rra();
		else
			while (bigger_index-- > 0)
				ra();
		pb();
		size--;
	}
	while (g_pileb)
		pa();
}
Пример #24
0
void Programmer::EraseAll()
{
	ProgressBar pb("Erase all");
	
	// send ERASE_ALL request
	req_simple_t req;
	req.length = sizeof req;
	req.request = reqEraseAll;
	reqSetChecksum(req);
	SendRequest(req);

	pb.Refresh(0.5);
	
	// validate response
	resp_simple_t resp;
	ReadResponse1(resp);

	if (resp.response != req2resp(reqEraseAll))
		throw std::string("Unexpected response from programmer in EraseAll()");

	pb.Refresh(1);
}
Пример #25
0
void Programmer::DisableReadback(const int region)
{
	ProgressBar pb("Disabling");
	
	req_simple_t req;
	req.length = sizeof req;
	req.request = region == DISABLE_MB ? reqDisReadMainBlock : reqDisReadInfoPage;
	reqSetChecksum(req);
	
	SendRequest(req);
	
	pb.Refresh(0.5);

	// validate
	resp_simple_t resp;
	ReadResponse1(resp);
	
	if (resp.response != req2resp(req.request))
		throw std::string("Unexpected response from programmer while disabling readback DisableReadback()");
		
	pb.Refresh(1);
}
Пример #26
0
void helix::generate(){
        
    
    //float radius = 200;
    
    for (int i = 0; i < 200; i++){
        
        float pct = i / 200.0;
        
        float r = 100 + 500 * pct;
        float x = r * cos(  pct * TWO_PI * 2 );
        float y = r * sin(  pct * TWO_PI * 2 );
        float z = pct * 900;
        
        ofPoint pa(x,y, z);
        
        helix0.addVertex(  ofPoint(x,y,z) );
        
        
        x = r * cos(  pct * TWO_PI * 2 + PI );
        y = r * sin(  pct * TWO_PI * 2 + PI);
        
        ofPoint pb(x,y,z);
        
        
        if (i % 3 == 0){
            
            line l;
            l.a = pa;
            l.b = pb;
            lines.push_back(l);
        }
        
        helix1.addVertex(  ofPoint(x,y, z) );
        
    }
    
}
Пример #27
0
void Debugger::process()
{
assert(false && "Needs rewriting");
#if 0
    ExecutionPaths paths;
    std::ofstream logfile;
    logfile.open(LogFile.c_str());

    PathBuilder pb(&m_parser);
    m_parser.parse(m_fileName);

    pb.enumeratePaths(paths);

    PathBuilder::printPaths(paths, std::cout);

    ExecutionPaths::iterator pit;

    unsigned pathNum = 0;
    for(pit = paths.begin(); pit != paths.end(); ++pit) {
        if (PathId != -1) {
            if (pathNum != (unsigned)PathId) {
                continue;
            }
        }

        std::cout << "Analyzing path " << pathNum << '\n';
        ModuleCache mc(&pb);

        //MemoryDebugger md(&m_binaries, &mc, &pb, logfile);
        //md.lookForValue(MemoryValue);

        ExecutionDebugger ed(&m_binaries, &mc, &pb, logfile);

        pb.processPath(*pit);
        ++pathNum;
    }
#endif
}
Пример #28
0
void Programmer::WriteMainBlock(const std::string& hexfilename)
{
	FlashMemory flash(flashSize);
	
	flash.LoadHex(hexfilename);		// read the HEX file
	
	printf("Loaded %i bytes from HEX file %s\n\n", flash.GetFlashLastByte() + 1, hexfilename.c_str());

	EraseAll();			// erase the chip's MainBlock

	// do the flash writing
	ProgressBar pb("Writing MB");
	
	// start writing the flash
	int address = 0;
	while (address < flash.GetFlashSize())
	{
		const uint8_t* pChunk = flash.GetFlash() + address;

		// Check all the bytes of the chunk to see if we have any non-0xff bytes. This is
		// good because we don't want to waste time sending an empty block for programming.
		int bytes = 0, c;
		for (c = 0; c < PROG_CHUNK_SIZE; c++)
		{
			if (pChunk[c] != 0xff)
				bytes = c + 1;
		}

		// do we have a non-empty block?
		if (bytes)
			WriteChunk(false, flash, address);

		address += PROG_CHUNK_SIZE;

		// update the progress bar
		pb.Refresh(address / double(flash.GetFlashSize()));
	}
}
Пример #29
0
int			checker_calc(t_e *e)
{
	char	*line;

	while (get_next_line(0, &line) != 0)
	{
		if (ft_strcmp("sa", line) == 0)
			sa(e->l_a);
		else if (ft_strcmp("sb", line) == 0)
			sb(e->l_b);
		else if (ft_strcmp("ss", line) == 0)
			ss(e->l_a, e->l_b);
		else if (ft_strcmp("ra", line) == 0)
			ra(e->l_a);
		else if (ft_strcmp("rb", line) == 0)
			rb(e->l_b);
		else if (ft_strcmp("rr", line) == 0)
			rr(e->l_a, e->l_b);
		else if (ft_strcmp("rra", line) == 0)
			rra(e->l_a);
		else if (ft_strcmp("rrb", line) == 0)
			rrb(e->l_b);
		else if (ft_strcmp("rrr", line) == 0)
			rrr(e->l_a, e->l_b);
		else if (ft_strcmp("pa", line) == 0)
			pa(e->l_a, e->l_b);
		else if (ft_strcmp("pb", line) == 0)
			pb(e->l_a, e->l_b);
		else
		{
			ft_putendl_fd("Error", 2);
			ft_memdel((void **)&line);
			return (0);
		}
		ft_memdel((void **)&line);
	}
	return (1);
}
Пример #30
0
void 
RFC_Pane_base::init() {
  
  // Determine whether the pane has quadratic elements
  if ( !_base->is_structured()) {
    _base->elements( _elem_conns);
    _elem_offsets.reserve( _elem_conns.size());

    for ( std::vector<const COM::Connectivity*>::const_iterator
	    it = _elem_conns.begin(); it != _elem_conns.end(); ++it) {
      _elem_offsets.push_back( (*it)->index_offset());
      const int ne = (*it)->size_of_edges_pe();
      const int nn = (*it)->size_of_nodes_pe();
      if ( nn > ne) _quadratic = true;
    }
  }

  MAP::Pane_boundary pb( _base);
  pb.determine_border_nodes( _is_border, _is_isolated);

  for ( int i=0, n=_is_border.size(); i<n; ++i) 
  { _n_border += _is_border[i]; _n_isolated += _is_isolated[i]; }
}