Android app recommendations

[Uncwilly]

Got myself an android tablet. Looking to find some good apps. Especially a nice calculator app. What are your faves?

[frmky]

RealCalc. Supports RPN.

[Mini-Geek]

250+ Solitaire Collection and Sudoku Free are good simple puzzlers, if you like that sort of thing.

[LaurV]

iBeer!

the best android app, no questions...

(what is not shown in the advertizing is the best part, when the guy is burping, and when you drop the phone on the table and break the mug, some friend was really scared that he broke the touchscreen, haha)

[Daria91]

I prefer Google Calculator but here are some other great options:[MOD: Spam link removed from first-time poster- anyone can search calculator apps themselves].
Google Maps, Google wallpaper, Sygic, Reddit are also must-have on my device

[ewmayer]

As is well-known hereabouts, the only smartphones I have ever owned are some cracked-screen Android ones I installed a Linux-environment freeware app on in order to run my Mlucas code. Said Linux distro of course includes Linux bc, which one can use as a text-based calculator app ... pretty basic, decimal-math based so noticeably slow once operands get beyond a few hundred digits in length ... but allows one to write one's own code to add functionality as needed and do cool stuff. For example, below is a sample of code I simply paste into an integer-mode bc run (floating-point-emulation mode needs 'bc -l' and possibly fiddling of the 'scale' setting) to give me some useful basic number-theory functionality. Never used an Android tablet, though, and anyway, as you can see I'm either a weirdo or a Luddite when it comes to app-tech. :)

define abs(n) {
	if(n < 0) return(-n);
	return(n);
}

define trailz(n) {
	auto ssave, i;
	i = 0;
	while(n && !(n%2)) { i += 1; n /= 2; }	/* Bizarre: (n%2 == 0) didn't work here */
	return(i);
}

define bits(n) {
	auto ssave, r;
	ssave = scale;	scale = 0;	/* In case we're in floating-point mode */
	r = length(n)*3321928095/1000000000;
	while ( 2^r > n ) { r -= 1; }
	scale = ssave;
	return(r+1);
}

define reverse(n,nbits) {
	auto ssave, tmp;
	ssave = scale;	scale = 0;	/* In case we're in floating-point mode */
	tmp = 0;
	while(nbits) {
		tmp = 2*tmp + (n % 2);
		n /= 2;
		nbits -= 1;
	}
	scale = ssave;
	return(tmp);
}

/* If the input == 2^p, return lg(n), otherwise return -1.
Note: We do not consider 0 as being a power of 2, since there is no number x such that 2^x = 0.
No special casing is needed for 0, since bits(0) = trailz(0) = 0. */
define ispow2(n) {
	auto bt, tz;
	bt = bits(n);
	tz = trailz(n);
	if(bt == tz+1) return(tz);
	return(-1);
}

/* left-to-right binary modpow, a^b (mod n); note that special 'fast' version which assumes
user knows what he is doing and eschews input corner-case checking was not faster for me in
practice: */
define modpow_lr(a,b,n) {
	auto ssave, y,len;
	ssave = scale;	scale = 0;	/* In case we're in floating-point mode */
	/* For n = 0, trigger a div-by-0 error; for n = +-1 return 0: */
	if(abs(n) < 2) {
		scale = ssave;
		return 2%n;
	}
	/* For b = 0, return 1; for b < 0, return 0: */
	if(b <= 0) {
		scale = ssave;
		return(b==0);
	}
	/* For a = 0, return 0; for a = +-1 return a^(b%2): */
	if(abs(a) < 2) {
		scale = ssave;
		return (a!=0) * a^(b%2);
	}
	len = bits(b);	b = reverse(b,len);
/*print "modpow_lr: n = ",n,", #bits = ",len,", reverse = ",b,"\n";*/
	y = a%n;	b /= 2;
	while(--len) {
		y = (y*y)%n;
		if(b%2) y = (a*y)%n;
/*print "len = ",len,", bit = ",b%2,": y = ",y,"\n";*/
		b /= 2;
	}
	scale = ssave;
	return(y);
}

