Beispiel #1
0
def ga_p(city_list):
    cfg = GACfg(gene_len=25,
                gene_size=25,
                pop_size=1000,
                elite_size=50,
                tournament_num=50,
                tournament_size=100,
                mutation_rate=0.03,
                repeatable=False)
    ga = GA(fitness_func, cfg)
    ga.prepare_kwargs(city_list=city_list)
    ga.init_population()
    progress = []
    progress.append(1 / ga.cal_fitness()[0][1])
    for _ in range(100):
        early_stop = ga.evolve()
        progress.append(1 / ga.cal_fitness()[0][1])
        if early_stop:
            break

    print("Final distance: " + str(1 / ga.cal_fitness()[0][1]))
    plt.plot(progress)
    plt.ylabel('Distance')
    plt.xlabel('Generation')
    plt.show()
Beispiel #2
0
def testIrisReplacement(trainfile, testfile, attrfile):
    iris_train = pd.read_csv(trainfile, header=None)
    iris_test = pd.read_csv(testfile, header=None)
    iris_attr = pd.read_csv(attrfile, header=None)
    input, output, input_test, output_test = digitalize(iris_train, iris_test, iris_attr,"iris")
    input = input.astype(np.float)
    input = np.concatenate((input, output), axis=1)
    test_input = np.concatenate((input_test, output_test), axis=1)
    replaceRate = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
    strategies = ['fitness-proportional', 'tournament', 'rank']
    cor_list = []
    strategy_list = []
    for j in range (len(strategies)):
        print ('Strategy: ' + strategies[j])
        for i10 in range(1, 10, 1):
            i = i10 / 10
            print('Replacement rate: ' + str(i))
            ga = GA(100, 6, 48, 3, i, 0.1, 1, 1, 30, strategies[j], 'iris') 
            cor, bestHypo = ga.fit(input)
            testAcc = ga.predict(bestHypo, test_input)
            print("Accuracy: " + str(testAcc) +"\n" )
            cor_list.append(testAcc)
        cor_array = np.array(cor_list)
        strategy_list.append(cor_array)
        cor_list = []
    print ('correct rate for fitness-proportional, tournament, rank strategy at vary replacement rate are')
    print (strategy_list)
def main():
    pop_size, gen_count, mutation = 10, 30, 0.4
    #solve_methods = ["keras", "svm", "logistic", "naivebayes", \
    #                "randomforest", "lda"]
    solve_methods = ["keras"]
    accuracy_fname = "accuracy_keras.txt"
    with open(accuracy_fname, "w") as fp:
        for dataset in loadData():
            fp.write("===================================\n")
            fp.write("Filename: %s\n" % dataset['fname'])
            Organism.data = dataset
            Organism.count = dataset['X'].shape[1]
            fp.write("Num Features: %d\n" % Organism.count)
            fp.write("\n------------------------------------\n")
            for solve_method in solve_methods:
                print "Using solve method: ", solve_method
                fp.write("Using solve method: %s\n" % solve_method)
                full_accuracy = GA.full_accuracy(solve_method)
                print "Accuracy using all features: ", full_accuracy.fitness
                fp.write("Accuracy using all features: %f\n" % full_accuracy.fitness)
                solver = GA(gen_count, pop_size, mutation, solve_method)
                finalPop = solver.search()
                print "Best Accuracy: ", finalPop[0].fitness
                print "Subset of features used: ", finalPop[0].feature_subset
                fp.write("Pop Size: %d; Generation Count: %d; Mutation Rate: %f\n" % (pop_size, gen_count, mutation))
                fp.write("Best Accuracy: %f\n" % finalPop[0].fitness)
                fp.write("Subset of features used: " + str(finalPop[0].feature_subset))
                fp.write("\n------------------------------------\n\n")
Beispiel #4
0
def mutation_data():

    # Plot parameters
    data_source = "data/sequences/"
    gens = 450
    chromosomes = 250
    mutations = [
        0.01, 0.015, 0.02, 0.025, 0.03, 0.035, 0.04, 0.045, 0.05, 0.055, 0.06,
        0.065, 0.07, 0.075, 0.08, 0.085, 0.09, 0.095, 0.1
    ]

    # Create output file
    with open("data/output_data2.csv", 'w') as output_file:
        output_file.write("mutation, result\n")

    # Get files in the data source
    files = glob.glob(data_source + "*.txt")

    # Generate data
    for mutation in mutations:
        results = []
        print("Running for mutation rate = " + str(mutation))

        for file in files:
            with Utils.suppress_stdout():
                genetic_algorithm = GA(chromosomes, gens, gens, mutation)
                result = genetic_algorithm.run_ga(file)
                results.append(result)

        # Calc median
        median = np.median(results)

        # Write data to file
        with open("data/output_data2.csv", 'a') as output_file:
            output_file.write(str(mutation) + ", " + str(median) + "\n")
