Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/Sources/formale Sprachen/GAP/pkg/simpcomp/src/ (Algebra von RWTH Aachen Version 4.15.1^©) Datei vom 18.2.2022 mit Größe 8 kB

Quelle reduce_complex.cpp Sprache: C

//
//  reduce_complex.cpp
//  Bistellar
//
//  Created by Alexander Thumm on 22.10.11.
//  Copyright 2011 -. All rights reserved.
//

#include "reduce_complex.h"

#include <iostream>
#include <stdlib.h>
#include <time.h>

const unsigned int baseHeating = 4;
const unsigned int baseRelaxation = 3;

void reduce_complex(MovableComplex & complex, unsigned int rounds, int heating, int relaxation)
{
    if (complex.dimension() == 0)
        return;

    // initialize the RNG
    srand(static_cast<unsigned int>(time(0)));

    MovableComplex minimalComplex = complex;

    for (int currentRound = 1; currentRound < rounds; currentRound++)
    {
        // select move
        bistellar_move_list_t moves;

        if (complex.dimension() < 3)
        {
            unsigned int i = complex.dimension();
            while (moves.empty())
            {
                moves = complex.validMoves(i);
                i--;
            }
        }
        else if (complex.dimension() == 3)
        {
            if (heating > 0)
            {
                if (heating % 15 == 0)
                {
                    moves = complex.validMoves(0);
                }
                else
                {
                    moves = complex.validMoves(1);
                    if (moves.empty())
                    {
                        moves = complex.validMoves(2);
                        heating = 0;
                    }
                }
                heating--;
            }
            else
            {
                moves = complex.validMoves(3);
                if (moves.empty())
                {
                    moves = complex.validMoves(2);
                    if (moves.empty())
                    {
                        moves = complex.validMoves(1);
                        if (relaxation == 10)
                        {
                            heating = 15;
                            relaxation = 0;
                        }
                        relaxation++;
                    }
                }
            }
        }
        else if (complex.dimension() == 4)
        {
            if (heating > 0)
            {
                if (heating % 20 == 0)
                {
                    moves = complex.validMoves(0);
                }
                else
                {
                    moves = complex.validMoves(1);
                    bistellar_move_list_t temp = complex.validMoves(2);
                    if (!temp.empty())
                        moves.insert(moves.begin(), temp.begin(), temp.end());

                    if (moves.empty())
                        moves = complex.validMoves(3);
                }
                heating--;
            }
            else
            {
                moves = complex.validMoves(4);
                if (moves.empty())
                {
                    moves = complex.validMoves(3);
                    if (moves.empty())
                    {
                        moves = complex.validMoves(2);
                        bistellar_move_list_t temp = complex.validMoves(1);
                        if (!temp.empty())
                            moves.insert(moves.begin(), temp.begin(), temp.end());

                        if (relaxation == 10)
                        {
                            heating = 20;
                            relaxation = 0;
                        }
                        relaxation++;
                    }
                }
            }
        }
        else if (complex.dimension() == 5)
        {
            if (heating > 0)
            {
                if (heating % 40 == 0)
                {
                    moves = complex.validMoves(0);
                }
                else
                {
                    moves = complex.validMoves(1);
                    bistellar_move_list_t temp = complex.validMoves(2);
                    if (!temp.empty())
                        moves.insert(moves.begin(), temp.begin(), temp.end());
                    temp = complex.validMoves(3);
                    if (!temp.empty())
                        moves.insert(moves.begin(), temp.begin(), temp.end());

                    if (moves.empty())
                        moves = complex.validMoves(4);
                }
                heating--;
            }
            else
            {
                moves = complex.validMoves(5);
                if (moves.empty())
                {
                    moves = complex.validMoves(4);
                    if (moves.empty())
                    {
                        moves = complex.validMoves(3);
                        if (moves.empty())
                        {
                            moves = complex.validMoves(2);
                            bistellar_move_list_t temp = complex.validMoves(1);
                            if (!temp.empty())
                                moves.insert(moves.begin(), temp.begin(), temp.end());

                            if (relaxation == 20)
                            {
                                heating = 40;
                                relaxation = 0;
                            }
                            relaxation++;
                        }
                    }
                }
            }

        }
        else
        {
            if (heating > 0)
            {
                //if (heating % ((complex.dimension()+2)*baseHeating) == 0)
                //{
                //    moves = complex.validMoves(0);
                //}
                //else
                //{
                    for (unsigned int i = 1; i < complex.dimension()/2 + 1; i++)
                    {
                        bistellar_move_list_t temp = complex.validMoves(i);
                        if (!temp.empty())
                            moves.insert(moves.begin(), temp.begin(), temp.end());
                    }
                //}
                if (moves.empty())
                {
                    for (unsigned int i = 1; i < complex.dimension()+2; i++)
                    {
                        bistellar_move_list_t temp = complex.validMoves(complex.dimension() + 1 - i);
                        if (!temp.empty())
                        {
                            moves.insert(moves.begin(), temp.begin(), temp.end());
                            if (i > (complex.dimension()-1)/2)
                                break;
                        }
                    }
                }
                heating--;
            }
            else
            {
                if (complex.dimension() % 2 == 1)
                {
                    for (unsigned int i = 1; i < (complex.dimension()+1)/2 + 1; i++)
                    {
                        bistellar_move_list_t temp = complex.validMoves(complex.dimension() + 1 - i);
                        if (!temp.empty())
                        {
                            moves = temp;
                            break;
                        }
                    }
                }
                else
                {
                    for (unsigned int i = 1; i < std::min((complex.dimension()+1)/2 + 1, complex.dimension())+1; i++)
                    {
                        bistellar_move_list_t temp = complex.validMoves(complex.dimension() + 1 - i);
                        if (!temp.empty())
                        {
                            moves = temp;
                            break;
                        }
                    }
                }
                if (moves.empty())
                {
                    for (unsigned int i = 1; i < std::min((complex.dimension()+1)/2 + 1, complex.dimension())+1; i++)
                    {
                        bistellar_move_list_t temp = complex.validMoves(i);
                        if (!temp.empty())
                        {
                            moves = temp;
                            break;
                        }
                    }
                }
                if (relaxation == (complex.dimension()+2)*baseRelaxation)
                {
                    //heating = (complex.dimension()+2)*baseHeating;
      heating = 1;
                    relaxation = 0;
                }
                relaxation++;
            }
        }

        // perform move
        if (moves.size() == 0)
            break;

        BistellarMove move = moves.at(rand() % moves.size());
        complex.moveComplex(move);

        if (complex.f(0) < minimalComplex.f(0))
        {
            minimalComplex = complex;
            std::cout << "found complex with " << minimalComplex.f(0) << " vertices in round " << currentRound << std::endl;

        }
    }
    complex = minimalComplex;
}

quality90%

¤ Dauer der Verarbeitung: 0.12 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.