/* right-to-left-to-right binary modpow, a^b (mod n): */
define modpow_rl(a,b,n) {
	auto ssave, y,z;
	ssave = scale;	scale = 0;	/* In case we're in floating-point mode */
	/* For n = 0, trigger a div-by-0 error; for n = +-1 return 0: */
	if(abs(n) < 2) {
		scale = ssave;
		return 2%n;
	}
	/* For b = 0, return 1; for b < 0, return 0: */
	if(b <= 0) {
		scale = ssave;
		return(b==0);
	}
	/* For a = 0, return 0; for a = +-1 return a^(b%2): */
	if(abs(a) < 2) {
		scale = ssave;
		return (a!=0) * a^(b%2);
	}
	y = 1;	z = a%n;
	while(b) {
		if(b%2) y = (y*z)%n;
		z = (z*z)%n;
		b /= 2;
	}
	scale = ssave;
	return(y);
}

/* base-2 specialized version of modpow_lr, computes 2^b (mod n): */
define modpow_lr2(b,n) {
	auto ssave, i,y,len;
	ssave = scale;	scale = 0;	/* In case we're in floating-point mode */
	len = bits(b); i = len;
	while(--i) {
		bmap[i] = (b%2);	b /= 2;
	}
	y = 2; i = 1;
	/* No need to mod until y >= n: */
	while(i < len) {
		y = (y*y);
		if(bmap[i++]) {
			y += y;
		}
		if(y >= n) break;
	}
	y = y%n;
	while(i < len) {
		y = (y*y)%n;
		if(bmap[i++]) {
			y += y;	if(y >= n) y -= n;
		}
	}
	scale = ssave;
	return(y);
}
/* Single-modpow timing test:
p = 3217; n = 2^p-1;
modpow_lr2(n-1,n)
*/

/* returns 1 if p is a base-z Fermat pseudoprime, 0 otherwise. */
define pprimef(p,base) {
	y = modpow_lr(base,p-1,p);
	return(y==1);
}

define isprp(p) {
	auto ssave;
	ssave = scale;	scale = 0;	/* In case we're in floating-point mode */
	if(p == 2) {
		scale = ssave;
		return(1);
	}
	if(!(p%2)) {
		scale = ssave;
		return(0);
	}
	/* Must only use inputs > the largest pprimef-base used below ... better, use that 341 is the smallest base-2 Fermat-pseudoprime: */
	if(p < 341) {
		scale = ssave;
		return(pprimef(p,2));
	}
	scale = ssave;
	return(pprimef(p,2) && pprimef(p,3) && pprimef(p,5) && pprimef(p,7) && pprimef(p,11) && pprimef(p,13));
}

define find_next_prp(n,up_or_down) {
	auto i,j,d;
	/* direction properly specified? */
	if(abs(up_or_down) != 1) {
		print "Direction of search not properly specified, must = +1 (up) or -1 (down).\n";
		return(0);
	}
	d = 2*up_or_down;
	/* n must be odd: */
	if(!(n%2)) {
		n -= up_or_down;
		print "Made n odd, starting search with: ",n,"...\n";
	}
	i = 0; j = 0;
	while(1) {
		n += d;	i += 1;
		if(pprimef(n,2)) {
			j += 1;
			if(isprp(n)) {
				print "[",i," odds tried, ",j," of which were 2-PRPs] Found next PRP: ",n,"\n";
				return(n);
			}
		}
	}
}

define gcd(x,y) {
	auto ssave, q, f;
	ssave = scale;	scale = 0;	/* In case we're in floating-point mode */
	if(!y) {
		scale = ssave;
		return(x);
	}
	while(y) {
		q = x/y;	/* Find quotient of current x/y and round toward zero: */
		f = x - q*y;/* Find y' and store in temporary: */
		x = y;		/* Find x', i.e. move the old value of y into the slots for x: */
		y = f;		/* New value of y: */
	}
	scale = ssave;
	return(x);
}

[M344587487]

F Droid is a must, it's a repo for FOSS apps ( https://en.wikipedia.org/wiki/F-Droid ). Shattered Pixel Dungeon is a roguelike that works well with a touch screen. There are various ssh and terminal emulators to interact with your tablet in a Linuxy way.

[Mark Rose]

Wolfram Alpha can be handy.

If you're looking for a fun and simple game, check out Flow Free.

[kruoli]

Originally Posted by Mark Rose

Wolfram Alpha can be handy.

That would be a "Wortwitz" in German. "Handy" means "mobile phone".

It is really nice that this paid version has a lot of the features you would only get for some monthly subscription on the website, so I use it rather often. Also, the extended keyboard with a lot of mathematical symbols is handy on a "Handy".

[pinhodecarlos]

Hope I can use this thread to ask for a good iPhone spam call blocker.

[R2357]

Primes, Primes between Numbers and Big Integer Calculater