Beispiel #5
0
    def birdCheckCollision(bird):
        ''' Handles collision for the birds and updates game messages '''
        if (bird.x + bird.radius) > (self.pipes[0].x + 75) and self.pipes[0].z == 0:
            bird.score += 1

            # Handles the case in which a new high score is set
            if bird.score > self.highscore:
                self.bestBirdBrain = bird.brain
                self.foundBestBird = True
                self.highscore = bird.score
                self.pipes[0].z = 1
            
            # Handles wall or pipe collision by adding and removing birds from the lists
            if bird.collidingWall() or bird.collidingPipe():
                self.savedBirds.append(bird)
                self.birds.remove(bird)

                # Handles the death of the last bird
                if len(self.birds) == 0:
                    self.gameDisplay.blit(self.image, [0, 0])
                    self.pipes = []
                    self.counter = 0
                    ga = GA(self)
                    ga.nextGeneration()
                    self.generation += 1
                    self.gameLoop()
def search_with_vanguard(options):
    """maintains a list of extended_graphs. Each extended graph is mutated,
    and the best {shape[0]} mutants are kept. We maintain a tree structure of nested lists of graphs.
    This structure is called the 'vanguard,' the lowest-level lists are called 'platoons.'
    We 'retreat' the vanguard so that no more than {shape[1]} levels are present.
    This allows us to use a form of backtracking, which mitigates the loss of genetic diversity
    encountered when we mutate the vertices one-at-a-time.
    options = branch_factor, meta_pop, pop_per_mu, iterations_per_mu,
             elite_percent, crossover_percent, meta_elite_percent, make_unique,meta_select_proc
    """
    pop_size = options["meta_pop"]
    #independence_number =3
    #g = ExtendedGraph([(i,i+1) for i in range(4)] + [(4,0),(5,4),(5,2)])
    g = options["start_graph"]
    pop = [g]
    mutation_options = {
        "branch_factor": options["branch_factor"],
        "pop_per_mu": options["pop_per_mu"],
        "iterations_per_mu": options["iterations_per_mu"],
        "elite_percent": options["elite_percent"],
        "crossover_percent": options["crossover_percent"]
    }
    genetic_alg1 = GA(FUN.fit,
                      curry_add_vertex_and_mutate(mutation_options),
                      None,
                      0.0,
                      options["meta_elite_percent"],
                      pop_size=options["meta_pop"],
                      make_unique=options["make_unique"])
    #pop = [g]
    results = genetic_alg1.run(pop, 31, meta_select_proc=True)
    print([FUN.fit(r) for r in results])
    #return sorted(results, key=FUN.fit, reverse = True)[0]
    return results[0]
Beispiel #7
0
def main():

    # Create the input parser
    parser = argparse.ArgumentParser(
        description="Mine pull requests from GitHub's open repositories.")

    parser.add_argument("-input", metavar='-i', type=str, help="Input path")
    parser.add_argument("-chromosomes",
                        metavar='-c',
                        type=int,
                        help="Number of chromosomes")
    parser.add_argument("-gens",
                        metavar='-gen',
                        type=int,
                        help="Number of generations")
    parser.add_argument("-min_gens",
                        metavar='-min',
                        type=int,
                        help="Minimum number of generations before stopping")
    parser.add_argument("-mutation_rate",
                        metavar='-mut',
                        type=float,
                        help="Mutation rate")

    # Parse args
    args = parser.parse_args()

    # Run the GA
    start = time.time()
    genetic_algorithm = GA(args.chromosomes, args.gens, args.min_gens,
                           args.mutation_rate)
    genetic_algorithm.run_ga(args.input)
    end = time.time()
    print("\nRunning time: " + str(end - start) + " seconds")
