void grille::dessinerNiveauHaut(vector<cases> C)
{
ifstream fichier("Matrice02.txt", ios::in); // on ouvre le fichier en lecture
if (fichier) // si l'ouverture a réussi
{
char caractere;
for (int y = 0; y < NB_LIGNES; y++)
{
for (int x = 0; x < NB_COLONNES; x++)
{
fichier.get(caractere);
//Remplissage de la matrice de cases, avec des caracteres
//Ces derniers seront remplacés par des textures dans le mainWindows
Matrice[y][x] = cases(C[caractere - '0']);
cout << caractere;
}
}
fichier.close();
}
else // sinon
cout << "Impossible d'ouvrir le fichier !" << endl;
}
double Auc::auc(const std::vector<double> &propensityScores, const std::vector<int> &treatment) {
unsigned int m = 0;
for (unsigned int i = 0; i < treatment.size(); i++) {
if (treatment.at(i) == 1) {
m++;
}
}
unsigned int n = treatment.size() - m;
std::vector<double> cases(m);
std::vector<double> controls(n);
m = 0;
n = 0;
for (unsigned int i = 0; i < treatment.size(); i++) {
if (treatment.at(i) == 1) {
cases[m++] = propensityScores.at(i);
} else {
controls[n++] = propensityScores.at(i);
}
}
double mean = 0;
for (unsigned int i = 0; i < m; i++) {
double localMean = 0;
for (unsigned int j = 0; j < n; j++) {
double mw = mannWhitneyKernel(cases.at(i), controls.at(j));
localMean += mw;
}
mean += localMean / n;
}
mean /= m;
return mean;
}
/* Returns index if a sentence matches, 0 otherwise */
int cases(int index)
{
if(nextTok(index) == CASE)
{
if(index = cases(index))
return index;
}
index = pushBack(index);
return index;
}
int main()
{
long long int n;
long long int r;
char h[100];
int check = 0;
int i=0;
scanf("%lli", &n);
if(n <= 16){
h[0] = n % 16;
h[0] = cases(h[0]);
printf("%c\n", h[0]);
return 0;
}
while(check==0)
{
r = n;
for(i = 0; r != 0; i++)
{
h[i] = r % 16;
r /= 16;
h[i] = cases(h[i]);
}
for(i = 0; i < strlen(h)/2 ; i++)
{
if(h[i] == h[strlen(h) - i - 1])
{
check = 1;
}
else{
check = 0;
break;
}
}
n++;
}
printf("%s\n", h);
return 0;
}
void SwitchValue::dumpSuccessors(const BasicBlock* block, PrintStream& out) const
{
// We must not crash due to a number-of-successors mismatch! Someone debugging a
// number-of-successors bug will want to dump IR!
if (numCaseValues() + 1 != block->numSuccessors()) {
Value::dumpSuccessors(block, out);
return;
}
out.print(cases(block));
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimAnalysisModels::removeCaseFromAllGroups(RimCase* reservoir)
{
m_gridCollection->removeCase(reservoir->reservoirData());
for (size_t i = 0; i < caseGroups.size(); i++)
{
RimIdenticalGridCaseGroup* cg = caseGroups()[i];
cg->removeCase(reservoir);
}
cases().removeChildObject(reservoir);
}
} END_TEST
TEST_CASE(CheckTimeFaulty) {
std::vector<std::string> cases({
"15:60",
"300:3",
"20:5:59",
"4002:02:19,23",
"30.3"
});
for (size_t i = 0; i < cases.size(); i++) {
if (checktime(cases[i])) {
test.fail(cases[i]);
}
}
} END_TEST
Seq<CaseClause*>* Parser::caseElements()
{
SeqBuilder<CaseClause*> cases(allocator);
bool hasDefault = false;
CaseClause* last = NULL;
for (;;) {
switch (hd ()) {
case T_RightBrace:
return cases.get();
case T_Default: {
if (hd2() != T_Colon)
goto just_a_statement; // default xml namespace
eat(T_Default);
eat(T_Colon);
if (hasDefault)
compiler->syntaxError(position(), SYNTAXERR_DUPLICATE_DEFAULT);
hasDefault = true;
cases.addAtEnd(last = ALLOC(CaseClause, (0, NULL)));
break;
}
case T_Case: {
eat(T_Case);
uint32_t pos = position();
Expr* expr = commaExpression(0);
eat(T_Colon);
cases.addAtEnd(last = ALLOC(CaseClause, (pos, expr)));
}
/*FALLTHROUGH*/
just_a_statement:
default: {
if (last == NULL)
compiler->syntaxError(position(), SYNTAXERR_EXPECT_CASE_OR_DEFAULT);
AvmAssert(last->stmts == NULL);
SeqBuilder<Stmt*> stmts(allocator);
while (hd() != T_RightBrace && hd() != T_Case && hd() != T_Default)
stmts.addAtEnd(statement());
last->stmts = stmts.get();
break;
}
}
}
}
/* Returns index if a sentence matches, 0 otherwise */
int switch_(int index)
{
if(nextTok(index) == SWITCH_START)
{
if(nextTok(index)==OPENTOK)
{
if(index = cases(index))
{
if(index = default_(index))
{
if(nextTok(index) == CLOSETOK)
return index;
}
}
}
}
return 0;
}
void emitSSwitch(HTS& env, const ImmVector& iv) {
const int numCases = iv.size() - 1;
/*
* We use a fast path translation with a hashtable if none of the
* cases are numeric strings and if the input is actually a string.
*
* Otherwise we do a linear search through the cases calling string
* conversion routines.
*/
const bool fastPath =
topC(env)->isA(Type::Str) &&
std::none_of(iv.strvec(), iv.strvec() + numCases,
[&](const StrVecItem& item) {
return curUnit(env)->lookupLitstrId(item.str)->isNumeric();
}
);
auto const testVal = popC(env);
std::vector<LdSSwitchData::Elm> cases(numCases);
for (int i = 0; i < numCases; ++i) {
auto const& kv = iv.strvec()[i];
cases[i].str = curUnit(env)->lookupLitstrId(kv.str);
cases[i].dest = SrcKey{curSrcKey(env), bcOff(env) + kv.dest};
}
LdSSwitchData data;
data.numCases = numCases;
data.cases = &cases[0];
data.defaultSk = SrcKey{curSrcKey(env),
bcOff(env) + iv.strvec()[iv.size() - 1].dest};
auto const dest = gen(env,
fastPath ? LdSSwitchDestFast
: LdSSwitchDestSlow,
data,
testVal);
gen(env, DecRef, testVal);
gen(env, AdjustSP, IRSPOffsetData { offsetFromIRSP(env, BCSPOffset{0}) },
sp(env));
gen(env, JmpSSwitchDest, dest, sp(env));
}
} END_TEST
TEST_CASE(CheckTime) {
std::vector<std::string> cases({
"200",
"15:30",
"300:30",
"20:59:59",
"4002:02:19",
"30.330",
"23:01,000",
"11:09:24.888",
"123121:50:10,132"
});
for (size_t i = 0; i < cases.size(); i++) {
if (!checktime(cases[i])) {
test.fail(cases[i]);
}
}
} END_TEST
} END_TEST
TEST_CASE(SplitToComponentsFaulty) {
std::vector<std::string> cases({
"",
".356",
"90:",
"150::23:13.12",
":13:23",
"133:23:14.231.2",
"22:2.323:231.145",
"583:340:32:23:231.233",
"03:a5:22"
});
std::vector<std::string> components;
for (size_t i = 0; i < cases.size(); i++) {
if (splitTimeString(cases[i], components)) {
test.fail(cases[i]);
}
components.clear();
}
} END_TEST
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimAnalysisModels::moveEclipseCaseIntoCaseGroup(RimCase* rimReservoir)
{
CVF_ASSERT(rimReservoir);
RigCaseData* rigEclipseCase = rimReservoir->reservoirData();
RigMainGrid* equalGrid = registerCaseInGridCollection(rigEclipseCase);
CVF_ASSERT(equalGrid);
// Insert in identical grid group
bool foundGroup = false;
for (size_t i = 0; i < caseGroups.size(); i++)
{
RimIdenticalGridCaseGroup* cg = caseGroups()[i];
if (cg->mainGrid() == equalGrid)
{
cg->addCase(rimReservoir);
foundGroup = true;
}
}
if (!foundGroup)
{
RimIdenticalGridCaseGroup* group = new RimIdenticalGridCaseGroup;
assert(RiaApplication::instance()->project());
RiaApplication::instance()->project()->assignIdToCaseGroup(group);
group->addCase(rimReservoir);
caseGroups().push_back(group);
}
// Remove reservoir from main container
cases().removeChildObject(rimReservoir);
}
std::vector<double> Auc::aucWithCi(const std::vector<double> &propensityScores, const std::vector<int> &treatment) {
unsigned int m = 0;
for (unsigned int i = 0; i < treatment.size(); i++) {
if (treatment.at(i) == 1) {
m++;
}
}
unsigned int n = treatment.size() - m;
std::vector<double> cases(m);
std::vector<double> controls(n);
m = 0;
n = 0;
for (unsigned int i = 0; i < treatment.size(); i++) {
if (treatment.at(i) == 1) {
cases[m++] = propensityScores.at(i);
} else {
controls[n++] = propensityScores.at(i);
}
}
double mean = 0;
for (unsigned int i = 0; i < m; i++) {
double localMean = 0;
for (unsigned int j = 0; j < n; j++) {
double mw = mannWhitneyKernel(cases.at(i), controls.at(j));
localMean += mw;
}
mean += localMean / n;
}
mean /= m;
double vr10[m];
for (unsigned int i = 0; i < m; i++) {
double sum = 0;
for (unsigned int j = 0; j < n; j++) {
sum += mannWhitneyKernel(cases.at(i), controls.at(j));
}
vr10[i] = sum / n;
}
double vr01[n];
for (unsigned int i = 0; i < n; i++) {
double sum = 0;
for (unsigned int j = 0; j < m; j++) {
sum += mannWhitneyKernel(cases.at(j), controls.at(i));
}
vr01[i] = sum / m;
}
double s10 = 0;
for (unsigned int i = 0; i < m; i++) {
s10 += (vr10[i] - mean) * (vr10[i] - mean);
}
s10 /= (double) (m - 1);
double s01 = 0;
for (unsigned int i = 0; i < n; i++) {
s01 += (vr01[i] - mean) * (vr01[i] - mean);
}
s01 /= (double) (n - 1);
double s = s10 / m + s01 / n;
double sd = sqrt(s);
std::vector<double> ci;
ci.push_back(mean);
ci.push_back(mean - (1.96 * sd));
ci.push_back(mean + (1.96 * sd));
return ci;
}
