Exercise 3.1 )) imag=(m6.

imag/
return true; ((m5.real*m5.real)+
else (m5.imag*m5
class MyComplex return false; .imag)));
{ } return new
double real,imag; double magnitude() MyComplex(real,imag);
MyComplex(double real,double { }
imag) }
{ return class ComplexTest
this.real=real; Math.sqrt((real*real)+ {
this.imag=imag; (imag*imag)); public static void main(String[]
} } args)
double getReal() MyComplex add(MyComplex {
{ m2) MyComplex c1=new
return real; { MyComplex(20,40);
} real=real+m2.real; MyComplex c2=new
double getImag() imag=imag+m2.imag; MyComplex(30,60);
{ return new System.out.println("Is c1 & c2
return imag; MyComplex(real,imag); are
} equal="+c1.equals(c2));
} MyComplex MyComplex c4=c1.add(c2);
void setReal(double real) subtract(MyComplex m3) System.out.println(c4.real+"+
{ { ("+c4.imag+")
this.real=real; real=real-m3.real; i");
} imag=imag-m3.imag; MyComplex
void setImag(double imag) return new c5=c1.divideBy(c2);
{ MyComplex(real,imag); System.out.println(c5.real+"+
this.imag=imag; } ("+c5.imag+")
} MyComplex i");
void setValue(double real,double multiplyWith(MyComplex m4) }
imag) { }
{ real=(real*m4.real)-
this.real=real; (imag*m4.imag); Exercise 3.2
this.imag=imag; imag=(real*m4.imag)+
} (m4.real*imag);
public String toString() return new class Polynomial{
{ MyComplex(real,imag);
return "("+real+" + "+imag+" i)";} // coeffs[i] is the coefficient of
} MyComplex the term x^i
boolean equals(double divideBy(MyComplex m5) protected double[] coeffs;
real,double imag) {
{ if(m5.imag>=0) public Polynomial(double[]
if((this.real==real)&&(this.imag m5.imag=-1*m5.imag; coefficients){
==imag)) else coeffs = new
return true; m5.imag=-1*m5.imag; double[coefficients.length];
else MyComplex for(int i=0; i<coeffs.length; i+
return false; m6=multiplyWith(m5); +)
} real=(m6.real/((m5.real*m5.real) coeffs[i] = coefficients[i];
boolean equals(MyComplex m1) +(m5.imag*m5 }
{ .imag))); public int getDegree(){
if((this.real==m1.real)&&(this.i int d = coeffs.length-1;
mag==m1.imag while((coeffs[d] == 0) && (d
> 0)) Polynomial(coefficients); // write the first 3 lines
d--; } according to sequence definition
return d; } a.put(1, 1); fw.write("1
} 1\r\n"); fw2.write("1 2\r\n");
public boolean Exercise 3.3 a.put(2, 2); fw.write("2
equals(Polynomial p){ public class A166133 { 2\r\n"); fw2.write("2 3\r\n");
if(getDegree() != a.put(3, 4); fw.write("3
p.getDegree()) public static void 4\r\n"); fw2.write("3 3\r\n");
return false; main(String[] args) throws
for(int i=0; i<=getDegree(); i+ IOException { BigInteger value = new
+) // 23 minutes for 1 million BigInteger("4");
if(coeffs[i] != p.coeffs[i]) new Runner(100); // put
return false; here the number of terms you // generate the rest of the
return true; want sequence
} for (int i = 4; i <= loop ; i+
public double evaluate(double } +)
x) { {
double sum = 0; } BigInteger prev = new
double input = 1; BigInteger(value.toString());
for(int k=0; k<coeffs.length; BigInteger bi =
k++) { package a166133; value.multiply(value);
sum += coeffs[k]*input; import java.math.BigInteger; bi =
input *= x; import java.util.ArrayList; bi.subtract(BigInteger.ONE); //
} import java.io.*; bi now equal (previous ^ 2) -1
return sum;
} public class Runner { // find next value
public Polynomial Array a; value = newValue(i, bi);
add(Polynomial p){ //PrimeList pl;
int degree = getDegree(); public Runner(int loop) // if next value is
if(p.getDegree() > degree){ throws IOException "maximal", that is, (previous ^ 2)
degree = p.getDegree(); { -1
} int line = 1; // then write out to
double[] coefficients = new //pl = new PrimeList(); // A256406
double[degree]; ignore this failed performance if (value.compareTo(bi)
for(int i=0; i<getDegree(); i+ improvment == 0)
+) fw4.write(line++ + " "
coefficients[i] += coeffs[i]; // open files + prev + "\r\n");
for(int i=0; i<p.getDegree(); FileWriter fw = new
i++) FileWriter("out.txt"); // A166133 // put the value in the
coefficients[i] += p.coeffs[i]; FileWriter fw2 = new array
return new FileWriter("min.txt"); // a.put(i, value);
Polynomial(coefficients); A256405
} FileWriter fw3 = new // now and then, write to
public Polynomial derivative(){ FileWriter("pos.txt"); // A256409 the console
double[] coefficients = new FileWriter fw4 = new if (i % 1000 == 0)
double[getDegree()]; FileWriter("hit.txt"); // A256406 System.out.println(i + " " + value
for(int i=0; i<getDegree(); i+ + " " + a.min);
+){ // Class Array is where we
coefficients[i] = know if a number is already in // write to A166133
(i+1)*coefficients[i+1]; A166133 fw.write(i + " " + value +
} a = new Array(fw3); "\r\n");
return new
 // write to A256405 BigInteger bsize; }
fw2.write(i + " " + a.min Hashtable h; public void put(int n, int v)
+ "\r\n"); public BigInteger min; // this throws IOException
is the minimum number not yet {
// did sequence die? in the sequence put(n, new BigInteger("" +
(probably not) int line; v));
if FileWriter fw; }
(value.compareTo(BigInteger.ZE public Array(FileWriter fw) // test if a number is already in
RO) == 0) { the sequence
break; this.fw = fw; public boolean test(BigInteger
} array = new boolean[size]; v)
fw.close(); bsize = new BigInteger("" + {
fw2.close(); size); boolean ret;
fw3.close(); h = new Hashtable(); if (v.compareTo(bsize) >=
fw4.close(); min = new BigInteger("1"); 0)
} } {
// 1, 2, 4, 3, 8, 7, 6, 5, 12, 11, ret = (h.get(v.toString()) !
10, 9, 16, 15, 14, 13, 21, 20, 19, { = null);
18, 17, 24, 23, 22, 69, 28, 27 // if it's a big number, use }
the hash else
// generate new value if (v.compareTo(bsize) >= {
private BigInteger 0) int i =
newValue(int n, BigInteger v) { Integer.parseInt(v.toString());
{ h.put(v.toString(), v); ret = array[i] ;
// get sorted list of all } }
factors, excluding 1, and else // otherwise the //System.out.println("test "
including the number itself boolean array + v + " " + ret);
ArrayList list = new { return ret;
FactorList(/* pl */).get(n, v); int i = }
Integer.parseInt(v.toString()); }
// find lowest factor not yet array[i] = true;
in array } public class FactorList {
for (int i = 0; i < list.size() ; //PrimeList pl;
i++) // if finally the minimum public FactorList(/*PrimeList
{ value has been inserted into the pl*/)
sequence, {
BigInteger bi = // calculate the new /*this.pl = pl;*/
(BigInteger)(list.get(i)); sequence, and write A256405 }
if (a.test(bi)) if (v.compareTo(min) == 0) public ArrayList get(int n,
continue; { BigInteger v)
line++; {
return bi; fw.write(line + " " + n + ArrayList list = new
"\r\n"); ArrayList();
} while (true)
{ // get the prime factors
return BigInteger.ZERO; min = ArrayList pf = new
} min.add(BigInteger.ONE); PrimeFactorList(/*pl*/).get(v);
} if (test(min) == false)
public class Array { break; // generate all factors
boolean array[]; } for (int i = 0 ; i < pf.size() ;
int size = 500000000; // below } i++)
this, use boolean array {
 int actual = list.size(); BigInteger start = new
BigInteger bi = BigInteger("1"); //System.out.println("minPF " +
(BigInteger)(pf.get(i)); while (true) v + " = " + min);
if (!isin(list, bi)) { list.add(min);
list.add(bi); BigInteger curr = null; v = v.divide(min);
for (int j = 0 ; j < actual ; for (int i = 0 ; i <
j++) list.size() ; i++) if
{ { (v.compareTo(BigInteger.ONE)
BigInteger p = BigInteger bi = == 0)
(BigInteger)(list.get(j)); (BigInteger)(list.get(i)); break;
try if (bi.compareTo(start) }
{ > 0) /*
BigInteger m = { String s = "PFList of " +
p.multiply(bi); if (curr == null) target + " is ";
if (!isin(list, m)) curr = bi; for (int i = 0 ; i < list.size() ;
list.add(m); else i++)
} if s += (BigInteger)
catch (Exception e) (bi.compareTo(curr) < 0) (list.get(i)) + " ";
{ curr = bi; System.out.println(s);
System.err.println("v= " + v); } */
System.err.println("p= " + p); } return list;
System.err.println("bi= " + bi); if (curr == null) }
throw e; break // find minimum prime factor
} start = curr; of input
} out.add(curr); public BigInteger
} } minPF(BigInteger target)
return out; {
// and sort them } BigInteger delta = new
list = sort(list); } BigInteger("1");
package a166133; int n = 0;
return list; import java.math.BigInteger; /* this performance
} import java.util.ArrayList; improvement didn't
// if factor already in list public class PrimeFactorList for (Prime p = pl.getFirst();
boolean isin(ArrayList list, {
BigInteger bi) //PrimeList pl; (p.getValue().multiply(p.getValu
{ public PrimeFactorList(/* e())).compareTo(target) <= 0;
for (int i = 0 ; i < list.size() ; PrimeList pl */) { /*this.pl = pl; p = pl.getNext(p) )
i++) */ } */
{ public ArrayList for (BigInteger bi = new
BigInteger p = get(BigInteger target) BigInteger("2");
(BigInteger)(list.get(i)); {
if (p.compareTo(bi) == 0) //System.out.println("PFList (bi.multiply(bi)).compareTo(targ
return true; " + target); et) <= 0;
} ArrayList list = new bi = bi.add(delta) )
return false; ArrayList(); {
} BigInteger v = new //BigInteger bi =
BigInteger(target.toString()); p.getValue();
// rather inefficient sort if
ArrayList sort(ArrayList list) while (true) (target.mod(bi).compareTo(BigI
{ { nteger.ZERO) == 0)
ArrayList out = new BigInteger min = {
ArrayList(); minPF(v); return bi;
 }
n++;
if (n == 2)
delta = new
BigInteger("2");
}
//System.out.println("PFList
" + target);
return target;
}
}