Beispiel #8
0
def process(oil_data, freight_outward_data, freight_homeward_data,
            exchange_data, demand_data, supply_data, newbuilding_data,
            secondhand_data, actionlist):
    ga = GA(oil_data, freight_outward_data, freight_homeward_data,
            exchange_data, demand_data, supply_data, newbuilding_data,
            secondhand_data, actionlist)
    return ga.execute_GA()
 def consoleGA(self):
     '''
     Run non-interactive GA.
     '''
     from ga import GA
     ga = GA(self.params)
     ga.run()
def run_ga(n):
    ga = GA(n)
    ga.GA_main()
    result_programs = ga.memory_best_fit_program
    result_fits = ga.memory_best_fit
    json.dump(result_programs, open("result_programs", 'w'))
    json.dump(result_fits, open("result_fits", 'w'))
Beispiel #11
0
def test_itp():
    ga = GA(3)

    x = ga.MV([1., 2., 3., 4., 5., 6., 7., 8.])

    assert tuple(x.itp(-1)) == ()
    assert tuple(x.itp(0)) == (1.0, )
    assert tuple(x.itp(1)) == (2.0, 3.0, 4.0)
def exe():
    ga = GA()
    metrics = ga.get_metrics()

    slack = Slack(metrics)
    slack.post()

    return metrics
Beispiel #13
0
def test_pproj():
	from ga import GA
	ga = GA(3, [1., 1., 1.])
	t = ga.vector(1., 0., 0.)
	eye = ga.vector(0., 0., 1.0)
	B = ga.e1 ^ ga.e2
	q = ga.vector(0., 0., 0.5)

	x = pproj(t, eye, B, q)
	assert x == ga.vector(0.5, 0.0, 0.5), str(x)
Beispiel #14
0
def test_format():
    ga = GA(3)

    doctest(ga.MV([0., -0., 0., -0., 0., -0., 0., -0.]), '0.0')
    doctest(
        ga.MV([1., -1., 1., -1., 1., -1., 1., -1.]),
        '1.0-e1+e2-e3+e12-e13+e23-I',
    )
    doctest(ga.MV([2., -2., 2., -2., 2., -2., 2., -2.]),
            '2.0-2.0e1+2.0e2-2.0e3+2.0e12-2.0e13+2.0e23-2.0I')
Beispiel #15
0
def one_rule_example(actionlist):
    oil_data, freight_outward_data, freight_homeward_data, exchange_data, demand_data, supply_data, newbuilding_data, secondhand_data = load_generated_sinario(
        TRAIN_DATA_SET)
    ga = GA(oil_data, freight_outward_data, freight_homeward_data,
            exchange_data, demand_data, supply_data, newbuilding_data,
            secondhand_data, actionlist)
    p = []
    p.append(ga.execute_GA())
    print(p)
    export_rules_csv(p, 1)
Beispiel #16
0
def main():
    graph = read_graph_from_file(input_file)

    gaParams = GAParams(populationSize=20, noOfGenerations=1000, crossoverProb=0.7, mutationProb=0.15)
    problemParams = ProblemParams(network=graph, dim=len(graph), function=calculate_route_length)

    ga = GA(gaParams, problemParams)
    ga.initialisation()
    ga.evaluation()

    allBestFitnesses = []
    generationsBest = []
    overallBest = Chromosome(problemParams)

    for generation in range(gaParams.noOfGenerations):
        ga.oneGenerationSteadyState()

        bestChromo = ga.bestChromosome()
        print('Best solution in generation ' + str(generation) + ' f(x) = ' + str(bestChromo.fitness))
        allBestFitnesses.append(bestChromo.fitness)
        generationsBest.append(bestChromo)
        if bestChromo.fitness < overallBest.fitness:
            overallBest = bestChromo

    print(overallBest.representation)
    print(calculate_route_length(overallBest.representation, problemParams.network))
Beispiel #17
0
def test_part():
    ga = GA(3)

    x = ga.MV([1., 2., 3., 4., 5., 6., 7., 8.])

    doctest(x.part(-1), '0.0')
    doctest(x.part(0), '1.0')
    doctest(x.part(1), '2.0e1+3.0e2+4.0e3')
    doctest(x.part(2), '5.0e12+6.0e13+7.0e23')
    doctest(x.part(3), '8.0I')
    doctest(x.part(4), '0.0')
Beispiel #18
0
def main_test():
    chromosome_size = 24
    population_size = 4
    constraint = 5000
    prop_crossover = 0.9
    prob_mutation = 0.01
    max_generations = 3
    solver = GA(chromosome_size,population_size,constraint,prop_crossover,prob_mutation,max_generations)
    chromosome = np.random.choice([0,1],(chromosome_size,population_size))

    print(solver.calculate_fitness())
