bool isNumeric(char* string)
{
int sz = strlen(string);
if (sz == 0) return false;
int fi=0;
char *s = string;
bool dot = false, ep = false;
if (!isInt(s, fi, sz - 1,dot)) return false;
for (; fi < sz; fi++){
if (dot){
if (!(s[fi] >= '0'&&s[fi] <= '9') && s[fi] != 'e'&&s[fi] != 'E') return false;
}
else{
if (!(s[fi] >= '0'&&s[fi] <= '9') && s[fi] != 'e'&&s[fi] != 'E' && s[fi] != '.') return false;
}
if (s[fi] == '.') {
dot = true;
}
if (s[fi] == 'e' || s[fi] == 'E') {
ep = true; break;
}
}
dot = false;
if (ep) {
fi++;
if(!isInt(s, fi, sz - 1,dot)) return false;
if (dot == true) return false;
for (; fi <sz ; fi++){
if (!(s[fi] >= '0'&&s[fi] <= '9')) return false;
}
}
return true;
}
Optional<Opcode> invertedCompare(Opcode opcode, Type type)
{
switch (opcode) {
case Equal:
return NotEqual;
case NotEqual:
return Equal;
case LessThan:
if (isInt(type))
return GreaterEqual;
return Nullopt;
case GreaterThan:
if (isInt(type))
return LessEqual;
return Nullopt;
case LessEqual:
if (isInt(type))
return GreaterThan;
return Nullopt;
case GreaterEqual:
if (isInt(type))
return LessThan;
return Nullopt;
case Above:
return BelowEqual;
case Below:
return AboveEqual;
case AboveEqual:
return Below;
case BelowEqual:
return Above;
default:
return Nullopt;
}
}
//ONLY USED IF USING DESCRIPTORS
SpriteSheetDescription Resources::loadDescription(std::string fileName) {
std::string filePath = TEXTURETPATH + fileName + TEXTUREDESCRIPTIONEXTENSION;
SpriteSheetDescription ret;
// leer el fichero
std::ifstream file(filePath);
if (!file.is_open()) {
std::cout << "Error opening file on resources loadDescription " << filePath << std::endl;
exit(EXIT_FAILURE);
}
std::vector<std::pair<int, std::string> > v;
int lineNum = 0;
std::string line;
while (getline(file,line)) {
++lineNum;
for (int i = 0; i < int(line.size()-1); ++i) {
if (line[i] == '/' && line[i+1] == '/') {
line = line.substr(0,i);
break;
}
}
std::istringstream aux(line);
std::string s;
while(aux >> s)
v.push_back(std::make_pair(lineNum,s));
}
SpriteSheetDescription ssd;
std::map<std::string, int> positions;
for (int i = 0; i < int(v.size()); ++i) {
lineNum = v[i].first;
std::string key = v[i].second;
int descriptorPosition;
if (positions.find(key) == positions.end()) {
descriptorPosition = positions.size();
positions.insert(std::make_pair(key,descriptorPosition));
ssd.push_back(std::vector<sf::IntRect>());
}
else {
descriptorPosition = positions[key];
}
//std::cout << "insertando la key " << key << " en la posicion " << descriptorPosition << std::endl;
if (i+4 >= int(v.size()) ||
!isInt(v[i+1].second) ||
!isInt(v[i+2].second) ||
!isInt(v[i+3].second) ||
!isInt(v[i+4].second)) {
std::cout << "Error in line " << lineNum << ": four integers are needed" << std::endl;
exit(EXIT_FAILURE);
}
sf::IntRect intRect(myStoi(v[i+1].second),
myStoi(v[i+2].second),
myStoi(v[i+3].second),
myStoi(v[i+4].second));
ssd[descriptorPosition].push_back(intRect);
i += 4;
}
return ssd;
}
int input(int argLen, char* zinomoton[], int* customers, int* numOfTellers, float* simTime, float* avgService)
{
if (argLen>6)
{
printf("I'm sorry, you've entered too many arguments.\n");
return EXIT_FAILURE;
}
if (argLen<5)
{
printf("I'm sorry, you've entered too few arguments.\n");
return EXIT_FAILURE;
}
if (isInt(zinomoton[1],FALSE)) *customers = atoi(zinomoton[1]);
else
{
printf("I'm sorry, but the number of customers (the first parameter) must be a positive integer.\n");
return EXIT_FAILURE;
}
if (isInt(zinomoton[2],FALSE)) *numOfTellers = atoi(zinomoton[2]);
else
{
printf("I'm sorry, but the number of tellers (the second parameter) must be a positive integer.\n");
return EXIT_FAILURE;
}
if (isDec(zinomoton[3],FALSE)) *simTime = atof(zinomoton[3]);
else
{
printf("I'm sorry, but the simulation time (the third parameter) must be a positive real number.\n");
return EXIT_FAILURE;
}
if (isDec(zinomoton[4],FALSE)) *avgService = atof(zinomoton[4]);
else
{
printf("I'm sorry, but the average service time (the fourth parameter) must be a positive real number.\n");
return EXIT_FAILURE;
}
if (argLen==6)
{
if (isInt(zinomoton[5],FALSE)) srand(atoi(zinomoton[5]));
else
{
printf("I'm sorry, but the random seed (the fifth parameter) must be a positive integer.\n");
return EXIT_FAILURE;
}
}
else
{
struct timeval time;
gettimeofday(&time,NULL);
srand(time.tv_usec);
}
return EXIT_SUCCESS;
}
bool GenericType::can_cast_to(opt_type other) const {
switch (other) {
case OT_BOOLEAN:
return isBool() || isInt() || isDouble();
case OT_BOOLVECTOR:
return isIntVector() || isDoubleVector();
case OT_INTEGER: case OT_REAL:
return isInt() || isDouble();
case OT_INTEGERVECTOR: case OT_REALVECTOR:
return isDoubleVector() || isIntVector();
default:
return type_ == other;
}
}
bool dynamic::operator==(dynamic const& o) const {
if (type() != o.type()) {
if (isNumber() && o.isNumber()) {
auto& integ = isInt() ? *this : o;
auto& doubl = isInt() ? o : *this;
return integ.asInt() == doubl.asDouble();
}
return false;
}
#define FB_X(T) return *getAddress<T>() == *o.getAddress<T>();
FB_DYNAMIC_APPLY(type_, FB_X);
#undef FB_X
}
int Lisp::eval(){
switch(buf[index]){
case '(':
++depth;
case ' ':
case '\t':
++index;
return eval();
case ')':
--depth;
++index;
return 0; //eval()を続けないという意味であり、0に意味があるわけではない。
case '+':
++index;
return plus();
case '-':
++index;
return sub();
case '*':
++index;
return mul();
case '/':
++index;
return div();
default:
break;
}
if(isInt(buf.substr(index,1))){
return stoi(lexInt());
}else{
cout << "Error" << endl;
return 0;
}
}
/** reads the nblocks section */
static
SCIP_RETCODE readNBlocks(
SCIP* scip, /**< SCIP data structure */
BLKINPUT* blkinput /**< BLK reading data */
)
{
int nblocks;
assert(scip != NULL);
assert(blkinput != NULL);
while( getNextToken(blkinput) )
{
/* check if we reached a new section */
if( isNewSection(scip, blkinput) )
{
if( blkinput->nblocks == NOVALUE )
syntaxError(scip, blkinput, "no integer value in nblocks section");
else
return SCIP_OKAY;
}
/* read number of blocks */
if( isInt(scip, blkinput, &nblocks) )
{
if( blkinput->nblocks == NOVALUE )
blkinput->nblocks = nblocks;
else
syntaxError(scip, blkinput, "2 integer values in nblocks section");
SCIPdebugMessage("Number of blocks = %d\n", blkinput->nblocks);
}
}
return SCIP_OKAY;
}
/** reads the presolved section */
static
SCIP_RETCODE readPresolved(
SCIP* scip, /**< SCIP data structure */
BLKINPUT* blkinput /**< DEC reading data */
)
{
int presolved;
assert(scip != NULL);
assert(blkinput != NULL);
while( getNextToken(blkinput) )
{
/* check if we reached a new section */
if( isNewSection(scip, blkinput) )
return SCIP_OKAY;
/* read number of blocks */
if( isInt(scip, blkinput, &presolved) )
{
blkinput->haspresolvesection = TRUE;
if( presolved == 1 )
blkinput->presolved = TRUE;
else if ( presolved == 0 )
blkinput->presolved = FALSE;
else
syntaxError(scip, blkinput, "presolved parameter must be 0 or 1");
SCIPdebugMessage("Decomposition is%s from presolved problem\n",
blkinput->presolved ? "" : " not");
}
}
return SCIP_OKAY;
}
inline int64 DictValue::get<int64>(int idx) const
{
CV_Assert((idx == -1 && size() == 1) || (idx >= 0 && idx < size()));
idx = (idx == -1) ? 0 : idx;
if (type == Param::INT)
{
return (*pi)[idx];
}
else if (type == Param::REAL)
{
double doubleValue = (*pd)[idx];
double fracpart, intpart;
fracpart = std::modf(doubleValue, &intpart);
CV_Assert(fracpart == 0.0);
return (int64)doubleValue;
}
else
{
CV_Assert(isInt() || isReal());
return 0;
}
}
bool isNumber(const char *s) {
int e = -1;
while (*s == ' ') s++;
if (*s == '+' || *s == '-'){
s++;
}
int n = strlen(s);
while (n>0 && s[n-1] == ' ') n--;
for (int i = 0; i<n; i++) if (s[i] == 'e'){
e = i;
break;
}
if (e == -1){
return isdouble(s, n);
}
if (!isdouble(s, e)) return false;
s += e+1;
n-=e+1;
if (*s == '+' || *s == '-'){
s++;
n--;
}
return isInt(s, n);
}
bool Value::isConvertibleTo(ValueType other) const {
switch (other) {
case nullValue:
return (isNumeric() && asDouble() == 0.0) ||
(type_ == booleanValue && value_.bool_ == false) ||
(type_ == stringValue && asString() == "") ||
(type_ == arrayValue && value_.map_->size() == 0) ||
(type_ == objectValue && value_.map_->size() == 0) ||
type_ == nullValue;
case intValue:
return isInt() ||
(type_ == realValue && InRange(value_.real_, minInt, maxInt)) ||
type_ == booleanValue || type_ == nullValue;
case uintValue:
return isUInt() ||
(type_ == realValue && InRange(value_.real_, 0, maxUInt)) ||
type_ == booleanValue || type_ == nullValue;
case realValue:
return isNumeric() || type_ == booleanValue || type_ == nullValue;
case booleanValue:
return isNumeric() || type_ == booleanValue || type_ == nullValue;
case stringValue:
return isNumeric() || type_ == booleanValue || type_ == stringValue ||
type_ == nullValue;
case arrayValue:
return type_ == arrayValue || type_ == nullValue;
case objectValue:
return type_ == objectValue || type_ == nullValue;
}
JSON_ASSERT_UNREACHABLE;
return false;
}
Variant getValue(ElmT elm) const {
if (isInt(elm)) {
return getInt(elm);
}
ASSERT(isStr(elm));
return getStr(elm);
}
bool isNumber(const char *s) {
int left = 0, right = strlen(s) - 1;
while(left <= right && (s[left] == ' ' || s[left] == '\t' || s[left] == '\n')) {
++ left;
}
while(left <= right && (s[right] == ' ' || s[right] == '\t' || s[right] == '\n')) {
-- right;
}
if (left > right) return false;
int cnt_dot = 0, cnt_e = 0, pos_e = 0;
for (int i = left; i <= right; ++i) {
if (!('0' <= s[i] && s[i] <= '9')) {
if (s[i] == '.') {
++ cnt_dot;
} else if (s[i] == 'e' || s[i] == 'E'){
++ cnt_e;
pos_e = i;
} else if (s[i] != '-' && s[i] != '+'){
return false;
}
}
}
if (cnt_e > 1 || cnt_dot > 1) {
return false;
}
if ((cnt_e && isFloat(s, left, pos_e - 1) && isInt(s, pos_e + 1, right)) || (!cnt_e && isFloat(s, left, right))) {
return true;
}
return false;
}
void str::operator-=(int n)
{
if(isInt())
{
(*this) = str::toInt(mpStr) - n; // Call Assignment Operator for int
}
}
void JsonWrapper::get(const char* name, bool dflt, bool& param) const {
auto val = m_config.get(name, dflt);
// Do some simple type conversions that folly used to do
if (val.isBool()) {
param = val.asBool();
return;
} else if (val.isInt()) {
auto valInt = val.asInt();
if (valInt == 0 || valInt == 1) {
param = (val.asInt() != 0);
return;
}
} else if (val.isString()) {
auto str = val.asString();
std::transform(str.begin(), str.end(), str.begin(),
[](auto c) { return ::tolower(c); });
if (str == "0" || str == "false" || str == "off" || str == "no") {
param = false;
return;
} else if (str == "1" || str == "true" || str == "on" || str == "yes") {
param = true;
return;
}
}
throw std::runtime_error("Cannot convert JSON value to bool: " +
val.asString());
}
char* handle_expr_single(char* op, ast* a)
{
if (strcmp(op, "NOT") == 0)
{
if (!isBool(a))
{
char msg[100];
strcpy(msg, "expected BOOL but got ");
strcat(msg, a->type);
error(msg, a);
return "TYPE_ERROR";
}
return "BOOL";
}
else
{
if (!isInt(a) && !isReal(a))
{
char msg[100];
strcpy(msg, "expected INTEGER or REAL but got ");
strcat(msg, a->type);
error(msg, a);
return "TYPE_ERROR";
}
return a->type;
}
}
int BSONElement::getInt(void)
{
int32_t* val = 0;
if (isInt())
val = (int32_t*)((char *)&_element + sizeof(char) + strlen(getKey()) + 1);
return *val;
}
bool Value::isIntegral() const {
#if defined(JSON_HAS_INT64)
return isInt64() || isUInt64();
#else
return isInt() || isUInt();
#endif
}
bool BSONElement::getBool(void)
{
char* val = 0;
if (isInt())
val = (char *)&_element + sizeof(char) + strlen(getKey()) + 1;
return (*val == 1 ? true : false);
}
bool GenericType::operator!=(const GenericType& op2) const{
if(isString() && op2.isString()){
return toString().compare(op2.toString()) != 0;
}
if(isInt() && op2.isInt()){
return toInt() != op2.toInt();
}
if(isDouble() && op2.isDouble()){
return toDouble() != op2.toDouble();
}
if(isDoubleVector() && op2.isDoubleVector()){
const vector<double> &v1 = toDoubleVector();
const vector<double> &v2 = op2.toDoubleVector();
if(v1.size() != v2.size()) return true;
for(int i=0; i<v1.size(); ++i)
if(v1[i] != v2[i]) return true;
return false;
}
if(isIntVector() && op2.isIntVector()){
const vector<int> &v1 = toIntVector();
const vector<int> &v2 = op2.toIntVector();
if(v1.size() != v2.size()) return true;
for(int i=0; i<v1.size(); ++i)
if(v1[i] != v2[i]) return true;
return false;
}
// Different types
return true;
}
Variant getValue(ElmT elm) const {
if (isInt(elm)) {
return getInt(elm);
}
assert(isStr(elm));
return getStr(elm);
}
//can be 2.-3 which just translates to 2.0-3
int scannar::isDecimal(string data)
{
size_t point=data.find_first_of(".");
string regex="0123456789";
//check for decimal
if(point!=string::npos)
{
size_t numerator = data.substr(0,point).find_first_not_of(regex);
size_t denominator= data.substr(point+1).find_first_not_of(regex);
if(numerator!=string::npos||denominator!=string::npos)
{
return 2;
}
}
else
{
//decimal type can support integers
if(isInt(data)==1)
{
return 1;
}
return 2;
}
return 1;
}
double GenericType::toDouble() const{
if(isInt()){
return double(toInt());
} else {
casadi_assert_message(isDouble(),"type mismatch");
return static_cast<const DoubleType*>(get())->d_;
}
}
Litteral& Rationnel::operator/(const Entier& l) const {
double tmp = l.getValue()/getValue();
if (isInt(tmp))
return LitteralManager::getInstance().addEntier(static_cast<int>(tmp));
QString s;
s = QString("%1/%2").arg(getNumerator()).arg(getDenominator()*l.getValue());
return LitteralManager::getInstance().addRationnel(s);
}
int main(int argc, char **argv){
if (argc == 3){
std::string aString = argv[1];
std::string bString = argv[2];
if (isInt(aString) and isInt(bString)){
int a, b;
a = toInt(aString);
b = toInt(bString);
int answer = gcd(a, b);
std::cout << "gcd of " << a << " and " << b << " = " << answer << std::endl;
}
}
else{
std::cout << "It need two integers numbers to work" << std::endl;
}
return 0;
}
void RepoQuery::getInt64(int iCol, int64_t& val) {
if (!isInt(iCol)) {
throw RepoExc(
"RepoQuery::%s(repo=%p) error: Column %d is not an integer in '%s'",
__func__, &m_stmt.repo(), iCol, m_stmt.sql().c_str());
}
val = sqlite3_column_int64(m_stmt.get(), iCol);
}
int isPt(struct a_NODE *node)
{
if(!node)
return FALSE;
if(node->token == '&')
return TRUE;
if(node->token == TK_IDENTIFIER && node->node->type == ID_POINTER)
return TRUE;
if(node->token == '+' && isPt(node->sons[0]) && isInt(node->sons[1]))
return TRUE;
if(node->token == '+' && isPt(node->sons[1]) && isInt(node->sons[0]))
return TRUE;
if(isPt(node->sons[0]))
return TRUE;
return FALSE;
}
A_exp A_NumberExp(A_pos pos, string s)
{A_exp p = checked_malloc(sizeof(*p));
p->kind=A_numberExp;
p->pos=pos;
p->dec_type=isInt(s)?Ty_int:Ty_float;
p->u.number=s;
return p;
}
bool AsmJsType::isSubType(AsmJsType type) const
{
switch (type.which_)
{
case Js::AsmJsType::Double:
return isDouble();
break;
case Js::AsmJsType::MaybeDouble:
return isMaybeDouble();
break;
case Js::AsmJsType::DoubleLit:
return isDoubleLit();
break;
case Js::AsmJsType::Float:
return isFloat();
break;
case Js::AsmJsType::MaybeFloat:
return isMaybeFloat();
break;
case Js::AsmJsType::Floatish:
return isFloatish();
break;
case Js::AsmJsType::FloatishDoubleLit:
return isFloatishDoubleLit();
break;
case Js::AsmJsType::Fixnum:
return which_ == Fixnum;
break;
case Js::AsmJsType::Int:
return isInt();
break;
case Js::AsmJsType::Signed:
return isSigned();
break;
case Js::AsmJsType::Unsigned:
return isUnsigned();
break;
case Js::AsmJsType::Intish:
return isIntish();
break;
case Js::AsmJsType::Void:
return isVoid();
break;
case AsmJsType::Int32x4:
return isSIMDInt32x4();
break;
case AsmJsType::Float32x4:
return isSIMDFloat32x4();
break;
case AsmJsType::Float64x2:
return isSIMDFloat64x2();
break;
default:
break;
}
return false;
}
