Eximpl int /* from analyse */
sol_analyse( Board* bp, int depth, Movelist* sols )
{
/*
* Here we know, how to call "analyse".
* We also manage dual-suppression.
*/
int res;
if( depth <= f_nodualdep ) {
/*
* We ask analyse for just one move, and fill that one
* into the given list.
*/
Move move;
move.m_from = NO_POS; /* not yet filled */
res = analyse(bp, depth, (Movelist*)0, &move, (RefuList*)0);
sol_1move_list(&move, ANASUC(res), sols);
}else { /* normal, all solutions */
res = analyse(bp, depth, sols, (Move*)0, (RefuList*)0);
/*
* Now, if the resulting depth is smaller than the asked depth,
* we might fall below the dual suppression limit.
* In this case the list is to be truncated after the first move.
*/
if( (list_length(sols) > 1) /* something to cut off */
&& ANASUC(res) && (ANADEP(res) <= f_nodualdep) ) {
sol_1redu_list(sols);
}
}
return res;
}
/////////////////////////////////////////////////////////////////////////////
// TDrawView::CmECGFilter()
//
// Responds to CM_ECGFILTER message generated by the menu item or button.
/////////////////////////////////////////////////////////////////////////////
void TDrawView::CmECGFilter()
{
const Tecg* ecg;
ecg = DrawDoc->GetECG();
TModule* moduleid = /*GetWindow()->*/GetModule();
TBufFilter filtbuff;
char far *buffer = new char[100];
for (int line=IDS_FILT_FIRST+1 ; line < IDS_FILT_LAST ; line++)
{
moduleid->LoadString(line, buffer, 100);
filtbuff.combo_filt_type.AddString(buffer);
}
filtbuff.combo_filt_type.Select(ecg->get_cur_filt_data().Mode-IDS_FILT_FIRST-1);
delete buffer; // dont want to be leeking
wsprintf(filtbuff.edit_optval, "%d", ecg->get_cur_filt_data().Opt_Val); // set initial optional value (not always used)
TDialog *dialog = new TDlgFilter( this, IDD_FILTER, &filtbuff);
int result = dialog->Execute();
if (result == IDOK)
{
const_cast<Tecg*>(ecg)->set_cur_filt_data(filtbuff.combo_filt_type.GetSelIndex() +IDS_FILT_FIRST +1
, atoi(filtbuff.edit_optval));
TAnalyse_Filter analyse(ecg);
analyse.Set_Filter_Mode(filtbuff.combo_filt_type.GetSelIndex() +IDS_FILT_FIRST +1
, atoi(filtbuff.edit_optval));
analyse.Execute();
//const_cast<Tecg*>(ecg)->AnalyseData(INVERT);
DrawDoc->RePaintViews();
}
}
void get_index(t_atoms *atoms, const char *fnm, int ngrps,
int isize[], atom_id *index[], char *grpnames[])
{
char ***gnames;
t_blocka *grps = NULL;
int *grpnr;
snew(grpnr, ngrps);
snew(gnames, 1);
if (fnm != NULL)
{
grps = init_index(fnm, gnames);
}
else if (atoms)
{
snew(grps, 1);
snew(grps->index, 1);
analyse(atoms, grps, gnames, FALSE, FALSE);
}
else
{
gmx_incons("You need to supply a valid atoms structure or a valid index file name");
}
rd_groups(grps, *gnames, grpnames, ngrps, isize, index, grpnr);
}
/////////////////////////////////////////////////////////////////////////////
// TDrawView::CmECGCalcRunMean()
//
// Responds to CM_ECGCALCRUNMEAN message generated by the menu item or button.
/////////////////////////////////////////////////////////////////////////////
void TDrawView::CmECGCalcRunMean()
{
TBufRunMean rmbuff;
const Tecg* ecg;
ecg = DrawDoc->GetECG();
rmbuff.full = (ecg->get_run_mean_calc() == TRMC_FULL);
rmbuff.rtor = (ecg->get_run_mean_calc() == TRMC_RTR);
rmbuff.rtorwin = (ecg->get_run_mean_calc() == TRMC_RTRWIN);
wsprintf(rmbuff.edit_winsize, "%d", ecg->get_run_mean_winsize());
TDialog *dialog = new TDlgRunMean( this, IDD_RUNNINGMEAN, &rmbuff);
int result = dialog->Execute();
if (result == IDOK)
{
if (rmbuff.full)
const_cast<Tecg*>(ecg)->set_run_mean_calc( TRMC_FULL );
else if (rmbuff.rtor)
const_cast<Tecg*>(ecg)->set_run_mean_calc( TRMC_RTR );
else if (rmbuff.rtorwin)
const_cast<Tecg*>(ecg)->set_run_mean_calc( TRMC_RTRWIN );
const_cast<Tecg*>(ecg)->set_run_mean_winsize(atoi(rmbuff.edit_winsize));
TAnalyse_Run_Mean analyse(ecg);
analyse.Execute();
//const_cast<Tecg*>(ecg)->AnalyseData(CALC_RUN_MEAN_1);
DrawDoc->RePaintViews();
}
}
int main(int argc, const char *argv[])
{
char arr[80];
char *p;
int i = 0;
shell myshell;
while(1)
{
i = 0;
printf("mysh%% ");
fgets(arr,80,stdin);
if(!strcmp(arr,"exit\n"))
return 0;
analyse(arr,&myshell);
printf("command:\t%s\n",myshell.command);
free(myshell.command); myshell.command = NULL;
while(p = myshell.argument[i++])
{
printf("argument%d:\t%s\n",i,p);
free(p); p = NULL;
}
printf("in_file:\t%s\n",myshell.in_file ? myshell.in_file : "NULL");
free(myshell.in_file); myshell.in_file = NULL;
printf("out_file:\t%s\n",myshell.out_file ? myshell.out_file : "NULL");
free(myshell.out_file); myshell.out_file = NULL;
}
return 0;
}
////////////////////////////////////////////////////////////////////////////////
//! Side effect of shared memory access
//! Side effect of shared memory access
//! @param tidx thread id in x dimension of block
//! @param tidy thread id in y dimension of block
//! @param tidz thread id in z dimension of block
//! @param bdimx block size in x dimension
//! @param bdimy block size in y dimension
//! @param bdimz block size in z dimension
//! @param file name of the source file where the access takes place
//! @param line line in the source file where the access takes place
//! @param aname name of the array which is accessed
//! @param index index into the array
////////////////////////////////////////////////////////////////////////////////
void BankChecker::
access( unsigned int tidx, unsigned int tidy, unsigned int tidz,
unsigned int bdimx, unsigned int bdimy, unsigned int bdimz,
const char* file, const int line, const std::string& aname,
const int index)
{
is_active = true;
// linearized thread id
unsigned int ltid = getLtid( tidx, tidy, tidz, bdimx, bdimy, bdimz);
// reset state if new warp
if( 0 == (ltid & (warp_size - 1)))
{
// double check to handle multiple shared mem accesses in one line
if( last_ltid != 0)
{
reset();
}
}
AccessLocation loc( file, line, aname, ltid);
AccessInfo info( ltid, tidx, tidy, tidz, index);
access_data[loc][(index % warp_size)].push_back( info);
if( 15 == (ltid & (warp_size - 1)))
{
analyse( access_data. find( loc));
}
last_ltid = (ltid % warp_size);
}
void PRCExporter::analyse ( osg::Node *nd, prcfile *out )
{
/// here you have found a group.
osg::Geode *geode = dynamic_cast<osg::Geode *> ( nd );
if ( geode )
{
// analyse the geode. If it isnt a geode the dynamic cast gives NULL.
analyseGeode ( geode, out );
}
else
{
osg::Group *gp = dynamic_cast<osg::Group *> ( nd );
if ( gp )
{
// osg::notify ( osg::WARN ) << "Group "<< gp->getName() <<std::endl;
for ( unsigned int ic=0; ic<gp->getNumChildren(); ic++ )
{
analyse ( gp->getChild ( ic ), out );
}
}
// else
// {
// osg::notify ( osg::WARN ) << "Unknown node "<< nd <<std::endl;
// }
}
}
t_filter *init_filter(t_atoms *atoms, const char *fn, int natom_trx)
{
t_filter *f;
int g, i;
snew(f, 1);
if (fn != NULL)
{
f->grps = init_index(fn, &f->grpnames);
}
else
{
snew(f->grps, 1);
snew(f->grps->index, 1);
analyse(atoms, f->grps, &f->grpnames, false, false);
}
snew(f->bDisable, f->grps->nr);
for (g = 0; g < f->grps->nr; g++)
{
for (i = f->grps->index[g]; i < f->grps->index[g+1] && !f->bDisable[g]; i++)
{
f->bDisable[g] = (f->grps->a[i] >= natom_trx);
}
}
snew(f->bShow, f->grps->nr);
return f;
}
static int process_command(int argc, char **argv)
{
static struct option long_options[] = {
{ "dump", no_argument, 0, 'd' },
{ "codegen", no_argument, 0, 'c' },
{ "make", no_argument, 0, 'm' },
{ 0, 0, 0, 0 }
};
opterr = 0;
optind = 1;
int index = 0;
const char *spec = "aer";
switch (getopt_long(MIN(argc, 2), argv, spec, long_options, &index)) {
case 'a':
return analyse(argc, argv);
case 'e':
return elaborate(argc, argv);
case 'r':
return run(argc, argv);
case 'd':
return dump_cmd(argc, argv);
case 'c':
return codegen(argc, argv);
case 'm':
return make_cmd(argc, argv);
default:
fatal("missing command, try %s --help for usage", PACKAGE);
return EXIT_FAILURE;
}
}
void PRCExporter::analyse ( osg::Node *nd, oPRCFile *out )
{
/// here you have found a group.
osg::Geode *geode = dynamic_cast<osg::Geode *> ( nd );
if ( geode )
{
// analyse the geode. If it isnt a geode the dynamic cast gives NULL.
QString nam = QString::fromStdString(geode->getName());
out->begingroup(nam.toLatin1());
analyseGeode ( geode, out );
out->endgroup();
}
else
{
osg::Group *gp = dynamic_cast<osg::Group *> ( nd );
if ( gp )
{
QString nam = QString::fromStdString(gp->getName());
out->begingroup(nam.toLatin1());
// osg::notify ( osg::WARN ) << "Group "<< gp->getName() <<std::endl;
for ( unsigned int ic=0; ic<gp->getNumChildren(); ic++ )
{
analyse ( gp->getChild ( ic ), out );
}
out->endgroup();
}
// else
// {
// osg::notify ( osg::WARN ) << "Unknown node "<< nd <<std::endl;
// }
}
}
void *thread_function(void *index){
// Thread index
int tindex = *(int*)index;
// Key and indexes
AES_KEY key;
uint8_t local_key[16];
int i, i1, i2, i3, i4, i5;
// Allocating text memory
uint8_t *decrypted_text = talloc(uint8_t, LENGTH);
// Defining cipher text and base key
memcpy(local_key, PARTIAL_KEY, 11);
// Defining indexes for this thread
int begin, end;
if(tindex == 0) begin = 33;
else begin = 33 + (tindex * (94/NTHREADS)) + 3;
if(tindex == NTHREADS-1) end = 126;
else end = 33 + ((tindex+1) * (94/NTHREADS) + 2);
// Verbosing about the range
verbose("Thread #%d running in the range %d..%d.", tindex, begin, end);
// Brute force
for(i1=begin; i1<=end; i1++){
local_key[11] = i1;
for(i2=33; i2<=126; i2++){
local_key[12] = i2;
for(i3=33; i3<=126; i3++){
local_key[13] = i3;
for(i4=33; i4<=126; i4++){
local_key[14] = i4;
for(i5=33; i5<=126; i5++){
local_key[15] = i5;
AES_set_decrypt_key(local_key, KEYLEN, &key);
AES_ECB_decrypt(cipher_text, decrypted_text, LENGTH, key.KEY, key.nr);
if(analyse(decrypted_text)){
verbose("Decrypted!");
verbose("Thread #%d found the key.", tindex);
printf(" - Key: ");
for(i=0; i<KEYLEN/8; i++)
printf("%c", local_key[i]);
printf("\n");
decrypt(&key, decrypted_text);
exit(1);
}
}
}
}
}
}
verbose("Thread #%d is done.", tindex);
return;
}
static void start(int* pT1, int* pT2, struct basicVal* pVal)
{
int i;
for (i = 1; i <= pVal->nbJ; i++)
{
if (i % 2 == 0)
analyse(pT2, pT1, pVal);
else
analyse(pT1, pT2, pVal);
if (pVal->nbS != 0 && i % pVal->nbS == 0)
if (i % 2 == 0)
output(pT1, pVal, i);
else
output(pT2, pVal, i);
}
}
/////////////////////////////////////////////////////////////////////////////
// TDrawView::CmECGClearAll()
//
// Responds to CM_ECGCLEARALL message generated by the menu item or button.
/////////////////////////////////////////////////////////////////////////////
void TDrawView::CmECGClearAll()
{
const Tecg* ecg;
ecg = DrawDoc->GetECG();
TAnalyse_Clear_All analyse(ecg);
analyse.Execute();
DrawDoc->RePaintViews();
}
void FrameAnalyser::analyseStack(string filename)
{
ausgabe.open(filename.c_str(), ios::out);
for (int var = myStack->size()-1; var > 0; var--) {
analyse(myStack->getFrame(var));
}
ausgabe.close();
}
void PhotonAnalyser::analyse(const EventPtr event, PhotonCollection signalPhotons, JetCollection cleanJets, ElectronCollection signalElectrons, MuonCollection signalMuons){
//all photons
analyse(event);
//signal photons
analyse_signalPhotons(event, signalPhotons, cleanJets, signalElectrons, signalMuons);
}
/*!
* \param[out] g Index group structure.
* \param[in] top Topology structure.
* \param[in] fnm File name for the index file.
* Memory is automatically allocated.
*
* One or both of \p top or \p fnm can be NULL.
* If \p top is NULL, an index file is required and the groups are read
* from the file (uses Gromacs routine init_index()).
* If \p fnm is NULL, default groups are constructed based on the
* topology (uses Gromacs routine analyse()).
* If both are null, the index group structure is initialized empty.
*/
void
gmx_ana_indexgrps_init(gmx_ana_indexgrps_t **g, t_topology *top,
const char *fnm)
{
t_blocka *block = NULL;
char **names = NULL;
if (fnm)
{
block = init_index(fnm, &names);
}
else if (top)
{
block = new_blocka();
analyse(&top->atoms, block, &names, FALSE, FALSE);
}
else
{
*g = new gmx_ana_indexgrps_t(0);
return;
}
try
{
*g = new gmx_ana_indexgrps_t(block->nr);
for (int i = 0; i < block->nr; ++i)
{
gmx_ana_index_t *grp = &(*g)->g[i];
grp->isize = block->index[i+1] - block->index[i];
snew(grp->index, grp->isize);
for (int j = 0; j < grp->isize; ++j)
{
grp->index[j] = block->a[block->index[i]+j];
}
grp->nalloc_index = grp->isize;
(*g)->names.push_back(names[i]);
}
}
catch (...)
{
for (int i = 0; i < block->nr; ++i)
{
sfree(names[i]);
}
sfree(names);
done_blocka(block);
sfree(block);
throw;
}
for (int i = 0; i < block->nr; ++i)
{
sfree(names[i]);
}
sfree(names);
done_blocka(block);
sfree(block);
}
/**
* enca_analyse_const:
* @analyser: An analyser initialized for some language.
* @buffer: Buffer to be analysed.
* @size: Size of @buffer.
*
* Analyses @buffer and finds its encoding.
*
* The @buffer is checked for 8bit encodings of language for which @analyser
* was initialized and for multibyte encodings, mostly independent on language
* (unless disabled with enca_set_multibyte()).
*
* This function never modifies @buffer (can be even used with string literal
* @buffer) at the expense it's generally slower than enca_analyse().
*
* Returns: Encoding of @buffer. When charset part of return value is
* #ENCA_CS_UNKNOWN, encoding was not determined. Check
* enca_errno() for reason.
**/
EncaEncoding
enca_analyse_const(EncaAnalyserState *analyser,
const unsigned char *buffer,
size_t size)
{
assert(analyser != NULL);
analyser->options.const_buffer = 1;
return analyse(analyser, (unsigned char *)buffer, size);
}
/////////////////////////////////////////////////////////////////////////////
// TDrawView::CmECGRThresh()
//
// Responds to CM_ECGRTHRESH message generated by the menu item or button.
/////////////////////////////////////////////////////////////////////////////
void TDrawView::CmECGRThresh()
{
const Tecg* ecg;
ecg = DrawDoc->GetECG();
TAnalyse_R_Thresh analyse(ecg);
analyse.Execute();
//const_cast<Tecg*>(ecg)->AnalyseData(R_THRESH);
DrawDoc->RePaintViews();
}
/////////////////////////////////////////////////////////////////////////////
// TDrawView::CmECGRChange()
//
// Responds to CM_ECGRCHANGE message generated by the menu item or button.
/////////////////////////////////////////////////////////////////////////////
void TDrawView::CmECGRChange()
{
const Tecg* ecg;
ecg = DrawDoc->GetECG();
TAnalyse_R_Change analyse(ecg);
analyse.Execute();
//const_cast<Tecg*>(ecg)->AnalyseData(R_CHANGE);
DrawDoc->RePaintViews();
}
/////////////////////////////////////////////////////////////////////////////
// TDrawView::CmECGSCalc()
//
// Responds to CM_ECGSCALC message generated by the menu item or button.
/////////////////////////////////////////////////////////////////////////////
void TDrawView::CmECGSCalc()
{
const Tecg* ecg;
ecg = DrawDoc->GetECG();
TAnalyse_S_Calc_1 analyse(ecg);
analyse.Execute();
//const_cast<Tecg*>(ecg)->AnalyseData(S_CALC_1);
DrawDoc->RePaintViews();
}
/**
* enca_analyse:
* @analyser: An analyser initialized for some language.
* @buffer: Buffer to be analysed.
* @size: Size of @buffer.
*
* Analyses @buffer and finds its encoding.
*
* The @buffer is checked for 8bit encodings of language for which @analyser
* was initialized and for multibyte encodings, mostly independent on language
* (unless disabled with enca_set_multibyte()).
*
* The contents of @buffer may be (and probably will be) modified during the
* analyse. Use enca_analyse_const() instead if this discomforts you.
*
* Returns: Encoding of @buffer. When charset part of return value is
* #ENCA_CS_UNKNOWN, encoding was not determined. Check
* enca_errno() for reason.
**/
EncaEncoding
enca_analyse(EncaAnalyser analyser,
unsigned char *buffer,
size_t size)
{
assert(analyser != NULL);
analyser->options.const_buffer = 0;
return analyse(analyser, buffer, size);
}
/////////////////////////////////////////////////////////////////////////////
// TDrawView::CmECGQCalc2()
//
// Responds to CM_ECGQCALC2 message generated by the menu item or button.
/////////////////////////////////////////////////////////////////////////////
void TDrawView::CmECGQCalc2()
{
const Tecg* ecg;
ecg = DrawDoc->GetECG();
TAnalyse_Q_Calc_2 analyse(ecg);
analyse.Execute();
//const_cast<Tecg*>(ecg)->AnalyseData(Q_CALC_2);
DrawDoc->RePaintViews();
}
/////////////////////////////////////////////////////////////////////////////
// TDrawView::CmECGGoodBad()
//
// Responds to CM_ECGGOODBAD message generated by the menu item or button.
/////////////////////////////////////////////////////////////////////////////
void TDrawView::CmECGGoodBad()
{
const Tecg* ecg;
ecg = DrawDoc->GetECG();
TAnalyse_Good_Or_Bad analyse(ecg);
analyse.Execute();
//const_cast<Tecg*>(ecg)->AnalyseData(GOOD_OR_BAD_1);
DrawDoc->RePaintViews();
}
void ScopeConsistencyChecker::checkConsistent(IHqlExpression * root, const HqlExprArray & _activeTables)
{
ForEachItemIn(i, _activeTables)
activeTables.append(OLINK(_activeTables.item(i)));
if (root->isDataset())
pushScope();
analyse(root, 0);
if (root->isDataset())
popScope();
}
static COMMAND_FUNC( danal )
{
Trial_Class *tcp;
tcp = PICK_TRIAL_CLASS("");
if( tcp == NULL ) return;
if( no_data(QSP_ARG "danal") ) return;
analyse(QSP_ARG tcp);
longout(QSP_ARG tcp);
}
void PRCExporter::convertFile ( QString fileName, PageItem_OSGFrame *frame )
{
if ( !fileName.isEmpty() )
{
if ( frame->loadedModel )
{
prcfile oPRC ( fileName.toStdString() );
analyse ( frame->loadedModel.get(), &oPRC );
oPRC.finish();
}
}
}
Type ASTClosure::analyse(SemanticAnalyser *analyser, const TypeExpectation &expectation) {
function_->setOwningType(analyser->function()->owningType());
function_->setFunctionType(analyser->function()->functionType());
auto closureAnalyser = SemanticAnalyser(function_, std::make_unique<CapturingSemanticScoper>(analyser->scoper()));
closureAnalyser.analyse();
captures_ = dynamic_cast<CapturingSemanticScoper&>(closureAnalyser.scoper()).captures();
if (closureAnalyser.pathAnalyser().hasPotentially(PathAnalyserIncident::UsedSelf)) {
captureSelf_ = true;
}
return function_->type();
}
/////////////////////////////////////////////////////////////////////////////
// TDrawView::CmECGInvert()
//
// Responds to CM_ECGINVERT message generated by the menu item or button.
/////////////////////////////////////////////////////////////////////////////
void TDrawView::CmECGInvert()
{
if ( MessageBox("Are you sure?", "Invert ECG", MB_YESNO) == IDYES)
{
const Tecg* ecg;
ecg = DrawDoc->GetECG();
TAnalyse_Invert analyse(ecg);
analyse.Execute();
//const_cast<Tecg*>(ecg)->AnalyseData(INVERT);
DrawDoc->RePaintViews();
}
}
void UnitManager::gather_all_build_data()
{
animsList.clear();
VFS::Instance()->getDirlist("anims\\*", animsList); // GAF-like directories
VFS::Instance()->getFilelist("anims\\*.gaf", animsList); // normal GAF files
name2gaf.clear();
// Cherche un fichier pouvant contenir des informations sur l'unité unit_name
for (int i = 0; i < nb_unit; ++i)
{
String name;
for(int n = 1 ; VFS::Instance()->fileExists(name = String(ta3dSideData.guis_dir) << unit_type[i]->Unitname << n << ".gui") ; ++n)
analyse(name, i);
}
// Fill build menus with information parsed from the sidedata.tdf file
TDFParser sidedata_parser(String(ta3dSideData.gamedata_dir) << "sidedata.tdf", false, true);
for (int i = 0 ; i < nb_unit; ++i)
{
int n = 1;
while(!sidedata_parser.pullAsString(ToLower(String("canbuild.") << unit_type[i]->Unitname << ".canbuild" << n ) ).empty()) n++;
n--;
String canbuild = sidedata_parser.pullAsString(ToLower(String("canbuild.") << unit_type[i]->Unitname << ".canbuild" << n ) );
while (n > 0)
{
int idx = get_unit_index( canbuild );
if (idx >= 0 && idx < nb_unit)
{
if (!unit_type[i]->canBuild(idx)) // Check if it's already in the list
{
GLuint tex = loadBuildPic( String("anims\\") << canbuild << "_gadget", canbuild);
if (!tex && !unit_type[idx]->glpic && unit_type[idx]->unitpic)
{
unit_type[idx]->glpic = gfx->make_texture(unit_type[idx]->unitpic, FILTER_LINEAR, true);
SDL_FreeSurface(unit_type[idx]->unitpic);
unit_type[idx]->unitpic = NULL;
gfx->set_texture_format(gfx->defaultTextureFormat_RGB());
}
if (unit_type[idx]->glpic || tex)
{
const int px = ((n - 1) & 1) * 64;
const int py = 155 + (((n - 1) >> 1) % 3) * 64;
const int p = (n - 1) / 6;
unit_type[i]->AddUnitBuild(idx, px, py, 64, 64, p, tex);
}
else
{ LOG_DEBUG("unit '" << canbuild << "' picture not found in build menu for unit '" << unit_type[i]->Unitname << "'"); }
}
}
else
{ LOG_DEBUG("unit '" << canbuild << "' not found (" << __FILE__ << " l." << __LINE__ << ')'); }
int swap_replica(int irep, int jrep) {
Replica *prepi,*prepj;
Slice *swaptrial, h;
int i,pathlen,ABexchOK,ireptype,jreptype,type;
//double aux;
prepi = replica[irep];
prepj = replica[jrep];
path.block_stats[path.initial_state-1][prepi->index].mcacc[1].tries++;
if(path.fixedbias==0) {
prepi->dos += state[path.initial_state-1].scalefactor;
}
if (jrep<0) {
return 0;
}
if ( (irep==0) || (jrep==0) ) {
return swap_replica_0(irep, jrep);
}
if (( irep==path.nreplica-1 ) && ( jrep==path.nreplica )) {
return 0;
}
if ( jrep>path.nreplica-1 ) {
return 0;
}
//aux = prepi->dos - prepj->dos;
if ( RandomNumber() > exp(prepi->dos - prepj->dos) ) {
return 0;
}
type =analyse(slice, prepj, path.nslices, path.initial_state);
if (type==0) {
return 0;
}
prepj->pathlen =prepi->pathlen;
prepj->type = prepi->type;
SWAP(replica[irep]->swapindex,replica[jrep]->swapindex,i);
path.current_replica=jrep;
path.block_stats[path.initial_state-1][prepi->index].mcacc[1].acc++;
return 1;
}