Beispiel #19
0
def test_sortbydist():
	ga = GA(3)

	p1 = [ga.e3 * 1.0]
	p2 = [ga.e3 * 2.0]

	rs = ex.sortbydist(ga, [p1, p2], 
		B = ga.e12, 
		q = ga.vector(),
	)


	assert rs == [p2, p1], str(rs)
Beispiel #20
0
def test_pproj():
	from random import random
	from ga import GA
	ga = GA(3, [1., 1., 1.])
	t = ga.vector(1., 0., 0.)
	eye = ga.vector(0., 0., 1.0)
	B = ga.e1 ^ ga.e2
	q = ga.vector(0., 0., 0.5)

	for _ in range(100):
		t = ga.vector(random()*100.0, random()*100.0, (random()-1.0)*100.0)
		x = pproj(t, eye, B, q)
		assert x._mv[3] - 0.5 < 0.0000000000001, (str(x), x._mv[3])
Beispiel #21
0
def test_inv():
    ga = GA(3)

    doctest(ga._1.inv(), '1.0')
    doctest(ga.e1.inv(), 'e1')
    doctest(ga.e12.inv(), '-e12')  # rev(e12) / (e12|e12) == -e12 / -1
    doctest(ga.I.inv(), '-I')
Beispiel #22
0
def test_bb_mul():
    ga = GA(3)

    doctest(ga.e1 * ga.e2, 'e12')
    doctest(ga.e1 * ga.e2 * ga.e3, 'I')
    doctest(ga.e2 * ga.e1, '-e12')
    doctest(2.0 * ga.e1, '2.0e1')
    doctest(ga.e12 * 2.0, '2.0e12')
Beispiel #23
0
def test_has_symbols():
    ga = GA(2)
    assert hasattr(ga, '_0')
    assert hasattr(ga, '_1')
    assert hasattr(ga, 'e1')
    assert hasattr(ga, 'e2')
    assert hasattr(ga, 'e12')
    assert hasattr(ga, 'I')
Beispiel #24
0
def test_left():
    ga = GA(3)

    doctest(ga.e2 << ga.e12, '-e1')
    doctest(ga.e3 << ga.e12, '0.0')
    doctest(ga.e12 << ga.e1, '0.0')
    doctest(ga._1 << ga.e1, 'e1')
    doctest(ga.e1 << ga._1, '0.0')
Beispiel #25
0
 def __init__(self):
     self.Training_Done = 0
     self.Trading_Required = 0
     self.System_Date = datetime(2011, 1, 1, 00, 00)
     self.popSize = 10
     self.i = 0
     self.cash_bal = 10000000
     self.asset_bal = 0
     self.TradingInfo = pd.DataFrame()  #to hold back testing results
     self.BackTestingInfo = pd.DataFrame()  #to hold back testing results
     self.train_dict = None
     self.test_dict = None
     self.FCPO = None
     self.j = 0
     self.initMarketRates()
     self.ga = GA()
     print("in init")
Beispiel #26
0
def main(argv):
    args = parse_args()
    if (args.pop_size % 2 != 0):
        print("Error: Population size needs to be an even number.")
        exit()

    if not os.path.exists(args.folder):
        os.mkdir(args.folder)

    #seed = random.randint(0, 16384)
    random.seed(args.seed)

    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    print(device)

    ga = GA(args.timelimit, args.pop_size, device)
    ga.run(args.generations, args.folder, args.ga_id, args.ga_init_solution_id)
def extend_search(mutation_options):
    """Picks one graph from the metapopulation and runs the G.A. for it."""
    level, values = choose_level(mutation_options["start_graph"])
    #values = eval(get_graphs_from_redis(level, mutation_options["start_graph"]))
    #print("got graphs")
    values.sort(key=lambda x: x[2])
    values[0][2] += 20
    set_graphs_to_redis(values)
    genetic_alg1 = GA(FUN.fit,
                      curry_add_vertex_and_mutate(mutation_options),
                      None,
                      0.0,
                      mutation_options["meta_elite_percent"],
                      pop_size=mutation_options["meta_pop"],
                      make_unique=mutation_options["make_unique"])
    pop = [values[0][0]]
    genetic_alg1.run(pop, 2, meta_select_proc=True)
