sac

type Director struct {
	// contains filtered or unexported fields
}

type FactorBase interface {

	// Prepare factor base.<p>
	// @param m BigInteger - number to be factorized
	// @return boolean - successful operation?
	Init(m *math.Int) bool

	// Get number of primes in the factor base.<P>
	// @return int - number of primes in factor base
	GetNumPrimes() int

	// Get the i.th primes in the factor base.<p>
	// @param i int - prime index
	// @return BigInteger - prime value
	GetPrime(i int) *math.Int

	// Solve the equation x^2 = m (mod p)
	// @param i int - prime index in factor base
	// @return BigInteger - solution (x)
	GetSqrt(i int) *math.Int

	// Get index of first (smallest) prime from factor base that
	// is a factor of f.<p>
	// @param f BigInteger - number (unsquare part of y)
	// @param pos int - last index (smaller than new index)
	// @return int - index of first occurring prime
	FirstPrimeIndex(f *math.Int, pos int) int

	// Extract a sub factor base.<p>
	// @param id int - identifier of sub factor base
	// @param start int - offset into full factor base
	// @param size int - number of successive primes
	// @return FactorBase - extracted sub factor base
	GetSubBase(id, start, size int) FactorBase

	// Check if number has a prime factor in factor base.<p>
	// @param a BigInteger - number to be tested
	// @return boolean - number has factor in factor base
	Covers(a *math.Int) bool

	// Get identifier of factor base.<p>
	// @return int - identifier
	GetId() int
}

type FactorBaseImpl struct {
	Instance

	FbMult *math.Int // multiplicative = Prod(i=1,B) p(i)
	// contains filtered or unexported fields
}

type Function struct {
	// contains filtered or unexported fields
}

type Instance interface {

	// Set instance identification (id and name).<p>
	// @param id int - identifier
	// @param name String - instance name
	Ident(id int, name string)

	// Return instance identifier.<p>
	// @return int - instance identifier
	GetId() int

	// Check if instance is active.<p>
	// @return boolean - instance active?
	IsActive() bool

	// Terminate instance.<p>
	Terminate()

	Run()
}

type InstanceImpl struct {
	// contains filtered or unexported fields
}

type Queue struct {
	// contains filtered or unexported fields
}

type Relation interface {

	// Initialize new relation for (x,y)<p>
	// @param x BigInteger - argument to square function
	// @param y BigInteger - fb-smooth function result
	Init(x, y *math.Int)

	// Normalize relation over factor base (reduce yh)<p>
	// @param fb FactorBase - factor base for reduction
	// @param m BigInteger - modulus
	Normalize(fb FactorBase, m *math.Int)

	// Multiply this relation with r:  this = this * r<p>
	// @param r Relation - multiplicator from list
	// @param fb FactorBase - factor base for reduction
	// @param m BigInteger - modulus
	Multiply(r Relation, fb FactorBase, m *math.Int)

	// Get smallest prime factor of f.<p>
	// @param fb FactorBase - list of primes
	// @return int - index of first prime
	FirstPrimeIndex(fb FactorBase, pos int) int

	// Returns (x-s) if relation is square (x^2 = s^2 mod m).<p>
	// @return BigInteger - (x-s) if square or null otherwise
	IsSquared() *math.Int

	// Check if h has factors in factor base fb.<p>
	// @param fb FactorBase - factor base to be used
	// @return boolean - h has factors in fb
	IsReducable(fb FactorBase) bool

	// Check if relation is completely reduced.<p>
	// @return boolean - relation reduced?
	IsReduced() bool

	// Check if f has factors in factor base fb.<p>
	// @param fb FactorBase - factor base to be used
	// @return boolean - f has factors in fb
	IsCovered(fb FactorBase) bool

	// Generate printable representation of relation.<p<
	// @return String - printable (and readable) relation
	String() string
}

type RelationImpl struct {
	// contains filtered or unexported fields
}

type Siever interface {
	Instance

	// Initialize solver instance.<p>
	// @param id int - siever identifier
	// @param m BigInteger - number to be factorized
	// @param fb FactorBase - factor base to be used
	// @param cb SieverCallback - callback for siever rersponses
	// @return boolean - successful operation?
	Init(id int, m *math.Int, fb FactorBase, cb SieverCallback) bool

	// Set siever interval for siever instance.<p>
	// @param x0 BigInteger - start of interval
	// @param x1 BigInteger - end of interval (inclusive)
	SetSieveInterval(x0, x1 *math.Int)
}

type SieverCallback func(id int, x, y *math.Int) bool

type SieverImpl struct {
	InstanceImpl
	// contains filtered or unexported fields
}

type Solver interface {
	Instance

	// Put relation into input queue for solver.<p>
	// This method is called by another thread (Director).<p>
	// @param r Relation - new relation for solver
	// @return boolean - delivery successful?
	Put(r Relation) bool

	// Initialize solver instance.<p>
	// @param id int - solver identifier
	// @param m BigInteger - number to be factorized
	// @param fb Factorbase - factor base to be used
	// @param cb SolverCallback - callback for requests/responses
	// @return boolean - successful operation?
	Init(id int, m *math.Int, fb FactorBase, cb SolverCallback) bool

	// Return number of pending relations in input queue.<p>
	// @return int - number of pending relations
	NumPending() int
}

type SolverCallback func(id int, r Relation, rc int)

type SolverImpl struct {
	InstanceImpl
	// contains filtered or unexported fields
}