// Example programs for Sinclair Cambridge Programmable model
//  nib - 2006-04-01 .. 2006-04-09

// Copyright Nigel Bromley 2006. Free use for any non-commercial purpose
//  with attribution. Except where attributes otherwise.

// Preload a useful program to calculate factorials. This is ripped-off from
//  Viktor T. Toth at http://www.rskey.org/detail.asp?manufacturer=
//  Sinclair&model=Cambridge+Programmable. It does some fairly tricky things
//  with brackets. This is the only "difficult" code I have tested with yet.

// Factorial program of mine - using less trickery.

function load_eg0()
{
	program[0] = '2';	// sto
	program[1] = 'F';	// -
	program[2] = '3';	// #
	program[3] = '3';	// 3
	program[4] = '-';	// =
	program[5] = 'A';	// downshift
	program[6] = '1';	// go if neg
	program[7] = '2';	// 2
	program[8] = '2';	// 2
	program[9] = 'E';	// +
	program[10] = '3';	// #
	program[11] = '2';	// 2
	program[12] = '.';	// *
	program[13] = 'A';	// downshift
	program[14] = '5';	// MEx
	program[15] = '-';	// *
	program[16] = 'A';	// downshift
	program[17] = '5';	// MEx
	program[18] = 'A';	// downshift
	program[19] = '2';	// goto
	program[20] = '0';	// 0
	program[21] = '1';	// 1
	program[22] = '5';	// rcl
	program[23] = '0';	// stop
	program[24] = 'A';	// downshift
	program[25] = '2';	// goto
	program[26] = '0';	// 0
	program[27] = '0';	// 0
	program[28] = '0';	// stop
	program[29] = '0';	// stop
	program[30] = '0';	// stop
	program[31] = '0';	// stop
	program[32] = '0';	// stop
	program[33] = '0';	// stop
	program[34] = '0';	// stop
	program[35] = '0';	// stop
}

function load_eg1()
{
	program[0] = '5';	// rcl
	program[1] = 'E';	// +
	program[2] = '3';	// #
	program[3] = '1';	// 1
	program[4] = '-';	// =
	program[5] = '2';	// sto
	program[6] = '0';	// stop
	program[7] = 'A';	// downshift
	program[8] = '2';	// goto
	program[9] = '0';	// 0
	program[10] = '0';	// 0
	program[11] = '0';	// stop
	program[12] = '0';	// stop
	program[13] = '0';	// stop
	program[14] = '0';	// stop
	program[15] = '0';	// stop
	program[16] = '0';	// stop
	program[17] = '0';	// stop
	program[18] = '0';	// stop
	program[19] = '0';	// stop
	program[20] = '0';	// stop
	program[21] = '0';	// stop
	program[22] = '0';	// stop
	program[23] = '0';	// stop
	program[24] = '0';	// stop
	program[25] = '0';	// stop
	program[26] = '0';	// stop
	program[27] = '0';	// stop
	program[28] = '0';	// stop
	program[29] = '0';	// stop
	program[30] = '0';	// stop
	program[31] = '0';	// stop
	program[32] = '0';	// stop
	program[33] = '0';	// stop
	program[34] = '0';	// stop
	program[35] = '0';	// stop
}

// Another program ripped-off from Viktor T. Toth at
//  http://www.rskey.org/detail.asp?manufacturer=
//  Sinclair&model=Cambridge+Programmable.
// "Or we can sacrifice accuracy (not that it matters much, in comparison
//  with the lack of accuracy of built-in scientific functions) and have
//  an implementation of Stirling's formula, yielding the natural logarithm
//  of the extended factorial for any positive real arguments greater than
//  one, with a precision of at least three significant digits."
// Stirling gives n! ~= sqrt(2.pi.n).(n/e)^n
// Below gives ln(n!) ~= (n+0.5).ln(n) - n + 0.91894 + ln(1+ 1/12n)
//  which apart from the last term is ln both sides of the above.
function load_eg98()
{
	program[0] = '2';	// sto
	program[1] = 'E';	// +
	program[2] = '3';	// #
	program[3] = 'A';	// .
	program[4] = '5';	// 5
	program[5] = '.';	// *
	program[6] = '6';	// (
	program[7] = '5';	// rcl
	program[8] = '4';	// ln
	program[9] = '6';	// )
	program[10] = 'F';	// -
	program[11] = '5';	// rcl
	program[12] = 'E';	// +
	program[13] = '3';	// #
	program[14] = 'A';	// .
	program[15] = '9';	// 9
	program[16] = '1';	// 1
	program[17] = '8';	// 8
	program[18] = '9';	// 9
	program[19] = '4';	// 4
	program[20] = 'E';	// +
	program[21] = '6';	// (
	program[22] = '3';	// #
	program[23] = '1';	// 1
	program[24] = '2';	// 2
	program[25] = 'G';	// /
	program[26] = 'G';	// /
	program[27] = '5';	// rcl
	program[28] = 'E';	// +
	program[29] = '3';	// #
	program[30] = '1';	// 1
	program[31] = '-';	// =
	program[32] = '4';	// ln
	program[33] = '6';	// )
	program[34] = '-';	// =
	program[35] = '0';	// stop
}

// A useful program to calculate factorials. This is ripped-off from
//  Viktor T. Toth at http://www.rskey.org/detail.asp?manufacturer=
//  Sinclair&model=Cambridge+Programmable. It does some fairly tricky things
//  with brackets. This is the only "difficult" code I have tested with yet.
function load_eg99()
{
	program[0] = '2';	// sto
	program[1] = 'F';	// -
	program[2] = '3';	// #
	program[3] = '2';	// 2
	program[4] = 'E';	// +
	program[5] = 'A';	// downshift
	program[6] = '1';	// go if neg
	program[7] = '2';	// 2
	program[8] = '2';	// 2
	program[9] = '3';	// #
	program[10] = '1';	// 1
	program[11] = '.';	// *
	program[12] = '6';	// (
	program[13] = '.';	// *
	program[14] = '5';	// rcl
	program[15] = 'G';	// /
	program[16] = '2';	// sto
	program[17] = '6';	// )
	program[18] = 'A';	// downshift
	program[19] = '2';	// goto
	program[20] = '0';	// 0
	program[21] = '1';	// 1
	program[22] = '-';	// =
	program[23] = '5';	// rcl
	program[24] = '0';	// stop
	program[25] = 'A';	// downshift
	program[26] = '2';	// goto
	program[27] = '0';	// 0
	program[28] = '0';	// 0
	program[29] = '0';	// stop
	program[30] = '0';	// stop
	program[31] = '0';	// stop
	program[32] = '0';	// stop
	program[33] = '0';	// stop
	program[34] = '0';	// stop
	program[35] = '0';	// stop
}