Beispiel #28
0
def test_bb_add():
    ga = GA(3)

    doctest(ga._1 + ga.e1 + ga.e2, '1.0+e1+e2')
    doctest(ga.e1 + ga.e12, 'e1+e12')

    doctest(2.0 + ga.I, '2.0+I')
    doctest(ga.I + 2.0, '2.0+I')
Beispiel #29
0
def compare_methods(N):
    """
    Compare different optimization methods
    :param N: dimensionality of quantum system
    :return: a dictionary of results
    """
    # generate a random system
    sys = get_rand_unitary_sys(N)

    max_cost_func = sys["max_cost_func"]

    # we wrap the propagator to track how many calls each method makes
    propagator = sys["propagator"] = counted(sys["propagator"])

    # initialize the dictionary where results are stored
    results = dict(max_cost_func=max_cost_func, N=N)

    # ###################### Dynamical programming ######################
    results["dp_max"] = QStochDynProg(
        **sys).make_rounds(21).max_cost() / max_cost_func

    # save number of calls made during optimization
    results["dp_calls"] = propagator.calls

    # reset the count
    propagator.calls = 0

    ################ Hybrid monte-carlo tree seach and dynamical programming #############
    results["mcdp_max"] = MTCDynProg(nsteps=10, **sys).make_rounds(
        2**13).max_cost() / max_cost_func

    # save number of calls made during optimization
    results["mcdp_calls"] = propagator.calls

    # reset the count
    propagator.calls = 0

    ###################### Monte-Carlo tree search ######################
    results["mcts_max"] = MCTreeSearch(nsteps=2**10, **sys).make_rounds(
        2**13).max_cost() / max_cost_func

    # save number of calls made during optimization
    results["mcts_calls"] = propagator.calls

    # reset the count
    propagator.calls = 0

    ###################### Genetic algorithm ######################
    results["ga_max"] = GA(nsteps=2**11, pop_size=2**7, **sys).make_rounds(
        2**9).max_cost() / max_cost_func

    # save number of calls made during optimization
    results["ga_calls"] = propagator.calls

    # reset the count
    propagator.calls = 0

    return results
Beispiel #30
0
def create_ga_test(population_size=10):
    X, X_test, y, y_test, column_names = create_data()
    ga = GA(X=X,
            X_test=X_test,
            y=y,
            y_test=y_test,
            column_names=column_names,
            output_path='test')
    return ga
Beispiel #31
0
def test_eq():
    ga = GA(2)

    assert ga._1 == ga._1
    assert ga.e1 == ga.e1
    assert ga.I == ga.I

    assert not (ga.e2 == ga.e1)
    assert not (ga.e1 == ga.e2)
Beispiel #32
0
 def select_dataset_file(self):
     try:
         filename = askopenfilename()
         self.td["text"] = filename
         self.dataset_path = filename
         self.ga = GA(dataset_path=filename)
     except Exception as e:
         print(e)
         self.td["text"] = ""
Beispiel #33
0
def test_rev():
    ga = GA(3)

    doctest(ga._1.rev(), '1.0')
    doctest(ga.e1.rev(), 'e1')

    doctest(ga.e12.rev(), '-e12')
    doctest(ga.e12.rev().rev(), 'e12')
    doctest(ga.I.rev(), '-I')
    doctest(ga.I.rev().rev(), 'I')
Beispiel #34
0
 def train_ga(self):
     if self.mode == '4D':
         J = 6
         input_dim = 3
     else:
         J = 8
         input_dim = 5
     iteration_times = int(self.it.get())
     populations_size = int(self.ps.get())
     mutation_prob = int(self.mp.get()) / 100
     crossover_prob = int(self.cp.get()) / 100
     print(iteration_times, populations_size, mutation_prob, crossover_prob)
     self.GA = GA(iteration_times=iteration_times,
                  populations_size=populations_size,
                  mutation_prob=mutation_prob,
                  crossover_prob=crossover_prob,
                  J=J,
                  input_dim=input_dim,
                  dataset_path=self.dataset_path)
     self.GA.train()
