/* 31 * p = 100 * q + 1 step 1: { calculate modulus thing } 100 = 3 * 31 + 7 a 31 = 4 * 7 + 3 b 7 = 2 * 3 + 1 c 3 = 3 * 1 + 0 d step 2: { rewrite (blended in with step 3) } a => 7 = 100 - ( 3 * 31 ) b => 3 = 31 - ( 4 * 7 ) c => 1 = 7 - ( 2 * 3 ) step 3: { e => sub b in c } 1 = 7 - ( 2 * b ) 1 = 7 - ( 2 * ( 31 - ( 4 * 7 ) ) ) 1 = ( 1 * 7 ) - ( 2 * 31 ) + ( ( 2 * 4 ) * 7 ) 1 = ( 1 * 7 ) - ( 2 * 31 ) + ( 8 * 7 ) 1 = ( 9 * 7 ) - ( 2 * 31 ) step 4: { f => sub a in e } 1 = ( 9 * a ) - ( 2 * 31 ) 1 = ( 9 * ( 100 - ( 3 * 31 ) ) ) - ( 2 * 31 ) 1 = ( 9 * 100 ) - ( 9 * ( 3 * 31 ) ) - ( 2 * 31 ) 1 = ( 9 * 100 ) - ( 27 * 31 ) - ( 2 * 31 ) 1 = ( 9 * 100 ) - ( 29 * 31 ) step 5: { magical rewrite f (too complicated) } 1 = ( 9 * 100 ) - ( 29 * 31 ) 1 = ( 9 * 100 ) - ( ( 100 - 71 ) * 31 ) 1 = ( 9 * x ) - ( ( x - 71 ) * 31 ) 1 = ( 9 * x ) - ( 31 * x ) + ( 71 * 31 ) 1 = ( ( 9 - 31 ) * x ) + ( 71 * 31 ) 1 = ( -22 * x ) + ( 71 * 31 ) 1 = ( -22 * 100 ) + ( 71 * 31 ) ( ( 22 * 100 ) + 1 ) = ( 71 * 31 ) 31 * 71 = 100 * 22 + 1 p = 71 (multiplicative inverse of the relative prime 31 to 100) q = 22 (idk what it's called) well then... lets get started x.x */ //step 1 //btw the 1 at the end is normal //I used 31 * q = 100 * p + 1 as an example alert("this will only work if you enter two numbers with a largest common divisor (lcd) of 1... and if step 1 takes four steps, otherwise it will stop automaticly"); var mirp = 31; var to = 100; var step1_Data = []; var step2_Data = ""; var step3_Data = ""; var step4_Data = []; var abcd = ["a","b","c","d"]; document.write(`${mirp} * ? = ${to} * ? + 1

`); //step 1 : {modulus thing} function Step1() { if( (to % mirp === 0) || (to % 2 === 0 && mirp % 2 === 0) ) console.log("Sorry, this pair of numbers won't have an outcome, because their lcd is not equal to 1"); else{ document.write("Step 1 : {modulus}
"); let cd = mirp; let max = to; for(let i in abcd) { if(i < 3 && max % cd == 0) break; let stp = -1; for(let j = max; j >= 0; j -= cd) { //alert(i + "\n" + j); stp++; } document.write(`${abcd[i]} : ${max} = ${stp} * ${cd} + ${max%cd}
`); step1_Data.push([abcd[i],max,stp,cd,max%cd]); let temp = max; max = cd; cd = temp % cd; stp = -1; } document.write("
Step 2 : {sub b in c}
"); try{ if(step1_Data[3][4]===0) Step2(); } catch(e) { console.log("Sorry, this pair of numbers won't have an outcome."); } } } //step 2 : {rewrite + sub b in c} function Step2() { let s1 = step1_Data; let one = 1; document.write ( `${s1[2][4]} = ${s1[2][1]} - ( ${s1[2][2]} * ( ${mirp} - ( ${s1[1][2]} * ${s1[1][3]} ) ) )
` ); document.write ( `${s1[2][4]} = ( ${one} * ${s1[2][1]} ) - ( ${s1[2][2]} * ${mirp} ) + ( ${s1[2][2]} * ( ${s1[1][2]} * ${s1[1][3]} ) )
` ); document.write ( `${s1[2][4]} = ( ${one} * ${s1[2][1]} ) - ( ${s1[2][2]} * ${mirp} ) + ( ${s1[2][2]*s1[1][2]} * ${s1[1][3]} )
` ); document.write ( `e : ${s1[2][4]} = ( ${one+s1[2][2]*s1[1][2]} * ${s1[1][3]} ) - ( ${s1[2][2]} * ${mirp} )
` ); document.write("
Step 3 : {sub a in e}
"); step2_Data = one + s1[2][2] * s1[1][2]; Step3(); } // step 3 : {sub a in e} function Step3() { let s1 = step1_Data; let one = 1; let sh = step2_Data; document.write ( `a => ${s1[0][4]} = ${to} - ( ${s1[0][2]} * ${mirp} )
` ); document.write ( `e => ${s1[2][4]} = ( ${sh} * ${s1[1][3]} ) - ( ${s1[2][2]} * ${mirp} )

` ); document.write ( `${s1[2][4]} = ( ${sh} * ( ${to} - ( ${s1[0][2]} * ${mirp} ) ) ) - ( ${s1[2][2]} * ${mirp} )
` ); document.write ( `${s1[2][4]} = ( ${sh} * ${to} ) - ( ${sh} * ( ${s1[0][2]} * ${mirp} ) ) - ( ${s1[2][2]} * ${mirp} )
` ); document.write ( `${s1[2][4]} = ( ${sh} * ${to} ) - ( ${sh*s1[0][2]} * ${s1[0][3]} ) - ( ${s1[2][2]} * ${mirp} )
` ); document.write ( `f : ${s1[2][4]} = ( ${sh} * ${to} ) - ( ${sh*s1[0][2]+s1[2][2]} * ${s1[0][3]} )

` ); step3_Data = sh*s1[0][2]+s1[2][2]; document.write("Step 4 : {rewrite f}
"); Step4(); } //step 4 : {rewrite f} function Step4() { let s1 = step1_Data; let s2 = step2_Data; let s3 = step3_Data; document.write ( `${s1[2][4]} = ( ${s2} * ${to} ) - ( ${s3} * ${mirp} )
` ); document.write ( `${s1[2][4]} = ( ${s2} * ${to} ) - ( ( ${to} - ${to-s3} ) * ${mirp} )
` ); document.write ( `${s1[2][4]} = ( ${s2} * y ) - ( ( y - ${to-s3} ) * ${mirp} )
` ); document.write ( `${s1[2][4]} = ( ${s2} * y ) - ( ${mirp} * y ) + ( ${mirp} * ${to-s3} )
` ); document.write ( `${s1[2][4]} = ( ${s2-mirp} * y ) + ( ${mirp} * ${to-s3} )
` ); document.write ( `${s1[2][4]} = ( ${s2-mirp} * ${to} ) + ( ${mirp} * ${to-s3} )
` ); document.write ( `( ( ${-(s2-mirp)} * ${to} ) + ${s1[2][4]} ) = ( ${mirp} * ${to-s3} )

` ); document.write ( `${mirp} * ${to-s3} = ${to} * ${-(s2-mirp)} + ${s1[2][4]}` ); } Step1();

Euclide's Algorithm (beta)