char *my_modulo(char *n1, char *n2)
{
t_div *d;
d = init_my_mod(n1, n2);
if ((d != NULL) && (my_str_isnum(d->dvd) == 1) && (my_str_isnum(d->dvs) == 1))
if (d->dvs[0] != '0')
{
while (d->dvd[0] != '-')
{
if ((my_do_op_sub_cmp(d->dvs, d->dvd, 0, 0) == 0) &&
(d->mod[0] == '0'))
my_strcpy(d->mod, d->dvd);
my_strcpy(d->temp_cmp, d->dvs);
my_strcpy(d->temp_fact, "1");
while (my_do_op_sub_cmp(d->temp_cmp, d->dvd, 0, 0) == 1)
add_zero(d);
(check_digits(d) == 1) ? (add_zero(d)) : (1);
remove_zero(d);
if (check_digits(d) == 1)
d->temp_fact = add_sub(d->temp_fact, "-1");
get_minus(d->temp_cmp);
d->total = add_sub(d->total, d->temp_fact);
d->dvd = add_sub(d->dvd, d->temp_cmp);
}
free(d);
return (check_neg(d, d->mod, 2, 0));
}
else
my_putstr(DIV_0);
return (0);
}
void Graph_Completer::run()
{
stopped_ = false;
//clock_t t0 = clock();
compute_convex_hull();
/*clock_t t1 = clock();
std::cout << "Convex hull points: (computed in " << (t1 - t0)*1.0/CLOCKS_PER_SEC << "s)" << std::endl;
unsigned int i;
for (i=0; i<convex_hull_.size(); i++)
{
std::cout << convex_hull_[i] + 1 << " ";
}
std::cout << std::endl;*/
//clock_t t2 = clock();
complete_triangulation();
/*clock_t t3 = clock();
std::cout << "Triangulated in " << (t3 - t2)*1.0/CLOCKS_PER_SEC << "s, ";*/
if (!stopped_)
{
add_zero();
sort_everything();
}
/*clock_t t4 = clock();
std::cout << "added zero in " << (t4 - t3)*1.0/CLOCKS_PER_SEC << "s" << std::endl;*/
return;
}
void add(char *_1,char *_2,char *r)
{
char one[10000],two[10000],res[10000];
strcpy(one,_1);
strcpy(two,_2);
if(strlen(one)<strlen(two))
swap(one,two);
int len=strlen(one);
if(len!=strlen(two))
add_zero((len-strlen(two)),two);
int i,result=0,carry=0;
for(i=0; i<len; i++)
{
result=one[i]-48+two[i]-48+carry;
res[i]=(result%10)+48;
carry=result/10;
}
if(carry)
res[i++]=carry+48;
res[i]='\0';
strcpy(r,res);
}
int main(void)
{
{
float zerof = 0.0f;
float minus_zerof = -0.0f;
assert(!bitwise_equalf(zerof, minus_zerof));
/* some constant folding */
assert(bitwise_equalf(minus_zerof + 20.f, 20.f));
assert(bitwise_equalf(minus_zerof + zerof, zerof));
assert(bitwise_equalf(zerof + minus_zerof, zerof));
assert(bitwise_equalf(zerof + zerof, zerof));
assert(bitwise_equalf(minus_zerof + minus_zerof, minus_zerof));
/* ensure optimisation did not mess up */
assert(!bitwise_equalf(add_zerof(minus_zerof), minus_zerof));
assert(bitwise_equalf(add_minus_zerof(minus_zerof), minus_zerof));
assert(bitwise_equalf(add_minus_zerof(zerof), zerof));
assert(bitwise_equalf(sub_zerof(minus_zerof), minus_zerof));
assert(bitwise_equalf(sub_minus_zerof(minus_zerof), zerof));
}
{
double zero = 0.0;
double minus_zero = -0.0;
assert(!bitwise_equal(zero, minus_zero));
/* some constant folding */
assert(!bitwise_equal(zero, minus_zero));
assert(bitwise_equal(minus_zero + 20., 20.));
assert(bitwise_equal(minus_zero + zero, zero));
assert(bitwise_equal(zero + minus_zero, zero));
assert(bitwise_equal(zero + zero, zero));
assert(bitwise_equal(minus_zero + minus_zero, minus_zero));
/* ensure optimisation did not mess up */
assert(!bitwise_equal(add_zero(minus_zero), minus_zero));
assert(bitwise_equal(add_minus_zero(minus_zero), minus_zero));
assert(bitwise_equal(add_minus_zero(zero), zero));
assert(bitwise_equal(sub_zero(minus_zero), minus_zero));
assert(bitwise_equal(sub_minus_zero(minus_zero), zero));
}
return 0;
}
///////////////////////////////////////////
//
// Public
//
///////////////////////////////////////////
char * const Bignum::to_s() {
int pos = 0, tmp = bignum_len - 1;
if (bignum[bignum_len - bignum_used_len()] < 0) {
cache[0] = '-';
pos += 1;
}
for (int i = 0; i < bignum_len; i++) {
if (bignum[i] != 0 || i == tmp) {
pos += int64_to_str(bignum[i], cache + pos);
for (int j = i + 1; j < bignum_len; j++) {
int64_to_str(bignum[j], cache + pos);
add_zero(cache + pos);
pos += LONG_LEN;
}
break;
}
}
return cache;
}
void finish_little_hexa(t_tmp_arg *tmp, t_params *params,
unsigned int s_to_add,
unsigned int s_to_print)
{
if (params->less == 1)
{
if (params->hash == 1 && tmp->uint != 0)
my_putstr("0x");
my_put_unsigned_nb(tmp->uint, s_to_print, "0123456789abcdef");
}
if (params->width >= params->precision && params->zero == 1
&& params->is_precision == 0 && params->less == 0
&& params->width > (int)s_to_print)
add_zero(s_to_add);
else if (params->width >= (params->precision) &&
params->width > (int)s_to_print)
add_space(s_to_add);
if (params->less == 0)
{
if (params->hash == 1 && tmp->uint != 0)
my_putstr("0x");
my_put_unsigned_nb(tmp->uint, s_to_print, "0123456789abcdef");
}
}
void Graph_Completer::complete_maximal_graph()
{
add_zero();
sort_everything();
return;
}