def runGA():
    myWorld = World([
        [0, 0, 0, 0, 1, 0, 1, 3, 1],
        [1, 0, 1, 1, 1, 0, 2, 3, 1],
        [1, 0, 0, 1, 3, 3, 3, 3, 1],
        [3, 3, 3, 1, 3, 1, 1, 0, 1],
        [3, 1, 3, 3, 3, 1, 1, 0, 0],
        [3, 3, 1, 1, 1, 1, 0, 1, 1],
        [1, 3, 0, 1, 3, 3, 3, 3, 3],
        [0, 3, 1, 1, 3, 1, 0, 1, 3],
        [1, 3, 3, 3, 3, 1, 1, 1, 4],
    ])

    ga = GA(20, 0.05, 0.9, 2, 10)
    population = ga.initPopulation(128)
    ga.evalPopulation(population, myWorld)

    # Keep track of current generation
    generation = 1
    while ga.isTerminationConditionMet(generation, maxGenerations) == False:
        # Print fittest individual from population
        fittest = population.getFittest(0)

        print("G" + str(generation) + " Best solution (" +
              str(fittest.getFitness()) + "): " + fittest.toString())

        # Apply crossover
        population = ga.crossoverPopulation(population)

        # Apply mutation
        population = ga.mutatePopulation(population)

        # Evaluate population
        ga.evalPopulation(population, myWorld)

        # Increment the current generation
        generation += 1
    print("Stopped after " + str(maxGenerations) + " generations.")
    fittest = population.getFittest(0)
    print("Best solution (" + str(fittest.getFitness()) + "): " +
          fittest.toString())
Beispiel #36
0
class Model(object):
	def __init__(self):
		self.ga = GA(3, [1.0, 1.0, 1.0])
		#self.circ = circle(self.ga, 1.5, 20, 1.0, 2)
		self.circ = circle(self.ga, 1.5, 20)

	def update(self, dt):
		R = self.ga.rotor(self.ga.e13, pi/210.0)
		R = R * 0.999
		Rr = R.rev()
		self.circ = [R*p*Rr for p in self.circ[0]], self.circ[1]
			

	def __iter__(self):
		yield self.circ
Beispiel #37
0
def random_blade(n=3):
    x = GA(n).scalar(0)
    i = random.randint(0, 2**n - 1)
    x._data[i] = 1.0
    return x
Beispiel #38
0
def test_rotor():
	ga = GA(3)

	doctest(ga.rotor(), '1.0')
	doctest(ga.rotor(ga.e1^ga.e2, 0.0), '1.0')
Beispiel #39
0
def test_zero():
	ga = GA(0)
	assert ga.zero() == ga.MV([0.0])
Beispiel #40
0
def test_one():
	ga = GA(0)
	assert ga.one() == ga.MV([1.0])
Beispiel #41
0
from ga import GA
import random

arr = [[(-1 if random.randint(0, 1) == 0 else 1) for i in range(30)] for i in range(100)]
data = []
for row in arr :
  decision = -1 if random.randint(0, 1) == 0 else 1
  row[0] = decision
  data.append( (True if decision==1 else False, row) )

print(data)
######
host = GA(data=data, poolSize=10)
best = host.evolve(stableFactor=100, breedRate=0.3, mutateRate=0.2, mutationDegree=0.05, mutationComplexity=0.3)
print(best)
Beispiel #42
0
	def __init__(self):
		self.ga = GA(3, [1.0, 1.0, 1.0])
		#self.circ = circle(self.ga, 1.5, 20, 1.0, 2)
		self.circ = circle(self.ga, 1.5, 20)
Beispiel #43
0
#!/usr/bin/env python3

import sys
sys.path.append('./py')

from tests.test import *
from tests.random import *

from ga import GA
from multivector import MultiVector

ga = GA(3)
assert ga.n == 3

x = 4 + 3*ga[1] + 4*ga[2] + 5*ga[1,2]
y = 3 + 2*ga[1] + 3*ga[2] + 4*ga[1,2]
z = 10 + 16*ga[1] + 26*ga[2] + 32*ga[1,2]

assert x*y == z

ga2 = GA(2)
xx =ga2.coerce_multivector(x)

assert x != xx
assert xx == ga2.scalar(4) + ga2.blade(3, 1) + ga2.blade(4, 2) + ga2.blade(5, 1, 2)

e1 = ga[1]
e2 = ga[2]
e3 = ga[3]
assert e1.cross_product(e2) == e3
assert e2.cross_product(e3) == e1
Beispiel #44
0
 def __init__(self, f, **args):
     GA.__init__(self, f, **args)
     self.initLinkageMatrix()
     self.averageFitness = 0
     self.parentFitnesses = None