void draw_time(struct tm *current) {
print_number(current->tm_hour / 10 % 10, 5, 16);
print_number(current->tm_hour % 10, 21, 16);
print_number(10, 35, 15);
print_number(current->tm_min / 10 % 10, 47, 16);
print_number(current->tm_min % 10, 63, 16);
}
int main()
{
number_t a, b, c;
int i;
a = string_to_number("-1.7171");
b = string_to_number("-17.17");
c = zero();
print_number(a);
printf("\n");
print_number(b);
printf("\n");
c = sub_number(a, b);
/*
for(i=-10; i<10; i++) {
c = make_exp(i);
print_number(c);
printf("\n");
}
*/
c = mult_num(a, b);
print_number(c);
printf("\n");
return 0;
}
static void run_benchmark(char *name, void (*benchmark)(void *),
void (*setup)(void *), void (*teardown)(void *),
void *data, int count, int iter) {
int i;
double min = HUGE_VAL;
double sum = 0.0;
double max = 0.0;
for (i = 0; i < count; i++) {
double begin, total;
if (setup != NULL) {
setup(data);
}
begin = gettimedouble();
benchmark(data);
total = gettimedouble() - begin;
if (teardown != NULL) {
teardown(data);
}
if (total < min) {
min = total;
}
if (total > max) {
max = total;
}
sum += total;
}
printf("%s: min ", name);
print_number(min * 1000000000.0 / iter);
printf("ns / avg ");
print_number((sum / count) * 1000000000.0 / iter);
printf("ns / max ");
print_number(max * 1000000000.0 / iter);
printf("ns\n");
}
int ft_printf_o2(unsigned long nb, t_flags f)
{
int len;
char *print;
int tmp_len;
len = 0;
tmp_len = 0;
print = ft_itoa_base(nb, 8);
if (f.hashtag == 1 && nb > 0 && f.precision < (int)ft_strlen(print))
tmp_len += 1;
if ((int)ft_strlen(print) < f.precision && f.precision >= 0)
tmp_len += f.precision;
else
tmp_len += ft_strlen(print);
if (tmp_len >= (int)f.len_field)
len += print_number(print, f, nb);
else if (f.minus == 1)
len = minus(len, print, f, nb);
else
{
while (len < (int)f.len_field - tmp_len)
len += ft_putchar(' ');
len += print_number(print, f, nb);
}
free(print);
return (len);
}
void print_combination_4(void) {
int n;
int n2;
/* run through & print the 2nd number for each digit b/w 0 and 99,
* excluding combinations already printed (using n2 = n+1). */
for (n = 0; n < 99; n++) {
for (n2 = n + 1; n2 < 100; n2++) {
if (n < 10) {
print_number(0); /* handle cases where n under 10 by manually printing 0 */
}
print_number(n);
print_char(' ');
if (n2 < 10) {
print_number(0); /* handle cases where n2 under 10 by manually printing 0 */
}
print_number(n2);
if (n + n2 != 197) {
print_char(',');
print_char(' ');
}
}
}
}
/* Render a value to text. */
static char *print_value(cJSON *item,int depth,int fmt,printbuffer *p)
{
char *out=0;
if (!item) return 0;
if (p)
{
switch ((item->type)&255)
{
case cJSON_NULL: {out=ensure(p,5); if (out) strcpy(out,"null"); break;}
case cJSON_False: {out=ensure(p,6); if (out) strcpy(out,"false"); break;}
case cJSON_True: {out=ensure(p,5); if (out) strcpy(out,"true"); break;}
case cJSON_Number: out=print_number(item,p);break;
case cJSON_String: out=print_string(item,p);break;
case cJSON_Array: out=print_array(item,depth,fmt,p);break;
case cJSON_Object: out=print_object(item,depth,fmt,p);break;
}
}
else
{
switch ((item->type)&255)
{
case cJSON_NULL: out=cJSON_strdup("null"); break;
case cJSON_False: out=cJSON_strdup("false");break;
case cJSON_True: out=cJSON_strdup("true"); break;
case cJSON_Number: out=print_number(item,0);break;
case cJSON_String: out=print_string(item,0);break;
case cJSON_Array: out=print_array(item,depth,fmt,0);break;
case cJSON_Object: out=print_object(item,depth,fmt,0);break;
}
}
return out;
}
int ft_printf_x(va_list ap, t_flags f)
{
t_len lenf;
unsigned long long nb;
char *print;
lenf.len = 0;
lenf.tmp_len = 0;
nb = unsigned_check(ap, f);
print = ft_itoa_base(nb, 16);
if (f.hashtag == 1)
lenf.tmp_len += 2;
if ((int)ft_strlen(print) < f.precision)
lenf.tmp_len += f.precision;
else
lenf.tmp_len += ft_strlen(print);
if (lenf.tmp_len >= (int)f.len_field)
lenf.len += print_number(print, f, nb, f.precision);
else if (f.minus == 1)
lenf.len = minus(f, lenf.len, nb, print);
else
{
while (lenf.len < (int)f.len_field - lenf.tmp_len && f.zero != 1)
lenf.len += ft_putchar(' ');
lenf.len += print_number(print, f, nb, (int)f.len_field - lenf.tmp_len);
}
return (free_ret(print, lenf.len));
}
/*prints - on one line - all possible combinations of two two-digit numbers*/
void print_combination_4(void)
{
int i, j, k, l, n1, n2;
for (i = 0; i <= 9; i++)
{
for (j = 0; j < 9; j++)
{
for(k = 0; k <= 9; k++)
{
for(l = 1; l <= 9; l++)
{
n1 = i*10 + j;
n2 = k*10 + l;
if(n2 > n1)
{
print_number(i);
print_number(j);
print_char(' ');
print_number(k);
print_number(l);
print_char(',');
print_char(' ');
}
}
}
}
}
}
static void print_free(unsigned long group, char * bitmap,
unsigned long num, unsigned long offset, int ratio)
{
int p = 0;
unsigned long i;
unsigned long j;
offset /= ratio;
offset += group * num;
for (i = 0; i < num; i++)
if (!in_use (bitmap, i))
{
if (p)
printf (", ");
print_number((i + offset) * ratio);
for (j = i; j < num && !in_use (bitmap, j); j++)
;
if (--j != i) {
fputc('-', stdout);
print_number((j + offset) * ratio);
i = j;
}
p = 1;
}
}
/*prints combination of all combinations of 2 two-digit numbers*/
void print_combination_4(void)
{
int n1, n2;
for (n1=0; n1<99; n1++)
{
for (n2=n1+1; n2<=99; n2++)
{
if (n1<10)
{
print_char('0');
}
print_number(n1);
print_char(' ');
if (n2<10)
{
print_char('0');
}
print_number(n2);
if (n1 < 98)
{
print_char(',');
print_char(' ');
}
}
}
}
void print_combination_1(void)
{
int i;
print_number(0); /*no comma before this*/
for (i=1;i<10;i++) /*from 1-9*/
{
print_char(',');
print_char(' ');
print_number(i);
}
}
int main() {
int a = 10;
int *b = NULL;
int *c = NULL;
b = &a;
print_number(b);
print_number(c);
return 0;
}
/* print an array */
void print_array(int *array, int n)
{
int i;
print_number(array[0]);
for (i = 1; i < n; i++) {
print_char(' ');
print_number(array[i]);
}
print_char('\n');
}
void print_combination_1(void){
int n;
for ( n=0; n<10; n++ ) { /* int n must print integers 0-9 */
if (n==9)
{print_number(n);
}
else {
print_number(n);
print_char(',');
print_char(' ');
}
}
}
int main(void)
{
print_number(98);
print_char('\n');
print_number(402);
print_char('\n');
print_number(1024);
print_char('\n');
print_number(0);
print_char('\n');
print_number(-98);
print_char('\n');
return (0);
}
void test_first_modulo() {
struct number n1 = {0, ((uint32_t)1 << 30), 0};
struct number n2 = {0, 0, ((uint32_t)1 << 32) - 1};
print_number(&n1);
std::cout << std::endl;
print_number(&n2);
std::cout << std::endl;
struct number *result = (struct number*)malloc(sizeof(struct number));
multp(&n1, &n2, result);
print_number(result);
std::cout << std::endl;
}
/* print each element of an array of integers */
void print_array(int *a, int n)
{
int i;
for (i = 0; i < n - 1; i++)
{
print_number(a[i]);
print_char(',');
print_char(' ');
}
print_number(a[n - 1]); /* print the last element */
print_char('\n');
}
void print_combination_1(void){
int n;
for (n = 0; n < 10; n++)
{
if ( n == 9)
{
print_number(n);
return ;
}
print_number(n);
print_char(',');
print_char(' ');
}
}
void cJSON_Print(cJSON *c){
switch(c->type){
case cJSON_Number: print_number(c);break;
case cJSON_String: print_string(c);break;
case cJSON_Object: print_object(c);break;
}
}
/* Render a value to text. */
static char *print_value(srjson_doc_t *doc, srjson_t *item, int depth, int fmt)
{
char *out = 0;
if (!item)
return 0;
switch ((item->type) & 255) {
case srjson_NULL:
out = srjson_strdup(doc, "null");
break;
case srjson_False:
out = srjson_strdup(doc, "false");
break;
case srjson_True:
out = srjson_strdup(doc, "true");
break;
case srjson_Number:
out = print_number(doc, item);
break;
case srjson_String:
out = print_string(doc, item);
break;
case srjson_Array:
out = print_array(doc, item, depth, fmt);
break;
case srjson_Object:
out = print_object(doc, item, depth, fmt);
break;
}
return out;
}
void print_sieves(int n){
char *notPrime= malloc(sizeof(char) * n - 1);
int i;
notPrime[0] = 1;
for(i = 1; i < n - 1; i++){
notPrime[i] = 0;
}
//START LOOKING
for(i = 1; i < n - 1; i++){
if(!notPrime[i]){
int number = i + 1;
int j = i + number;
while(j < n - 1){
notPrime[j] = 1;
j += number;
}
}
}
//FINISHED LOOKING
for(i = 0; i < n - 1; i++){
if(!notPrime[i])
print_number(i+1);
}
free(notPrime);
printf("\n");
}
void print_sieves(int n){
int i, j, k, s;
int primeList[n];
for (i = 2; i <= n; i++) {
primeList[i] = 1;
}
for (j = 2; j*j <= n ; j++) {
if (primeList[j]){
for (k = j*j ; k <= n ; k += j) {
primeList[k] = 0;
}
}
}
int y = 2;
int distCounter = 0;
// For loop for printing the values.
for (s = 2; s <= n; s++) {
if (primeList[s]){
int x = s;
if ((x - y) == 4)
distCounter += 1;
counter++;
print_number(s);
y = x;
}
}
printf("\n\n%s%d\n","The number of times the distance is 4 is: ", distCounter);
}
void print_string_struct(struct String *str){
print_string(str->str);
print_char(',');
print_char(' ');
print_number(str->length);
print_char('\n');
}
static int minus(int len, char *print, t_flags f, unsigned long nb)
{
len += print_number(print, f, nb);
while (len < (int)f.len_field)
len += ft_putchar(' ');
return (len);
}
int vfprintf(int fd, char * fmt, va_list ap)
{
char c;
char * ptr = fmt;
int in_fmt = 0;
int written = 0;
while ((c = *ptr++) != (char) 0) {
if (in_fmt && c == '%') {
written++;
in_fmt = 0;
fputc(fd, c);
} else if (in_fmt) {
written += print_number(fd, ap, c);
in_fmt = 0;
} else if (c == '%') {
in_fmt = c;
} else {
fputc(fd, c);
written++;
}
}
return written;
}
int d_func(va_list ap){
int data, i;
data = va_arg(ap, int);
i = print_number(data);
return i;
}
void print_vector(FILE *OUT, int digits, complex_vector z)
/***************************************************************\
* USAGE: prints z *
\***************************************************************/
{
int i, size = z->size;
if (size <= 0)
{ // nothing to print
fprintf(OUT, "[];\n");
}
else
{ // size > 0
for (i = 0; i < size; i++)
{
if (i == 0)
fprintf(OUT, "[");
fprintf(OUT, "[");
print_number(OUT, digits, z->coord[i]);
fprintf(OUT, "]");
if (i == size - 1)
fprintf(OUT, "];\n\n");
else
fprintf(OUT, ";\n");
}
}
return;
}
/* Render a value to text. */
static char *print_value(cJSON *item,int depth,int fmt)
{
char *out=0;
if (!item) return 0;
switch ((item->type)&255)
{
case cJSON_NULL:
out=cJSON_strdup("null");
break;
case cJSON_False:
out=cJSON_strdup("false");
break;
case cJSON_True:
out=cJSON_strdup("true");
break;
case cJSON_Number:
out=print_number(item);
break;
case cJSON_String:
out=print_string(item);
break;
case cJSON_Array:
out=print_array(item,depth,fmt);
break;
case cJSON_Object:
out=print_object(item,depth,fmt);
break;
}
return out;
}
void print_sieves(int n) {
int primes[n];
primes[0] = 0;
int i;
for (i = 1; i<n;i++) {
primes[i] = 1;
}
int step = 2;
int end = 7;
i = 2;
sieve:
while (i <= n) {
if (is_prime(i) == 0) primes[i-1] = 0;
i += step;
}
//go over primes 2,3,5,7 nicely
if (step == 2) {
i = 3;
step = 3;
goto sieve;
} else if (step != end) {
step += 2;
i = step;
goto sieve;
}
for (i = 0; i < n; i++) {
if (primes[i] == 1) print_number(i+1);
}
}
static char* print_value(cjson* item, int depth, int fmt)
{
char* out;
switch (item->type)
{
case JSON_NULL:
out = print_null();
break;
case JSON_TRUE:
out = print_true();
break;
case JSON_FALSE:
out = print_false();
break;
case JSON_STRING:
out = print_string(item->valuestring);
break;
case JSON_NUMBER:
out = print_number(item);
break;
case JSON_ARRAY:
out = print_array(item, depth, fmt);
break;
case JSON_OBJECT:
out = print_object(item, depth, fmt);
break;
}
return out;
}
