The problem is that a power of two can't be odd like in the second picture.
Have you some code?

I actually programmed it to use the "..." when the entire output is too large to fit.
The first picture (showing 2¹⁵⁵) is correct, while the second one, 2²¹⁰, is not. I noticed that it always outputs a number with a lot of 2809's and 2810's when it's not correct.

There is a part of my program that might be screwing up. One of the parameters my power function takes in is an array of ints that will be the output.
int numPow(int in1[], int in2[], int output[], int in1len, int in2len)For that parameter (called output[]), I pass it the pointer to an array, and the array has only one int in it.
int *ans = malloc(4); // One int
int ansLen = numPow(in1, in2, ans, numInts1, numInts2);The power function keeps calling my multiplication function, and resizes the array whenever it needs to. (Now that I think about it, this might not be so smart)

I'm thinking that if the array grows too large, and it has to move to a different address, my pointer (named ans) won't update to the new address, so it will point to the old one, which is now full of garbage.

Also, (Not really related) If you have:
int a;
int b = 2000000000; // Still within range
int c = 2000000000; // Still within range
a  = (b * c) % 10000000000; // Last 10 digits of the productDoes that work, or will it cause overflow? I am wondering because right now, I am storing numbers as arrays of ints with 4 digits in each int, which is quite inefficient.

Great job !
This will be very useful for arithmetics. You know when they ask you "what is the relainder when you divide 2⁹⁰⁰¹ by 193 ?" and you have to find a power n of 2 with 2ⁿ==1[193] because they think the calc is slow, with your engine, you just write the calculus and it is done

Also, (Not really related) If you have:

Code: [Select]

int a;
int b = 2000000000; // Still within range
int c = 2000000000; // Still within range
a  = (b * c) % 10000000000; // Last 10 digits of the productDoes that work, or will it cause overflow? I am wondering because right now, I am storing numbers as arrays of ints with 4 digits in each int, which is quite inefficient.

Yes, it will overflow, my compiler gives a warning.

Why do you only store 4 digits in one int, and not more?

That's pretty cool. I participate in math contests a lot, and this would be really helpful. I'll type up some stuff later.

I haven't had much time to work on my project, but Winter Break = time to code
My checklist of things to do:
1. Allow large numbers to be viewed easily
2. Program:
   a. Sum of digits
   b. Trailing zero counter
   c. Factorial
   d. nCr
   e. Division
3. Make a menu system

By the way, did anyone take the AMC 10/12? How did you do?

I made a custom radical sign character
It currently replaces the "1" character, so that's why the version number is so funny.

Meanwhile, I removed the memory usage indicator because it would be hard to program and useless, and I'm also working on porting GMP so I don't have to use my silly slow math algorithms. If that turns out successful, I will stop using my own math functions and just focus on programming a GUI.

Here's the source and stuff. I work with Ndless 1.7 because it is supported by Ncubate, which I use for debugging, so sorry if it's not compatible with what you use.