blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
616
| content_id
stringlengths 40
40
| detected_licenses
sequencelengths 0
112
| license_type
stringclasses 2
values | repo_name
stringlengths 5
115
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 777
values | visit_date
timestamp[us]date 2015-08-06 10:31:46
2023-09-06 10:44:38
| revision_date
timestamp[us]date 1970-01-01 02:38:32
2037-05-03 13:00:00
| committer_date
timestamp[us]date 1970-01-01 02:38:32
2023-09-06 01:08:06
| github_id
int64 4.92k
681M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 22
values | gha_event_created_at
timestamp[us]date 2012-06-04 01:52:49
2023-09-14 21:59:50
⌀ | gha_created_at
timestamp[us]date 2008-05-22 07:58:19
2023-08-21 12:35:19
⌀ | gha_language
stringclasses 149
values | src_encoding
stringclasses 26
values | language
stringclasses 1
value | is_vendor
bool 2
classes | is_generated
bool 2
classes | length_bytes
int64 3
10.2M
| extension
stringclasses 188
values | content
stringlengths 3
10.2M
| authors
sequencelengths 1
1
| author_id
stringlengths 1
132
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
660db7cf37d0c43e23f7a596370be654b457e365 | 959122eea21cec24a4cf32808a24482feda73863 | /account/migrations/0001_initial.py | 5340e80bcf8a95717424cdd0591d4929d71890df | [] | no_license | AsadullahFarooqi/InventoryWebApp | 9fbe6ccafcb93bb5cb1879b728954867014d0afd | 07e8e6cb06e11f8ef6ada6a590e52f569a8c2d6b | refs/heads/master | 2020-06-18T15:06:18.612258 | 2019-07-11T07:32:00 | 2019-07-11T07:32:00 | 196,341,216 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,138 | py | # -*- coding: utf-8 -*-
# Generated by Django 1.11.7 on 2018-03-21 06:14
from __future__ import unicode_literals
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='Profile',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('activation_key', models.CharField(blank=True, max_length=120, null=True)),
('activated', models.BooleanField(default=False)),
('timestamp', models.DateTimeField(auto_now_add=True)),
('updated', models.DateTimeField(auto_now=True)),
('slug', models.SlugField(blank=True, unique=True)),
('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='profile', to=settings.AUTH_USER_MODEL)),
],
),
]
| [
"[email protected]"
] | |
2cea009e2b7488d145a5c09e172c6dc3f4a5fd14 | 5e80f0b1af9fbf9dc774dbb68aa603574e4ae0ba | /python/deep learning/matplot_test2.py | 2de2dd91a1fa053c0c0b9595266cbe18ddff1a10 | [] | no_license | namujinju/study-note | 4271b4248b3c4ac1b96ef1da484d86569a030762 | 790b21e5318a326e434dc836f5f678a608037a8c | refs/heads/master | 2023-02-04T13:25:55.418896 | 2020-12-26T10:47:11 | 2020-12-26T10:47:11 | 275,279,138 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 960 | py | import matplotlib as mpl
import pandas
import matplotlib.pyplot as plt
import matplotlib.pyplot as plt
# matplotlib 폰트설정
plt.rc('font', family='NanumGothic') # For Windows
DATASET_PATH = "../Datasets/"
test_dataframe = pandas.read_csv(DATASET_PATH + '목포 2014년.csv', sep=",", engine='python', header = None)
test_dataframe = test_dataframe.iloc[:20, :] # 1년 8760개의 데이터 중 1월만 가져옴
test_prediction_dataframe = pandas.read_csv(DATASET_PATH + 'my_testset_prediction_2014.csv', sep=",", engine='python', header = None)
# test
dataset = test_dataframe.values
x = dataset[:20,0]
y1 = dataset[:20,5]
dataset = test_prediction_dataframe.values
y2 = dataset[:20,0]
plt.plot(x, y1, label="observed")
plt.plot(x, y2, label="predicted")
# plt.plot(x, y3, label="MAE")
plt.title("2014년 영암 태양광 발전소 발전량 예측값과 관측값 testset")
plt.xlabel("시간")
plt.ylabel("발전량(kWh)")
plt.legend()
plt.show()
| [
"[email protected]"
] | |
9493c500bcafef612ab8fabddda6e9cf0fbc065d | 0be27c0a583d3a8edd5d136c091e74a3df51b526 | /sort_based_on_vowels.py | 138e56e804102a3ecf306375c10d58a27eb22549 | [] | no_license | ssangitha/guvicode | 3d38942f5d5e27a7978e070e14be07a5269b01fe | ea960fb056cfe577eec81e83841929e41a31f72e | refs/heads/master | 2020-04-15T05:01:00.226391 | 2019-09-06T10:08:23 | 2019-09-06T10:08:23 | 164,405,935 | 0 | 2 | null | null | null | null | UTF-8 | Python | false | false | 228 | py | l=["a","e","i","o","u","A","E","I","O","U"]
n=int(input())
c=0
m=[]
for i in range(n):
a=input()
for i in a:
if i in l:
c+=1
m.append([a,c])
c=0
m.sort(key=lambda x:x[1],reverse=True)
for i in range(n):
print(m[i][0])
| [
"[email protected]"
] | |
83ce54fb3ad0d2a17033243d3d170b31aa63f207 | febeffe6ab6aaa33e3a92e2dbbd75783a4e32606 | /ssseg/cfgs/gcnet/cfgs_cityscapes_resnet101os16.py | 2b548a998b4066159b8e526c725ecbb0f1dc850e | [
"MIT"
] | permissive | Junjun2016/sssegmentation | 7bbc5d53abee1e0cc88d5e989e4cff5760ffcd09 | bf7281b369e8d7fc2f8986caaeec3ec38a30c313 | refs/heads/main | 2023-02-04T22:09:13.921774 | 2020-12-23T06:28:56 | 2020-12-23T06:28:56 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,317 | py | '''define the config file for cityscapes and resnet101os16'''
from .base_cfg import *
# modify dataset config
DATASET_CFG = DATASET_CFG.copy()
DATASET_CFG['train'].update(
{
'type': 'cityscapes',
'rootdir': '/data/CityScapes',
'aug_opts': [('Resize', {'output_size': (2048, 1024), 'keep_ratio': True, 'scale_range': (0.5, 2.0)}),
('RandomCrop', {'crop_size': (512, 1024), 'one_category_max_ratio': 0.75}),
('RandomFlip', {'flip_prob': 0.5}),
('PhotoMetricDistortion', {}),
('Normalize', {'mean': [123.675, 116.28, 103.53], 'std': [58.395, 57.12, 57.375]}),
('ToTensor', {}),
('Padding', {'output_size': (512, 1024), 'data_type': 'tensor'}),]
}
)
DATASET_CFG['test'].update(
{
'type': 'cityscapes',
'rootdir': '/data/CityScapes',
'aug_opts': [('Resize', {'output_size': (2048, 1024), 'keep_ratio': True, 'scale_range': None}),
('Normalize', {'mean': [123.675, 116.28, 103.53], 'std': [58.395, 57.12, 57.375]}),
('ToTensor', {}),],
}
)
# modify dataloader config
DATALOADER_CFG = DATALOADER_CFG.copy()
DATALOADER_CFG['train'].update(
{
'batch_size': 8,
}
)
# modify optimizer config
OPTIMIZER_CFG = OPTIMIZER_CFG.copy()
OPTIMIZER_CFG.update(
{
'max_epochs': 220
}
)
# modify losses config
LOSSES_CFG = LOSSES_CFG.copy()
# modify model config
MODEL_CFG = MODEL_CFG.copy()
MODEL_CFG.update(
{
'num_classes': 19,
'backbone': {
'type': 'resnet101',
'series': 'resnet',
'pretrained': True,
'outstride': 16,
'is_use_stem': True
},
}
)
# modify common config
COMMON_CFG = COMMON_CFG.copy()
COMMON_CFG['train'].update(
{
'backupdir': 'gcnet_resnet101os16_cityscapes_train',
'logfilepath': 'gcnet_resnet101os16_cityscapes_train/train.log',
}
)
COMMON_CFG['test'].update(
{
'backupdir': 'gcnet_resnet101os16_cityscapes_test',
'logfilepath': 'gcnet_resnet101os16_cityscapes_test/test.log',
'resultsavepath': 'gcnet_resnet101os16_cityscapes_test/gcnet_resnet101os16_cityscapes_results.pkl'
}
) | [
"[email protected]"
] | |
31eae4246d94f36c4e53982ca85c5f89ddb83f88 | 2fed9d28558360a74ba52772a3793a6180d6d0b8 | /meiduo_mall/meiduo_mall/meiduo_mall/apps/meiduo_main/view/ordersView.py | 2e24f0ccc26d8dc3e7071d8f30652f701df56ce7 | [] | no_license | xj-ie/rest_framework-0.2 | 13e6b24327e99108b7fc433c8ecf6a976245477d | e9ef7716d5fae87b278845a28a9fbc1af1bcf8df | refs/heads/master | 2022-12-12T15:20:38.402755 | 2020-09-05T01:31:05 | 2020-09-05T01:31:05 | 290,355,223 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,089 | py | from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.viewsets import ReadOnlyModelViewSet
from rest_framework.permissions import IsAdminUser
from meiduo_main.utils import PageUnm
from meiduo_main.verializer.orderserialzier import OrderSeriazlier
from orders.models import OrderInfo
class OrdersView(ReadOnlyModelViewSet):
permission_classes = [IsAdminUser]
serializer_class = OrderSeriazlier
pagination_class = PageUnm
def get_queryset(self):
if not self.request.query_params.get('keyword'):
return OrderInfo.objects.all()
else:
return OrderInfo.objects.filter(order_id__contains=self.request.query_params.get('keyword'))
@action(methods=["put"], detail=True,)
def status(self, request, pk):
try:
order = OrderInfo.objects.get(OrderInfo_id=pk)
except Exception as e:
raise e
status = request.data.get("status")
order.status = status
order.save()
return Response({"pk":pk,"status":status})
| [
"[email protected]"
] | |
f3f7551884b09ee0f04581a97137aa32b95c9ad1 | 52b5773617a1b972a905de4d692540d26ff74926 | /.history/length_20200530000955.py | 2a69096dfd430b6fa026c101a17a24b32c58f34b | [] | no_license | MaryanneNjeri/pythonModules | 56f54bf098ae58ea069bf33f11ae94fa8eedcabc | f4e56b1e4dda2349267af634a46f6b9df6686020 | refs/heads/master | 2022-12-16T02:59:19.896129 | 2020-09-11T12:05:22 | 2020-09-11T12:05:22 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 474 | py | def removeDuplicates(nums):
i = 0
while i < len(nums):
print(i,'i---------->','nums at i',nums[nums[i]])
j = i+1
while j< len(nums):
print(j,'j---->','nums at j',nums[nums[j]])
if nums[i] == nums[j]:
print(nums[i],'----was removed')
nums.remove(nums[i])
j +=1
i +=1
print(nums)
removeDuplicates([1,2,2,2])
| [
"[email protected]"
] | |
48ca7d397841d82276541e4f2df9185694286518 | 53fab060fa262e5d5026e0807d93c75fb81e67b9 | /backup/user_264/ch16_2019_03_13_02_50_16_810830.py | a1d029cf30fa8ba3b1690d8e41608be6cb84ef9f | [] | no_license | gabriellaec/desoft-analise-exercicios | b77c6999424c5ce7e44086a12589a0ad43d6adca | 01940ab0897aa6005764fc220b900e4d6161d36b | refs/heads/main | 2023-01-31T17:19:42.050628 | 2020-12-16T05:21:31 | 2020-12-16T05:21:31 | 306,735,108 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 107 | py | import math
def distancia_euclidiana(x1, y1, x2, y2):
d = sqrt(((x2-x1)**2)+((y2-y1)**2))
return d | [
"[email protected]"
] | |
d13b13a4e5f3e3b9464f7d3916f0727780cdd2fd | 5e2284bff015e6b03e4ea346572b29aaaf79c7c2 | /docs/source/conf.py | ada5bca296c674f1d233246497f7a700de57ef25 | [
"MIT"
] | permissive | LaurenDebruyn/aocdbc | bbfd7d832f9761ba5b8fb527151157742b2e4890 | b857e8deff87373039636c12a170c0086b19f04c | refs/heads/main | 2023-06-11T23:02:09.825705 | 2021-07-05T09:26:23 | 2021-07-05T09:26:23 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 5,961 | py | # -*- coding: utf-8 -*-
#
# Configuration file for the Sphinx documentation builder.
#
# This file does only contain a selection of the most common options. For a
# full list see the documentation:
# http://www.sphinx-doc.org/en/master/config
# -- Path setup --------------------------------------------------------------
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
import os
import sys
from typing import Dict, List, Tuple
sys.path.insert(0, os.path.abspath("../.."))
import correct_programs
# -- Project information -----------------------------------------------------
project = "python-by-contract-corpus"
author = "Lauren De bruyn, Marko Ristin, Phillip Schanely"
description = "A corpus of Python programs annotated with contracts"
# The short X.Y version
version = "1.0"
# The full version, including alpha/beta/rc tags
release = "1.0"
# -- General configuration ---------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
"sphinx.ext.autodoc",
"sphinx.ext.doctest",
"sphinx.ext.autosectionlabel",
"sphinx.ext.viewcode",
"autodocsumm",
"sphinx_icontract"
]
autodoc_typehints = "signature"
autodoc_default_options = {
"members": True,
"undoc-members": True,
"member-order": "bysource",
"autosummary": True,
}
# Add any paths that contain templates here, relative to this directory.
templates_path = ["_templates"]
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = ".rst"
# The master toctree document.
master_doc = "index"
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This pattern also affects html_static_path and html_extra_path.
exclude_patterns: List[str] = []
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = "sphinx"
# Do not show module names as exercises are mostly self-containing, so the module names
# only hinder readability
add_module_names = False
# -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
html_theme = "sphinx_rtd_theme"
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#
# html_theme_options = {}
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path: List[str] = []
# Custom sidebar templates, must be a dictionary that maps document names
# to template names.
#
# The default sidebars (for documents that don't match any pattern) are
# defined by theme itself. Builtin themes are using these templates by
# default: ``['localtoc.html', 'relations.html', 'sourcelink.html',
# 'searchbox.html']``.
#
# html_sidebars = {}
# html_logo = "logo.png"
# -- Options for HTMLHelp output ---------------------------------------------
# Output file base name for HTML help builder.
htmlhelp_basename = "python_by_contract_corpus_doc"
# -- Options for LaTeX output ------------------------------------------------
latex_elements: Dict[str, str] = {
# The paper size ('letterpaper' or 'a4paper').
#
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#
# 'preamble': '',
# Latex figure (float) alignment
#
# 'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(
master_doc,
"{}.tex".format(project),
"{} Documentation".format(project),
author,
"manual",
),
]
# -- Options for manual page output ------------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [(master_doc, project, "{} Documentation".format(project), [author], 1)]
# -- Options for Texinfo output ----------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(
master_doc,
project,
"{} Documentation".format(project),
author,
project,
description,
"Miscellaneous",
),
]
# -- Options for Epub output -------------------------------------------------
# Bibliographic Dublin Core info.
epub_title = project
# The unique identifier of the text. This can be a ISBN number
# or the project homepage.
#
# epub_identifier = ''
# A unique identification for the text.
#
# epub_uid = ''
# A list of files that should not be packed into the epub file.
epub_exclude_files = ["search.html"]
# -- Extension configuration -------------------------------------------------
| [
"[email protected]"
] | |
45670a3d2d9a0ac6b7003b1bc305c2321c58522e | a3f1e80179c23d9202d72b75dd37a49b44785f45 | /api/client/swagger_client/models/api_pipeline_custom.py | e8121beb8d0b1d83de76082c965a59dc57d9b46d | [
"Apache-2.0"
] | permissive | pvaneck/mlx | b1e82fae5ac8aaa1dddac23aaa38c46f6e6cfc27 | 6edaa0bd77787c56b737322a0c875ae30de6cd49 | refs/heads/main | 2023-05-14T06:08:38.404133 | 2021-05-04T01:41:11 | 2021-05-04T01:41:11 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 6,191 | py | # Copyright 2021 IBM Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# coding: utf-8
"""
MLX API
MLX API Extension for Kubeflow Pipelines # noqa: E501
OpenAPI spec version: 0.1.25-related-assets
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
import pprint
import re # noqa: F401
import six
from swagger_client.models.api_pipeline_dag import ApiPipelineDAG # noqa: F401,E501
from swagger_client.models.api_pipeline_inputs import ApiPipelineInputs # noqa: F401,E501
class ApiPipelineCustom(object):
"""NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually.
"""
"""
Attributes:
swagger_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
"""
swagger_types = {
'dag': 'ApiPipelineDAG',
'inputs': 'ApiPipelineInputs',
'name': 'str',
'description': 'str'
}
attribute_map = {
'dag': 'dag',
'inputs': 'inputs',
'name': 'name',
'description': 'description'
}
def __init__(self, dag=None, inputs=None, name=None, description=None): # noqa: E501
"""ApiPipelineCustom - a model defined in Swagger""" # noqa: E501
self._dag = None
self._inputs = None
self._name = None
self._description = None
self.discriminator = None
self.dag = dag
if inputs is not None:
self.inputs = inputs
self.name = name
if description is not None:
self.description = description
@property
def dag(self):
"""Gets the dag of this ApiPipelineCustom. # noqa: E501
:return: The dag of this ApiPipelineCustom. # noqa: E501
:rtype: ApiPipelineDAG
"""
return self._dag
@dag.setter
def dag(self, dag):
"""Sets the dag of this ApiPipelineCustom.
:param dag: The dag of this ApiPipelineCustom. # noqa: E501
:type: ApiPipelineDAG
"""
if dag is None:
raise ValueError("Invalid value for `dag`, must not be `None`") # noqa: E501
self._dag = dag
@property
def inputs(self):
"""Gets the inputs of this ApiPipelineCustom. # noqa: E501
:return: The inputs of this ApiPipelineCustom. # noqa: E501
:rtype: ApiPipelineInputs
"""
return self._inputs
@inputs.setter
def inputs(self, inputs):
"""Sets the inputs of this ApiPipelineCustom.
:param inputs: The inputs of this ApiPipelineCustom. # noqa: E501
:type: ApiPipelineInputs
"""
self._inputs = inputs
@property
def name(self):
"""Gets the name of this ApiPipelineCustom. # noqa: E501
Name of the custom pipeline # noqa: E501
:return: The name of this ApiPipelineCustom. # noqa: E501
:rtype: str
"""
return self._name
@name.setter
def name(self, name):
"""Sets the name of this ApiPipelineCustom.
Name of the custom pipeline # noqa: E501
:param name: The name of this ApiPipelineCustom. # noqa: E501
:type: str
"""
if name is None:
raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501
self._name = name
@property
def description(self):
"""Gets the description of this ApiPipelineCustom. # noqa: E501
Optional description of the custom pipeline # noqa: E501
:return: The description of this ApiPipelineCustom. # noqa: E501
:rtype: str
"""
return self._description
@description.setter
def description(self, description):
"""Sets the description of this ApiPipelineCustom.
Optional description of the custom pipeline # noqa: E501
:param description: The description of this ApiPipelineCustom. # noqa: E501
:type: str
"""
self._description = description
def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(ApiPipelineCustom, dict):
for key, value in self.items():
result[key] = value
return result
def to_str(self):
"""Returns the string representation of the model"""
return pprint.pformat(self.to_dict())
def __repr__(self):
"""For `print` and `pprint`"""
return self.to_str()
def __eq__(self, other):
"""Returns true if both objects are equal"""
if not isinstance(other, ApiPipelineCustom):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""Returns true if both objects are not equal"""
return not self == other
| [
"[email protected]"
] | |
b42cf163d4f8bdc75575b3da040f41dc5fc3b13b | 0e478f3d8b6c323c093455428c9094c45de13bac | /src/OTLMOW/OTLModel/Datatypes/KlVerlichtingstoestelMerk.py | 8c7856a23aba0c4fd7334f2b6b1eb8d3dc506f0a | [
"MIT"
] | permissive | davidvlaminck/OTLMOW | c6eae90b2cab8a741271002cde454427ca8b75ba | 48f8c357c475da1d2a1bc7820556843d4b37838d | refs/heads/main | 2023-01-12T05:08:40.442734 | 2023-01-10T15:26:39 | 2023-01-10T15:26:39 | 432,681,113 | 3 | 1 | MIT | 2022-06-20T20:36:00 | 2021-11-28T10:28:24 | Python | UTF-8 | Python | false | false | 3,302 | py | # coding=utf-8
import random
from OTLMOW.OTLModel.Datatypes.KeuzelijstField import KeuzelijstField
from OTLMOW.OTLModel.Datatypes.KeuzelijstWaarde import KeuzelijstWaarde
# Generated with OTLEnumerationCreator. To modify: extend, do not edit
class KlVerlichtingstoestelMerk(KeuzelijstField):
"""Het merk van het verlichtingstoestel."""
naam = 'KlVerlichtingstoestelMerk'
label = 'Verlichtingstoestel merk'
objectUri = 'https://wegenenverkeer.data.vlaanderen.be/ns/abstracten#KlVerlichtingstoestelMerk'
definition = 'Het merk van het verlichtingstoestel.'
status = 'ingebruik'
codelist = 'https://wegenenverkeer.data.vlaanderen.be/id/conceptscheme/KlVerlichtingstoestelMerk'
options = {
'ARC': KeuzelijstWaarde(invulwaarde='ARC',
label='ARC',
status='uitgebruik',
definitie='ARC',
objectUri='https://wegenenverkeer.data.vlaanderen.be/id/concept/KlVerlichtingstoestelMerk/ARC'),
'HCI-TS': KeuzelijstWaarde(invulwaarde='HCI-TS',
label='HCI-TS',
status='uitgebruik',
definitie='HCI-TS',
objectUri='https://wegenenverkeer.data.vlaanderen.be/id/concept/KlVerlichtingstoestelMerk/HCI-TS'),
'Philips': KeuzelijstWaarde(invulwaarde='Philips',
label='Philips',
status='ingebruik',
objectUri='https://wegenenverkeer.data.vlaanderen.be/id/concept/KlVerlichtingstoestelMerk/Philips'),
'Rombalux': KeuzelijstWaarde(invulwaarde='Rombalux',
label='Rombalux',
status='uitgebruik',
definitie='Rombalux',
objectUri='https://wegenenverkeer.data.vlaanderen.be/id/concept/KlVerlichtingstoestelMerk/Rombalux'),
'Schreder': KeuzelijstWaarde(invulwaarde='Schreder',
label='Schreder',
status='ingebruik',
objectUri='https://wegenenverkeer.data.vlaanderen.be/id/concept/KlVerlichtingstoestelMerk/Schreder'),
'andere': KeuzelijstWaarde(invulwaarde='andere',
label='andere',
status='ingebruik',
objectUri='https://wegenenverkeer.data.vlaanderen.be/id/concept/KlVerlichtingstoestelMerk/andere'),
'lightwell': KeuzelijstWaarde(invulwaarde='lightwell',
label='Lightwell',
status='ingebruik',
definitie='Lightwell',
objectUri='https://wegenenverkeer.data.vlaanderen.be/id/concept/KlVerlichtingstoestelMerk/lightwell')
}
@classmethod
def create_dummy_data(cls):
return random.choice(list(map(lambda x: x.invulwaarde,
filter(lambda option: option.status == 'ingebruik', cls.options.values()))))
| [
"[email protected]"
] | |
361ef6f4861f97380643d983b09e9fe220e2720a | 3c000380cbb7e8deb6abf9c6f3e29e8e89784830 | /venv/Lib/site-packages/cobra/modelimpl/cloud/hostrouteregresspkts15min.py | d56e30a2b6e75dce09114ac5b0559db59074cee9 | [] | no_license | bkhoward/aciDOM | 91b0406f00da7aac413a81c8db2129b4bfc5497b | f2674456ecb19cf7299ef0c5a0887560b8b315d0 | refs/heads/master | 2023-03-27T23:37:02.836904 | 2021-03-26T22:07:54 | 2021-03-26T22:07:54 | 351,855,399 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 14,189 | py | # coding=UTF-8
# **********************************************************************
# Copyright (c) 2013-2020 Cisco Systems, Inc. All rights reserved
# written by zen warriors, do not modify!
# **********************************************************************
from cobra.mit.meta import ClassMeta
from cobra.mit.meta import StatsClassMeta
from cobra.mit.meta import CounterMeta
from cobra.mit.meta import PropMeta
from cobra.mit.meta import Category
from cobra.mit.meta import SourceRelationMeta
from cobra.mit.meta import NamedSourceRelationMeta
from cobra.mit.meta import TargetRelationMeta
from cobra.mit.meta import DeploymentPathMeta, DeploymentCategory
from cobra.model.category import MoCategory, PropCategory, CounterCategory
from cobra.mit.mo import Mo
# ##################################################
class HostRouterEgressPkts15min(Mo):
"""
Mo doc not defined in techpub!!!
"""
meta = StatsClassMeta("cobra.model.cloud.HostRouterEgressPkts15min", "host router egress packets")
counter = CounterMeta("unicast", CounterCategory.COUNTER, "packets", "host router egress unicast packets")
counter._propRefs[PropCategory.IMPLICIT_LASTREADING] = "unicastLast"
counter._propRefs[PropCategory.IMPLICIT_CUMULATIVE] = "unicastCum"
counter._propRefs[PropCategory.IMPLICIT_PERIODIC] = "unicastPer"
counter._propRefs[PropCategory.IMPLICIT_MIN] = "unicastMin"
counter._propRefs[PropCategory.IMPLICIT_MAX] = "unicastMax"
counter._propRefs[PropCategory.IMPLICIT_AVG] = "unicastAvg"
counter._propRefs[PropCategory.IMPLICIT_SUSPECT] = "unicastSpct"
counter._propRefs[PropCategory.IMPLICIT_BASELINE] = "unicastBase"
counter._propRefs[PropCategory.IMPLICIT_THRESHOLDED] = "unicastThr"
counter._propRefs[PropCategory.IMPLICIT_TREND_BASE] = "unicastTrBase"
counter._propRefs[PropCategory.IMPLICIT_TREND] = "unicastTr"
counter._propRefs[PropCategory.IMPLICIT_RATE] = "unicastRate"
meta._counters.append(counter)
meta.moClassName = "cloudHostRouterEgressPkts15min"
meta.rnFormat = "CDcloudHostRouterEgressPkts15min"
meta.category = MoCategory.STATS_CURRENT
meta.label = "current host router egress packets stats in 15 minute"
meta.writeAccessMask = 0x601
meta.readAccessMask = 0x601
meta.isDomainable = False
meta.isReadOnly = True
meta.isConfigurable = False
meta.isDeletable = False
meta.isContextRoot = False
meta.parentClasses.add("cobra.model.cloud.HostRouterTunnelInfoHolder")
meta.superClasses.add("cobra.model.stats.Item")
meta.superClasses.add("cobra.model.stats.Curr")
meta.superClasses.add("cobra.model.cloud.HostRouterEgressPkts")
meta.rnPrefixes = [
('CDcloudHostRouterEgressPkts15min', False),
]
prop = PropMeta("str", "childAction", "childAction", 4, PropCategory.CHILD_ACTION)
prop.label = "None"
prop.isImplicit = True
prop.isAdmin = True
prop._addConstant("deleteAll", "deleteall", 16384)
prop._addConstant("deleteNonPresent", "deletenonpresent", 8192)
prop._addConstant("ignore", "ignore", 4096)
meta.props.add("childAction", prop)
prop = PropMeta("str", "cnt", "cnt", 16212, PropCategory.REGULAR)
prop.label = "Number of Collections During this Interval"
prop.isImplicit = True
prop.isAdmin = True
meta.props.add("cnt", prop)
prop = PropMeta("str", "dn", "dn", 1, PropCategory.DN)
prop.label = "None"
prop.isDn = True
prop.isImplicit = True
prop.isAdmin = True
prop.isCreateOnly = True
meta.props.add("dn", prop)
prop = PropMeta("str", "lastCollOffset", "lastCollOffset", 111, PropCategory.REGULAR)
prop.label = "Collection Length"
prop.isImplicit = True
prop.isAdmin = True
meta.props.add("lastCollOffset", prop)
prop = PropMeta("str", "modTs", "modTs", 7, PropCategory.REGULAR)
prop.label = "None"
prop.isImplicit = True
prop.isAdmin = True
prop.defaultValue = 0
prop.defaultValueStr = "never"
prop._addConstant("never", "never", 0)
meta.props.add("modTs", prop)
prop = PropMeta("str", "repIntvEnd", "repIntvEnd", 110, PropCategory.REGULAR)
prop.label = "Reporting End Time"
prop.isImplicit = True
prop.isAdmin = True
meta.props.add("repIntvEnd", prop)
prop = PropMeta("str", "repIntvStart", "repIntvStart", 109, PropCategory.REGULAR)
prop.label = "Reporting Start Time"
prop.isImplicit = True
prop.isAdmin = True
meta.props.add("repIntvStart", prop)
prop = PropMeta("str", "rn", "rn", 2, PropCategory.RN)
prop.label = "None"
prop.isRn = True
prop.isImplicit = True
prop.isAdmin = True
prop.isCreateOnly = True
meta.props.add("rn", prop)
prop = PropMeta("str", "status", "status", 3, PropCategory.STATUS)
prop.label = "None"
prop.isImplicit = True
prop.isAdmin = True
prop._addConstant("created", "created", 2)
prop._addConstant("deleted", "deleted", 8)
prop._addConstant("modified", "modified", 4)
meta.props.add("status", prop)
prop = PropMeta("str", "unicastAvg", "unicastAvg", 54294, PropCategory.IMPLICIT_AVG)
prop.label = "host router egress unicast packets average value"
prop.isOper = True
prop.isStats = True
meta.props.add("unicastAvg", prop)
prop = PropMeta("str", "unicastBase", "unicastBase", 54289, PropCategory.IMPLICIT_BASELINE)
prop.label = "host router egress unicast packets baseline"
prop.isOper = True
prop.isStats = True
meta.props.add("unicastBase", prop)
prop = PropMeta("str", "unicastCum", "unicastCum", 54290, PropCategory.IMPLICIT_CUMULATIVE)
prop.label = "host router egress unicast packets cumulative"
prop.isOper = True
prop.isStats = True
meta.props.add("unicastCum", prop)
prop = PropMeta("str", "unicastLast", "unicastLast", 54288, PropCategory.IMPLICIT_LASTREADING)
prop.label = "host router egress unicast packets current value"
prop.isOper = True
prop.isStats = True
meta.props.add("unicastLast", prop)
prop = PropMeta("str", "unicastMax", "unicastMax", 54293, PropCategory.IMPLICIT_MAX)
prop.label = "host router egress unicast packets maximum value"
prop.isOper = True
prop.isStats = True
meta.props.add("unicastMax", prop)
prop = PropMeta("str", "unicastMin", "unicastMin", 54292, PropCategory.IMPLICIT_MIN)
prop.label = "host router egress unicast packets minimum value"
prop.isOper = True
prop.isStats = True
meta.props.add("unicastMin", prop)
prop = PropMeta("str", "unicastPer", "unicastPer", 54291, PropCategory.IMPLICIT_PERIODIC)
prop.label = "host router egress unicast packets periodic"
prop.isOper = True
prop.isStats = True
meta.props.add("unicastPer", prop)
prop = PropMeta("str", "unicastRate", "unicastRate", 54299, PropCategory.IMPLICIT_RATE)
prop.label = "host router egress unicast packets rate"
prop.isOper = True
prop.isStats = True
meta.props.add("unicastRate", prop)
prop = PropMeta("str", "unicastSpct", "unicastSpct", 54295, PropCategory.IMPLICIT_SUSPECT)
prop.label = "host router egress unicast packets suspect count"
prop.isOper = True
prop.isStats = True
meta.props.add("unicastSpct", prop)
prop = PropMeta("str", "unicastThr", "unicastThr", 54296, PropCategory.IMPLICIT_THRESHOLDED)
prop.label = "host router egress unicast packets thresholded flags"
prop.isOper = True
prop.isStats = True
prop.defaultValue = 0
prop.defaultValueStr = "unspecified"
prop._addConstant("avgCrit", "avg-severity-critical", 2199023255552)
prop._addConstant("avgHigh", "avg-crossed-high-threshold", 68719476736)
prop._addConstant("avgLow", "avg-crossed-low-threshold", 137438953472)
prop._addConstant("avgMajor", "avg-severity-major", 1099511627776)
prop._addConstant("avgMinor", "avg-severity-minor", 549755813888)
prop._addConstant("avgRecovering", "avg-recovering", 34359738368)
prop._addConstant("avgWarn", "avg-severity-warning", 274877906944)
prop._addConstant("cumulativeCrit", "cumulative-severity-critical", 8192)
prop._addConstant("cumulativeHigh", "cumulative-crossed-high-threshold", 256)
prop._addConstant("cumulativeLow", "cumulative-crossed-low-threshold", 512)
prop._addConstant("cumulativeMajor", "cumulative-severity-major", 4096)
prop._addConstant("cumulativeMinor", "cumulative-severity-minor", 2048)
prop._addConstant("cumulativeRecovering", "cumulative-recovering", 128)
prop._addConstant("cumulativeWarn", "cumulative-severity-warning", 1024)
prop._addConstant("lastReadingCrit", "lastreading-severity-critical", 64)
prop._addConstant("lastReadingHigh", "lastreading-crossed-high-threshold", 2)
prop._addConstant("lastReadingLow", "lastreading-crossed-low-threshold", 4)
prop._addConstant("lastReadingMajor", "lastreading-severity-major", 32)
prop._addConstant("lastReadingMinor", "lastreading-severity-minor", 16)
prop._addConstant("lastReadingRecovering", "lastreading-recovering", 1)
prop._addConstant("lastReadingWarn", "lastreading-severity-warning", 8)
prop._addConstant("maxCrit", "max-severity-critical", 17179869184)
prop._addConstant("maxHigh", "max-crossed-high-threshold", 536870912)
prop._addConstant("maxLow", "max-crossed-low-threshold", 1073741824)
prop._addConstant("maxMajor", "max-severity-major", 8589934592)
prop._addConstant("maxMinor", "max-severity-minor", 4294967296)
prop._addConstant("maxRecovering", "max-recovering", 268435456)
prop._addConstant("maxWarn", "max-severity-warning", 2147483648)
prop._addConstant("minCrit", "min-severity-critical", 134217728)
prop._addConstant("minHigh", "min-crossed-high-threshold", 4194304)
prop._addConstant("minLow", "min-crossed-low-threshold", 8388608)
prop._addConstant("minMajor", "min-severity-major", 67108864)
prop._addConstant("minMinor", "min-severity-minor", 33554432)
prop._addConstant("minRecovering", "min-recovering", 2097152)
prop._addConstant("minWarn", "min-severity-warning", 16777216)
prop._addConstant("periodicCrit", "periodic-severity-critical", 1048576)
prop._addConstant("periodicHigh", "periodic-crossed-high-threshold", 32768)
prop._addConstant("periodicLow", "periodic-crossed-low-threshold", 65536)
prop._addConstant("periodicMajor", "periodic-severity-major", 524288)
prop._addConstant("periodicMinor", "periodic-severity-minor", 262144)
prop._addConstant("periodicRecovering", "periodic-recovering", 16384)
prop._addConstant("periodicWarn", "periodic-severity-warning", 131072)
prop._addConstant("rateCrit", "rate-severity-critical", 36028797018963968)
prop._addConstant("rateHigh", "rate-crossed-high-threshold", 1125899906842624)
prop._addConstant("rateLow", "rate-crossed-low-threshold", 2251799813685248)
prop._addConstant("rateMajor", "rate-severity-major", 18014398509481984)
prop._addConstant("rateMinor", "rate-severity-minor", 9007199254740992)
prop._addConstant("rateRecovering", "rate-recovering", 562949953421312)
prop._addConstant("rateWarn", "rate-severity-warning", 4503599627370496)
prop._addConstant("trendCrit", "trend-severity-critical", 281474976710656)
prop._addConstant("trendHigh", "trend-crossed-high-threshold", 8796093022208)
prop._addConstant("trendLow", "trend-crossed-low-threshold", 17592186044416)
prop._addConstant("trendMajor", "trend-severity-major", 140737488355328)
prop._addConstant("trendMinor", "trend-severity-minor", 70368744177664)
prop._addConstant("trendRecovering", "trend-recovering", 4398046511104)
prop._addConstant("trendWarn", "trend-severity-warning", 35184372088832)
prop._addConstant("unspecified", None, 0)
meta.props.add("unicastThr", prop)
prop = PropMeta("str", "unicastTr", "unicastTr", 54298, PropCategory.IMPLICIT_TREND)
prop.label = "host router egress unicast packets trend"
prop.isOper = True
prop.isStats = True
meta.props.add("unicastTr", prop)
prop = PropMeta("str", "unicastTrBase", "unicastTrBase", 54297, PropCategory.IMPLICIT_TREND_BASE)
prop.label = "host router egress unicast packets trend baseline"
prop.isOper = True
prop.isStats = True
meta.props.add("unicastTrBase", prop)
# Deployment Meta
meta.deploymentQuery = True
meta.deploymentType = "Ancestor"
meta.deploymentQueryPaths.append(DeploymentPathMeta("FvCtxToHcloudIgw", "From fv:Ctx to hcloud:Igw", "cobra.model.hcloud.Igw"))
meta.deploymentQueryPaths.append(DeploymentPathMeta("FvCtxToHcloudVgw", "From fv:Ctx to hcloud:Vgw", "cobra.model.hcloud.Vgw"))
meta.deploymentQueryPaths.append(DeploymentPathMeta("FvCtxToCloudExtEPg", "From fvCtx (VRF) to cloudExtEPg", "cobra.model.cloud.ExtEPg"))
meta.deploymentQueryPaths.append(DeploymentPathMeta("FvCtxToCloudRegion", "From fvCtx (VRF) to CloudRegion", "cobra.model.cloud.Region"))
meta.deploymentQueryPaths.append(DeploymentPathMeta("FvCtxToHcloudCsr", "From fvCtx (VRF) to hcloudCsr (CSR)", "cobra.model.hcloud.Csr"))
meta.deploymentQueryPaths.append(DeploymentPathMeta("FvCtxToHCloudEndPoint", "From fvCtx (VRF) to hcloud:EndPoint", "cobra.model.hcloud.EndPoint"))
meta.deploymentQueryPaths.append(DeploymentPathMeta("FvCtxToHCloudCtx", "From fvCtx (VRF) to hcloudCtx (VPC)", "cobra.model.hcloud.Ctx"))
meta.deploymentQueryPaths.append(DeploymentPathMeta("FvCtxToCloudCtxProfile", "From fvCtx (VRF) to cloudCtxProfile", "cobra.model.cloud.CtxProfile"))
meta.deploymentQueryPaths.append(DeploymentPathMeta("FvCtxToCloudEPg", "From fvCtx (VRF) to cloud EPg", "cobra.model.cloud.EPg"))
meta.deploymentQueryPaths.append(DeploymentPathMeta("CtxToRegion", "Vrf to cloud Region", "cobra.model.cloud.Region"))
meta.deploymentQueryPaths.append(DeploymentPathMeta("CtxToNwIf", "Private Network to Interface", "cobra.model.nw.If"))
def __init__(self, parentMoOrDn, markDirty=True, **creationProps):
namingVals = []
Mo.__init__(self, parentMoOrDn, markDirty, *namingVals, **creationProps)
# End of package file
# ##################################################
| [
"[email protected]"
] | |
9a61cf0c3df886f81438338b21a69343804579e7 | b9e0381bed124e6f4aaf09378a91d6f7d99ca9ae | /setup.py | eab11340a28c2b7281962b205451fa0a5cf4b9cd | [] | no_license | fanstatic/js.jquery_elastic | b9d944921d4ff92fac69b2154b0c477835645c56 | 8a25992b188ce3c6dbf2103b6e8863c9286858b0 | refs/heads/master | 2020-08-06T02:26:16.335518 | 2011-11-02T14:35:04 | 2011-11-02T14:35:04 | 212,799,961 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,276 | py | from setuptools import setup, find_packages
import os
# The version of the wrapped library is the starting point for the
# version number of the python package.
# In bugfix releases of the python package, add a '-' suffix and an
# incrementing integer.
# For example, a packaging bugfix release version 1.4.4 of the
# js.jquery package would be version 1.4.4-1 .
version = '1.6.12dev'
def read(*rnames):
return open(os.path.join(os.path.dirname(__file__), *rnames)).read()
long_description = (
read('README.txt')
+ '\n' +
read('js', 'jquery_elastic', 'test_jquery_elastic.txt')
+ '\n' +
read('CHANGES.txt'))
setup(
name='js.jquery_elastic',
version=version,
description="Fanstatic packaging of jQuery Elastic",
long_description=long_description,
classifiers=[],
keywords='',
author='Fanstatic Developers',
author_email='[email protected]',
license='BSD',
packages=find_packages(),namespace_packages=['js'],
include_package_data=True,
zip_safe=False,
install_requires=[
'fanstatic',
'js.jquery',
'setuptools',
],
entry_points={
'fanstatic.libraries': [
'jquery_elastic = js.jquery_elastic:library',
],
},
)
| [
"devnull@localhost"
] | devnull@localhost |
3dab1ae060c9e10e1ca242db4acc01adc03ef465 | 152e85c9f718d39a17d7f77889270ea14a4cdd9f | /galleria_videos/apps.py | afe8c476f5316abdf7a7246635e630fb1b6bc495 | [] | no_license | sahandtebyani/galleria | 4bb2d0fe1813eff0319416b9480f648533ae39df | 43451d97c6ecd6378d25413bf4588759ff271d02 | refs/heads/main | 2023-05-25T07:49:23.114250 | 2021-06-13T14:37:11 | 2021-06-13T14:37:11 | 337,804,665 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 104 | py | from django.apps import AppConfig
class GalleriaVideosConfig(AppConfig):
name = 'galleria_videos'
| [
"[email protected]"
] | |
b0c53adb2d8f14b353316719929f4dd0bd405eae | ed381eac1c805be20af9c28e0a1a319c9a71352d | /client/tests/utils/formatting_test.py | 838e65f0cf1944dd082ae1cfc45af15b80c97fe7 | [
"Apache-2.0"
] | permissive | hpec/ok | 2bde333bd47e2b457fbb6da020c82d4bb99d9455 | 492a077a06a36644177092f26c3a003fd86c2595 | refs/heads/master | 2020-12-29T18:48:03.884930 | 2014-11-26T10:39:28 | 2014-11-26T10:39:42 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,321 | py | from client.utils import formatting
import unittest
class PrettyJsonTest(unittest.TestCase):
def assertFormat(self, expect, json):
self.assertEqual(formatting.dedent(expect),
formatting.prettyjson(json))
def testInt(self):
self.assertFormat('42', 42)
def testFloat(self):
self.assertFormat('3.14', 3.14)
def testString_singleLine(self):
self.assertFormat("'hello world'", 'hello world')
def testString_multipleLines(self):
self.assertFormat("""
r\"\"\"
hello
world
\"\"\"
""", "hello\nworld")
def testString_multipleLinesSurroundingNewlines(self):
self.assertFormat("""
r\"\"\"
hello
world
\"\"\"
""", "\nhello\nworld\n")
def testString_rawStringSingleLine(self):
self.assertFormat(r"""
'hello \\ there'
""", r"hello \ there")
def testString_rawStringMultiLine(self):
self.assertFormat("""
r\"\"\"
hello \\
there
\"\"\"
""", r"""
hello \
there
""")
def testList_onlyPrimitives(self):
self.assertFormat("""
[
42,
3.14,
'hello world',
r\"\"\"
hello
world
\"\"\"
]
""", [
42,
3.14,
'hello world',
'hello\nworld'
])
def testList_nestedLists(self):
self.assertFormat("""
[
42,
[
3.14
]
]
""", [
42,
[3.14]
])
def testDict_onlyPrimitives(self):
self.assertFormat("""
{
'answer': 'hello world',
'multi': r\"\"\"
answer
here
\"\"\",
'secret': 42
}
""", {
'answer': 'hello world',
'multi': 'answer\nhere',
'secret': 42,
})
def testDict_nestedDicts(self):
self.assertFormat("""
{
'answer': {
'test': 42
},
'solution': 3.14
}
""", {
'answer': {
'test': 42
},
'solution': 3.14,
})
| [
"[email protected]"
] | |
dbd9a2eea3df8cd33d06c5e73b27aaf6ec14541d | 600283415a6a403b0a12ee8b5b4a3ff5d6aa757a | /json-response-demo/venv/bin/flask | 432a62ab9d22131fbb4e353042308645385c11ca | [] | no_license | pixb/flask-demo | 0f2ef9a8bc6315c92e0aec6cac0acfdcf7bc8f03 | a40686eb25df0ca6379bc409ba34ef0425a863f8 | refs/heads/master | 2023-07-25T06:35:08.364038 | 2023-07-11T16:09:49 | 2023-07-11T16:09:49 | 336,691,847 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 271 | #!/home/pix/dev/code/python/python-web-demo/json-response-demo/venv/bin/python
# -*- coding: utf-8 -*-
import re
import sys
from flask.cli import main
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
sys.exit(main())
| [
"[email protected]"
] | ||
db58d82a549ed036189d914f201f0a265b1fdc64 | 6f00947901426274cb895a21ad5f83c0197b50ba | /e2e/scripts/st_arrow_add_rows.py | e53ab48bc7665ab1864f15dc0b6e83ebde996bb3 | [
"Apache-2.0"
] | permissive | g147/streamlit | f19a796e1bbf83f939f1bcbd3e8f3fd6e64155bb | d54fab097caa3e6dc101eb930cddc0832e05dea9 | refs/heads/develop | 2023-06-18T02:21:22.112118 | 2021-07-10T09:22:27 | 2021-07-10T09:22:27 | 363,459,800 | 1 | 0 | Apache-2.0 | 2021-07-10T09:22:43 | 2021-05-01T16:45:08 | Python | UTF-8 | Python | false | false | 2,580 | py | # Copyright 2018-2021 Streamlit Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import altair as alt
import numpy as np
import pandas as pd
import streamlit as st
df = pd.DataFrame({"a": [1, 2], "b": [3, 4], "c": [5, 6]})
table_element = st._arrow_table(df)
dataframe_element = st._arrow_dataframe(df)
chart_element_1 = st._arrow_line_chart()
chart_element_2 = st._arrow_line_chart(df)
# 4 identical charts, built in different ways.
vega_element_1 = st._arrow_vega_lite_chart(
df,
{
"mark": {"type": "line", "point": True},
"encoding": {
"x": {"field": "a", "type": "quantitative"},
"y": {"field": "b", "type": "quantitative"},
},
},
use_container_width=True,
)
vega_element_2 = st._arrow_vega_lite_chart(
{
"datasets": {"foo": df},
"data": {"name": "foo"},
"mark": {"type": "line", "point": True},
"encoding": {
"x": {"field": "a", "type": "quantitative"},
"y": {"field": "b", "type": "quantitative"},
},
},
use_container_width=True,
)
vega_element_3 = st._arrow_vega_lite_chart(
{
"datasets": {"foo": df},
"data": {"name": "foo"},
"mark": {"type": "line", "point": True},
"encoding": {
"x": {"field": "a", "type": "quantitative"},
"y": {"field": "b", "type": "quantitative"},
},
},
use_container_width=True,
)
altair_element = st._arrow_altair_chart(
alt.Chart(df).mark_line(point=True).encode(x="a", y="b").interactive(),
use_container_width=True,
)
table_element.arrow_add_rows(df)
dataframe_element.arrow_add_rows(df)
chart_element_1.arrow_add_rows(df)
chart_element_2.arrow_add_rows(df)
vega_element_1.arrow_add_rows(df)
vega_element_2.arrow_add_rows(df)
vega_element_3.arrow_add_rows(foo=df)
altair_element.arrow_add_rows(df)
# Test that `add_rows` errors out when the dataframe dimensions don't match.
# This should show an error!
dataframe_element = st._arrow_dataframe(df)
dataframe_element.arrow_add_rows(np.abs(np.random.randn(1, 6)))
| [
"[email protected]"
] | |
35c78ecacb40eb0cd1a443ee04cf16f841c17837 | 531c47c15b97cbcb263ec86821d7f258c81c0aaf | /sdk/servicebus/azure-servicebus/azure/servicebus/aio/_servicebus_receiver_async.py | da6c4b6e72e58c8992d9e046d13400ae7aa7a442 | [
"LicenseRef-scancode-generic-cla",
"LGPL-2.1-or-later",
"MIT"
] | permissive | YijunXieMS/azure-sdk-for-python | be364d3b88204fd3c7d223df23756386ff7a3361 | f779de8e53dbec033f98f976284e6d9491fd60b3 | refs/heads/master | 2021-07-15T18:06:28.748507 | 2020-09-04T15:48:52 | 2020-09-04T15:48:52 | 205,457,088 | 1 | 2 | MIT | 2020-06-16T16:38:15 | 2019-08-30T21:08:55 | Python | UTF-8 | Python | false | false | 24,763 | py | # --------------------------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# --------------------------------------------------------------------------------------------
import asyncio
import collections
import functools
import logging
from typing import Any, TYPE_CHECKING, List, Optional, AsyncIterator
from uamqp import ReceiveClientAsync, types, Message
from uamqp.constants import SenderSettleMode
from ._base_handler_async import BaseHandler, ServiceBusSharedKeyCredential
from ._async_message import ReceivedMessage
from .._base_handler import _convert_connection_string_to_kwargs
from .._common.receiver_mixins import ReceiverMixin
from .._common.constants import (
REQUEST_RESPONSE_UPDATE_DISPOSTION_OPERATION,
REQUEST_RESPONSE_PEEK_OPERATION,
REQUEST_RESPONSE_RECEIVE_BY_SEQUENCE_NUMBER,
REQUEST_RESPONSE_RENEWLOCK_OPERATION,
ReceiveSettleMode,
MGMT_REQUEST_DISPOSITION_STATUS,
MGMT_REQUEST_LOCK_TOKENS,
MGMT_REQUEST_SEQUENCE_NUMBERS,
MGMT_REQUEST_RECEIVER_SETTLE_MODE,
MGMT_REQUEST_FROM_SEQUENCE_NUMBER,
MGMT_REQUEST_MESSAGE_COUNT
)
from .._common import mgmt_handlers
from ._async_utils import create_authentication
if TYPE_CHECKING:
from azure.core.credentials import TokenCredential
_LOGGER = logging.getLogger(__name__)
class ServiceBusReceiver(collections.abc.AsyncIterator, BaseHandler, ReceiverMixin):
"""The ServiceBusReceiver class defines a high level interface for
receiving messages from the Azure Service Bus Queue or Topic Subscription.
The two primary channels for message receipt are `receive()` to make a single request for messages,
and `async for message in receiver:` to continuously receive incoming messages in an ongoing fashion.
:ivar fully_qualified_namespace: The fully qualified host name for the Service Bus namespace.
The namespace format is: `<yournamespace>.servicebus.windows.net`.
:vartype fully_qualified_namespace: str
:ivar entity_path: The path of the entity that the client connects to.
:vartype entity_path: str
:param str fully_qualified_namespace: The fully qualified host name for the Service Bus namespace.
The namespace format is: `<yournamespace>.servicebus.windows.net`.
:param ~azure.core.credentials.TokenCredential credential: The credential object used for authentication which
implements a particular interface for getting tokens. It accepts
:class:`ServiceBusSharedKeyCredential<azure.servicebus.ServiceBusSharedKeyCredential>`, or credential objects
generated by the azure-identity library and objects that implement the `get_token(self, *scopes)` method.
:keyword str queue_name: The path of specific Service Bus Queue the client connects to.
:keyword str topic_name: The path of specific Service Bus Topic which contains the Subscription
the client connects to.
:keyword str subscription_name: The path of specific Service Bus Subscription under the
specified Topic the client connects to.
:keyword mode: The mode with which messages will be retrieved from the entity. The two options
are PeekLock and ReceiveAndDelete. Messages received with PeekLock must be settled within a given
lock period before they will be removed from the queue. Messages received with ReceiveAndDelete
will be immediately removed from the queue, and cannot be subsequently abandoned or re-received
if the client fails to process the message.
The default mode is PeekLock.
:paramtype mode: ~azure.servicebus.ReceiveSettleMode
:keyword float max_wait_time: The timeout in seconds between received messages after which the receiver will
automatically shutdown. The default value is 0, meaning no timeout.
:keyword bool logging_enable: Whether to output network trace logs to the logger. Default is `False`.
:keyword int retry_total: The total number of attempts to redo a failed operation when an error occurs.
Default value is 3.
:keyword transport_type: The type of transport protocol that will be used for communicating with
the Service Bus service. Default is `TransportType.Amqp`.
:paramtype transport_type: ~azure.servicebus.TransportType
:keyword dict http_proxy: HTTP proxy settings. This must be a dictionary with the following
keys: `'proxy_hostname'` (str value) and `'proxy_port'` (int value).
Additionally the following keys may also be present: `'username', 'password'`.
:keyword str user_agent: If specified, this will be added in front of the built-in user agent string.
:keyword int prefetch: The maximum number of messages to cache with each request to the service.
This setting is only for advanced performance tuning. Increasing this value will improve message throughput
performance but increase the chance that messages will expire while they are cached if they're not
processed fast enough.
The default value is 0, meaning messages will be received from the service and processed one at a time.
In the case of prefetch being 0, `ServiceBusReceiver.receive` would try to cache `max_batch_size` (if provided)
within its request to the service.
.. admonition:: Example:
.. literalinclude:: ../samples/async_samples/sample_code_servicebus_async.py
:start-after: [START create_servicebus_receiver_async]
:end-before: [END create_servicebus_receiver_async]
:language: python
:dedent: 4
:caption: Create a new instance of the ServiceBusReceiver.
"""
def __init__(
self,
fully_qualified_namespace: str,
credential: "TokenCredential",
**kwargs: Any
) -> None:
self._message_iter = None # type: Optional[AsyncIterator[ReceivedMessage]]
if kwargs.get("entity_name"):
super(ServiceBusReceiver, self).__init__(
fully_qualified_namespace=fully_qualified_namespace,
credential=credential,
**kwargs
)
else:
queue_name = kwargs.get("queue_name")
topic_name = kwargs.get("topic_name")
subscription_name = kwargs.get("subscription_name")
if queue_name and topic_name:
raise ValueError("Queue/Topic name can not be specified simultaneously.")
if not (queue_name or topic_name):
raise ValueError("Queue/Topic name is missing. Please specify queue_name/topic_name.")
if topic_name and not subscription_name:
raise ValueError("Subscription name is missing for the topic. Please specify subscription_name.")
entity_name = queue_name or topic_name
super(ServiceBusReceiver, self).__init__(
fully_qualified_namespace=fully_qualified_namespace,
credential=credential,
entity_name=str(entity_name),
**kwargs
)
self._populate_attributes(**kwargs)
# Python 3.5 does not allow for yielding from a coroutine, so instead of the try-finally functional wrapper
# trick to restore the timeout, let's use a wrapper class to maintain the override that may be specified.
class _IterContextualWrapper(collections.abc.AsyncIterator):
def __init__(self, receiver, max_wait_time=None):
self.receiver = receiver
self.max_wait_time = max_wait_time
async def __anext__(self):
original_timeout = None
# This is not threadsafe, but gives us a way to handle if someone passes
# different max_wait_times to different iterators and uses them in concert.
if self.max_wait_time and self.receiver and self.receiver._handler:
original_timeout = self.receiver._handler._timeout
self.receiver._handler._timeout = self.max_wait_time * 1000
try:
return await self.receiver.__anext__()
finally:
if original_timeout:
self.receiver._handler._timeout = original_timeout
def __aiter__(self):
return self._IterContextualWrapper(self)
async def __anext__(self):
self._check_live()
while True:
try:
return await self._do_retryable_operation(self._iter_next)
except StopAsyncIteration:
self._message_iter = None
raise
async def _iter_next(self):
await self._open()
if not self._message_iter:
self._message_iter = self._handler.receive_messages_iter_async()
uamqp_message = await self._message_iter.__anext__()
message = self._build_message(uamqp_message, ReceivedMessage)
return message
def _create_handler(self, auth):
self._handler = ReceiveClientAsync(
self._get_source(),
auth=auth,
debug=self._config.logging_enable,
properties=self._properties,
error_policy=self._error_policy,
client_name=self._name,
on_attach=self._on_attach,
auto_complete=False,
encoding=self._config.encoding,
receive_settle_mode=self._mode.value,
send_settle_mode=SenderSettleMode.Settled if self._mode == ReceiveSettleMode.ReceiveAndDelete else None,
timeout=self._max_wait_time * 1000 if self._max_wait_time else 0,
prefetch=self._prefetch,
keep_alive_interval=self._config.keep_alive,
shutdown_after_timeout=False
)
async def _open(self):
# pylint: disable=protected-access
if self._running:
return
if self._handler and not self._handler._shutdown:
await self._handler.close_async()
auth = None if self._connection else (await create_authentication(self))
self._create_handler(auth)
try:
await self._handler.open_async(connection=self._connection)
while not await self._handler.client_ready_async():
await asyncio.sleep(0.05)
self._running = True
except:
await self.close()
raise
async def close(self):
# type: () -> None
await super(ServiceBusReceiver, self).close()
self._message_iter = None
async def _receive(self, max_batch_size=None, timeout=None):
# type: (Optional[int], Optional[float]) -> List[ReceivedMessage]
# pylint: disable=protected-access
await self._open()
amqp_receive_client = self._handler
received_messages_queue = amqp_receive_client._received_messages
max_batch_size = max_batch_size or self._prefetch
timeout_ms = 1000 * (timeout or self._max_wait_time) if (timeout or self._max_wait_time) else 0
abs_timeout_ms = amqp_receive_client._counter.get_current_ms() + timeout_ms if timeout_ms else 0
batch = [] # type: List[Message]
while not received_messages_queue.empty() and len(batch) < max_batch_size:
batch.append(received_messages_queue.get())
received_messages_queue.task_done()
if len(batch) >= max_batch_size:
return [self._build_message(message) for message in batch]
# Dynamically issue link credit if max_batch_size > 1 when the prefetch is the default value 1
if max_batch_size and self._prefetch == 1 and max_batch_size > 1:
link_credit_needed = max_batch_size - len(batch)
await amqp_receive_client.message_handler.reset_link_credit_async(link_credit_needed)
first_message_received = expired = False
receiving = True
while receiving and not expired and len(batch) < max_batch_size:
while receiving and received_messages_queue.qsize() < max_batch_size:
if abs_timeout_ms and amqp_receive_client._counter.get_current_ms() > abs_timeout_ms:
expired = True
break
before = received_messages_queue.qsize()
receiving = await amqp_receive_client.do_work_async()
received = received_messages_queue.qsize() - before
if not first_message_received and received_messages_queue.qsize() > 0 and received > 0:
# first message(s) received, continue receiving for some time
first_message_received = True
abs_timeout_ms = amqp_receive_client._counter.get_current_ms() + \
self._further_pull_receive_timeout_ms
while not received_messages_queue.empty() and len(batch) < max_batch_size:
batch.append(received_messages_queue.get())
received_messages_queue.task_done()
return [self._build_message(message, ReceivedMessage) for message in batch]
async def _settle_message(self, settlement, lock_tokens, dead_letter_details=None):
message = {
MGMT_REQUEST_DISPOSITION_STATUS: settlement,
MGMT_REQUEST_LOCK_TOKENS: types.AMQPArray(lock_tokens)}
self._populate_message_properties(message)
if dead_letter_details:
message.update(dead_letter_details)
return await self._mgmt_request_response_with_retry(
REQUEST_RESPONSE_UPDATE_DISPOSTION_OPERATION,
message,
mgmt_handlers.default
)
async def _renew_locks(self, *lock_tokens):
message = {MGMT_REQUEST_LOCK_TOKENS: types.AMQPArray(lock_tokens)}
return await self._mgmt_request_response_with_retry(
REQUEST_RESPONSE_RENEWLOCK_OPERATION,
message,
mgmt_handlers.lock_renew_op
)
def get_streaming_message_iter(self, max_wait_time: float = None) -> AsyncIterator[ReceivedMessage]:
"""Receive messages from an iterator indefinitely, or if a max_wait_time is specified, until
such a timeout occurs.
:param float max_wait_time: Maximum time to wait in seconds for the next message to arrive.
If no messages arrive, and no timeout is specified, this call will not return
until the connection is closed. If specified, and no messages arrive for the
timeout period, the iterator will stop.
:rtype AsyncIterator[ReceivedMessage]
.. admonition:: Example:
.. literalinclude:: ../samples/async_samples/sample_code_servicebus.py
:start-after: [START receive_forever_async]
:end-before: [END receive_forever_async]
:language: python
:dedent: 4
:caption: Receive indefinitely from an iterator in streaming fashion.
"""
return self._IterContextualWrapper(self, max_wait_time)
@classmethod
def from_connection_string(
cls,
conn_str: str,
**kwargs: Any
) -> "ServiceBusReceiver":
"""Create a ServiceBusReceiver from a connection string.
:param str conn_str: The connection string of a Service Bus.
:keyword str queue_name: The path of specific Service Bus Queue the client connects to.
:keyword str topic_name: The path of specific Service Bus Topic which contains the Subscription
the client connects to.
:keyword str subscription_name: The path of specific Service Bus Subscription under the
specified Topic the client connects to.
:keyword mode: The mode with which messages will be retrieved from the entity. The two options
are PeekLock and ReceiveAndDelete. Messages received with PeekLock must be settled within a given
lock period before they will be removed from the queue. Messages received with ReceiveAndDelete
will be immediately removed from the queue, and cannot be subsequently abandoned or re-received
if the client fails to process the message.
The default mode is PeekLock.
:paramtype mode: ~azure.servicebus.ReceiveSettleMode
:keyword float max_wait_time: The timeout in seconds between received messages after which the receiver will
automatically shutdown. The default value is 0, meaning no timeout.
:keyword bool logging_enable: Whether to output network trace logs to the logger. Default is `False`.
:keyword int retry_total: The total number of attempts to redo a failed operation when an error occurs.
Default value is 3.
:keyword transport_type: The type of transport protocol that will be used for communicating with
the Service Bus service. Default is `TransportType.Amqp`.
:paramtype transport_type: ~azure.servicebus.TransportType
:keyword dict http_proxy: HTTP proxy settings. This must be a dictionary with the following
keys: `'proxy_hostname'` (str value) and `'proxy_port'` (int value).
Additionally the following keys may also be present: `'username', 'password'`.
:keyword str user_agent: If specified, this will be added in front of the built-in user agent string.
:keyword int prefetch: The maximum number of messages to cache with each request to the service.
This setting is only for advanced performance tuning. Increasing this value will improve message throughput
performance but increase the chance that messages will expire while they are cached if they're not
processed fast enough.
The default value is 0, meaning messages will be received from the service and processed one at a time.
In the case of prefetch being 0, `ServiceBusReceiver.receive` would try to cache `max_batch_size` (if provided)
within its request to the service.
:rtype: ~azure.servicebus.aio.ServiceBusReceiver
:raises ~azure.servicebus.ServiceBusAuthenticationError: Indicates an issue in token/identity validity.
:raises ~azure.servicebus.ServiceBusAuthorizationError: Indicates an access/rights related failure.
.. admonition:: Example:
.. literalinclude:: ../samples/async_samples/sample_code_servicebus_async.py
:start-after: [START create_servicebus_receiver_from_conn_str_async]
:end-before: [END create_servicebus_receiver_from_conn_str_async]
:language: python
:dedent: 4
:caption: Create a new instance of the ServiceBusReceiver from connection string.
"""
constructor_args = _convert_connection_string_to_kwargs(
conn_str,
ServiceBusSharedKeyCredential,
**kwargs
)
if kwargs.get("queue_name") and kwargs.get("subscription_name"):
raise ValueError("Queue entity does not have subscription.")
if kwargs.get("topic_name") and not kwargs.get("subscription_name"):
raise ValueError("Subscription name is missing for the topic. Please specify subscription_name.")
return cls(**constructor_args)
async def receive_messages(self, max_batch_size=None, max_wait_time=None):
# type: (int, float) -> List[ReceivedMessage]
"""Receive a batch of messages at once.
This approach is optimal if you wish to process multiple messages simultaneously, or
perform an ad-hoc receive as a single call.
Note that the number of messages retrieved in a single batch will be dependent on
whether `prefetch` was set for the receiver. If `prefetch` is not set for the receiver, the receiver would
try to cache max_batch_size (if provided) messages within the request to the service.
This call will prioritize returning quickly over meeting a specified batch size, and so will
return as soon as at least one message is received and there is a gap in incoming messages regardless
of the specified batch size.
:param int max_batch_size: Maximum number of messages in the batch. Actual number
returned will depend on prefetch size and incoming stream rate.
:param float max_wait_time: Maximum time to wait in seconds for the first message to arrive.
If no messages arrive, and no timeout is specified, this call will not return
until the connection is closed. If specified, and no messages arrive within the
timeout period, an empty list will be returned.
:rtype: list[~azure.servicebus.aio.ReceivedMessage]
.. admonition:: Example:
.. literalinclude:: ../samples/async_samples/sample_code_servicebus_async.py
:start-after: [START receive_async]
:end-before: [END receive_async]
:language: python
:dedent: 4
:caption: Receive messages from ServiceBus.
"""
self._check_live()
return await self._do_retryable_operation(
self._receive,
max_batch_size=max_batch_size,
timeout=max_wait_time,
require_timeout=True
)
async def receive_deferred_messages(self, sequence_numbers):
# type: (List[int]) -> List[ReceivedMessage]
"""Receive messages that have previously been deferred.
When receiving deferred messages from a partitioned entity, all of the supplied
sequence numbers must be messages from the same partition.
:param list[int] sequence_numbers: A list of the sequence numbers of messages that have been
deferred.
:rtype: list[~azure.servicebus.aio.ReceivedMessage]
.. admonition:: Example:
.. literalinclude:: ../samples/async_samples/sample_code_servicebus_async.py
:start-after: [START receive_defer_async]
:end-before: [END receive_defer_async]
:language: python
:dedent: 4
:caption: Receive deferred messages from ServiceBus.
"""
self._check_live()
if not sequence_numbers:
raise ValueError("At least one sequence number must be specified.")
await self._open()
try:
receive_mode = self._mode.value.value
except AttributeError:
receive_mode = int(self._mode)
message = {
MGMT_REQUEST_SEQUENCE_NUMBERS: types.AMQPArray([types.AMQPLong(s) for s in sequence_numbers]),
MGMT_REQUEST_RECEIVER_SETTLE_MODE: types.AMQPuInt(receive_mode)
}
self._populate_message_properties(message)
handler = functools.partial(mgmt_handlers.deferred_message_op,
mode=self._mode,
message_type=ReceivedMessage,
receiver=self)
messages = await self._mgmt_request_response_with_retry(
REQUEST_RESPONSE_RECEIVE_BY_SEQUENCE_NUMBER,
message,
handler
)
return messages
async def peek_messages(self, message_count=1, sequence_number=0):
"""Browse messages currently pending in the queue.
Peeked messages are not removed from queue, nor are they locked. They cannot be completed,
deferred or dead-lettered.
:param int message_count: The maximum number of messages to try and peek. The default
value is 1.
:param int sequence_number: A message sequence number from which to start browsing messages.
:rtype: list[~azure.servicebus.PeekMessage]
.. admonition:: Example:
.. literalinclude:: ../samples/async_samples/sample_code_servicebus_async.py
:start-after: [START peek_messages_async]
:end-before: [END peek_messages_async]
:language: python
:dedent: 4
:caption: Peek messages in the queue.
"""
self._check_live()
if not sequence_number:
sequence_number = self._last_received_sequenced_number or 1
if int(message_count) < 1:
raise ValueError("count must be 1 or greater.")
if int(sequence_number) < 1:
raise ValueError("start_from must be 1 or greater.")
await self._open()
message = {
MGMT_REQUEST_FROM_SEQUENCE_NUMBER: types.AMQPLong(sequence_number),
MGMT_REQUEST_MESSAGE_COUNT: message_count
}
self._populate_message_properties(message)
return await self._mgmt_request_response_with_retry(
REQUEST_RESPONSE_PEEK_OPERATION,
message,
mgmt_handlers.peek_op
)
| [
"[email protected]"
] | |
ac00e754fe6dc5a4a50fc219b4646135d18ffb8d | f93d36a8884a69b9f5189fee91af308bb60e2418 | /review/amagnuss/coffee_points.py | de3e925855da41aba2ddb1f550e9cc5fda7d27d5 | [] | no_license | adamlubitz/pratt-savi-810-2018-10 | 1aa1d2c5032f3d68a70d85245da4bc287594e5c1 | b66a699c7c1b37059f9d8cce4d81c0f89508424a | refs/heads/master | 2022-01-08T09:43:10.909984 | 2018-12-08T20:30:21 | 2018-12-08T20:30:21 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,362 | py | import arcpy
import pandas as pd
import json
arcpy.env.overwriteOutput = True
wd = 'Z:/Windows/GitHub/pratt-savi-810-2018-10/projects_scratch/amagnuss'
# Set the local variables
in_table = '{}/CoffeePoints_2.csv'.format(wd)
List_of_Countries = ['Costa Rica', 'Guatemala', 'Mexico', 'Nicaragua', 'Honduras', 'El Salvador']
# Set dataframe, save separate new csvs for CAM countries
df = pd.read_csv(in_table, encoding='latin-1')
df_CAM = df[df['Country'].isin(List_of_Countries)]
for i in df_CAM['Country'].unique():
dfc = df_CAM[df['Country'] == i]
out_table = in_table.replace('.csv', '_{}.csv'.format(i))
dfc.to_csv(out_table, index=False, encoding='utf-8')
print df_CAM.head(500)
# variables for xy plotting
for s in List_of_Countries:
in_table_xy = '{}/CoffeePoints_2_'.format(wd) + s + '.csv'
out_feature_class = 'coffee_points'
x_coords = "Longitude"
y_coords = "Latitude"
out_layer = 'coffeePoints' + s + '_CAM_lyr'
saved_layer = '{}/CoffeePoints_{}.csv'.format(wd, s)
# Set Arc workspace
arcpy.env.workspace = '{}/CoffeeData.gdb'.format(wd) # probably want to add create file geodatabase
arcpy.MakeXYEventLayer_management(
in_table_xy,
x_coords,
y_coords,
out_layer,
)
# reprojecting into NA Albers Equal Area
# first shapefiles
# Replace a layer/table view name with a path to a dataset (which can be a layer file)
# or create the layer/table view within the script
coffee_cfg = '{}/coffee_cfg.json'.format(wd)
def read_config(config_json):
with open(config_json) as f:
data = json.load(f)
return data
d = read_config(coffee_cfg)
print(
d['data']['out_cs']
)
proj_filename = '{}/projected/'.format(wd) + s + '_proj'
out_cs = d['data']['out_cs']
transform = ''
in_cs = d['data']['in_cs']
shp_preserve = 'NO_PRESERVE_SHAPE'
max_dev = ''
vertical = 'NO_VERTICAL'
arcpy.Project_management(
out_layer,
proj_filename,
out_cs,
transform,
in_cs,
shp_preserve,
max_dev,
vertical,
)
arcpy.CopyFeatures_management(out_layer, saved_layer) # One of these last few things may be unnecessary
# Save layer to file
arcpy.SaveToLayerFile_management(out_layer, saved_layer)
| [
"[email protected]"
] | |
1df8f7c1d3cab02ad4cbac3c7f8197322180a3e9 | bd553d50a233c043878e4209e0376eab1eb7176f | /Examples/11SampleModules/Threading/threadingEx2.py | 84b4b8614b152a038ab3a74216f7b1e9f774e443 | [] | no_license | jainendrak/python-training | 3610434926774bca9c711a5e6c675d3ce28893ef | 336221aab9aaa9624ad0f5ad046c44195105249e | refs/heads/master | 2020-05-27T13:59:17.656236 | 2019-05-27T06:21:46 | 2019-05-27T06:21:46 | 188,648,975 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 1,200 | py | import threading, time
exitFlag = 0
class myThread(threading.Thread):
def __init__(self, threadID, name, counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
def run(self):
print("Starting " + self.name)
print_time(self.name, self.counter, 5)
print("Exiting " + self.name)
def print_time(threadName, delay, counter):
while counter:
if exitFlag:
thread.exit()
time.sleep(delay)
print("%s: %s" % (threadName, time.ctime(time.time())))
counter -= 1
start=time.time()
# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
thread3 = myThread(2, "Thread-3", 1)
#setDaemon()
#thread1.setDaemon(True)
#thread2.setDaemon(True)
#thread3.setDaemon(True)
# Start new Threads
thread1.start()
thread2.start()
thread3.start()
while(threading.activeCount()>1):
#print("Number of active threads are: ",threading.activeCount())
time.sleep(1)
end=time.time()-start
print("Time taken: ",end)
print("Exiting ",threading.currentThread().getName())
| [
"[email protected]"
] | |
d7dfbc16b17661a8706b27969577d5d8b7cf03e0 | 1b16a85abcac93fdab96cb3d952505f39dcb98b0 | /tests/testproject/multidb/tests/test_models.py | 1c0c2da1a0b053684244c0c1498789dfdeb883f8 | [
"BSD-3-Clause"
] | permissive | playpauseandstop/tddspry | 6bb4ef3d3c1fed100acd6b1cff0f632f264ce6dd | 0a0f9242238d2d81a375dcb4b8c32b25612edf42 | refs/heads/master | 2016-09-05T18:50:47.687939 | 2011-03-01T15:01:10 | 2011-03-01T15:01:10 | 136,525 | 12 | 1 | null | null | null | null | UTF-8 | Python | false | false | 2,349 | py | from tddspry.django import TestCase
from tddspry.django.helpers import EMAIL, PASSWORD, USERNAME
from django.contrib.auth.models import User
class TestModels(TestCase):
multidb = True
def setup(self):
self.model = User
self.manager = self.model.objects.using('legacy')
self.kwargs = {'username': USERNAME,
'password': PASSWORD,
'email': EMAIL}
self.sgrawk = {'username': USERNAME[::-1],
'password': PASSWORD[::-1],
'email': EMAIL[::-1]}
def test_using_keyword(self):
self.assert_count(self.model, 0)
self.assert_count(self.model, 0, using='legacy')
self.assert_create(self.model, using='legacy', **self.kwargs)
self.assert_count(self.model, 0)
self.assert_not_count(self.model, 0, using='legacy')
self.assert_count(self.model, 1, using='legacy')
for key, value in self.kwargs.items():
self.assert_not_read(self.model, **{key: value})
for key, value in self.kwargs.items():
self.assert_read(self.model, using='legacy', **{key: value})
try:
self.assert_update(self.model, **self.sgrawk)
except AssertionError:
pass
else:
assert False, 'Any %r model should be exist in default ' \
'database.' % self.model
self.assert_update(self.model, using='legacy', **self.sgrawk)
self.assert_not_read(self.model, **self.kwargs)
self.assert_not_read(self.model, using='legacy', **self.kwargs)
self.assert_delete(self.model)
self.assert_delete(self.model, using='legacy')
self.assert_count(self.model, 0)
self.assert_count(self.model, 0, using='legacy')
def test_using_manager(self):
self.assert_count(self.manager, 0)
self.assert_create(self.manager, **self.kwargs)
self.assert_not_count(self.manager, 0)
self.assert_count(self.manager, 1)
for key, value in self.kwargs.items():
self.assert_read(self.manager, **{key: value})
self.assert_update(self.manager, **self.sgrawk)
self.assert_not_read(self.manager, **self.kwargs)
self.assert_delete(self.manager)
self.assert_count(self.manager, 0)
| [
"[email protected]"
] | |
0853dbf53c7d4fc01a324eb039cd10c345befae6 | bdb0b0ee38078bc7c19ca9d953f9dfd222ea8479 | /ansible/roles/hotspot/templates/boot.py | 547f3a63a397f6a9406d2f256350432ecbaffb40 | [] | no_license | mrc-toader/setup | 73b2bc69a69f5ba8adc51b2a85fac411bc21bb02 | 0ed8037f74a78f15c6ee138eb2e399e8771b5298 | refs/heads/master | 2021-01-21T07:30:04.181983 | 2017-08-29T11:38:04 | 2017-08-29T11:38:04 | 91,614,785 | 0 | 0 | null | 2017-05-17T19:54:52 | 2017-05-17T19:54:52 | null | UTF-8 | Python | false | false | 3,524 | py | #!/usr/bin/env python3
import sys
import re
from pathlib import Path
import subprocess
RUN_DIR = Path('/var/local/hotspot/run')
SUPERVISOR_DIR = Path('/etc/supervisor/conf.d')
HOSTAPD_CONFIG_TEMPLATE = """\
interface={interface}
ieee80211d=1
country_code={country_code}
ieee80211n=1
wmm_enabled=1
driver=nl80211
hw_mode=g
ssid={ssid}
channel={channel}
auth_algs=1
wpa=2
wpa_key_mgmt=WPA-PSK
rsn_pairwise=CCMP
wpa_passphrase={passphrase}
"""
HOSTAPD_SUPERVISOR_TEMPLATE = """\
[program:{program_name}]
command = /usr/sbin/hostapd -d {hostapd_conf_path}
autostart = false
startsecs = 3
"""
DNSMASQ_CONFIG_TEMPLATE = """\
interface=br0
bind-interfaces
domain-needed
bogus-priv
no-resolv
no-poll
no-hosts
server=8.8.8.8
address=/liquid/{liquid_address}
dhcp-range={dhcp_range},12h
"""
DNSMASQ_SUPERVISOR_TEMPLATE = """\
[program:dnsmasq]
command = /usr/sbin/dnsmasq --keep-in-foreground -C {dnsmasq_conf_path}
autostart = false
startsecs = 3
"""
def find_wireless_interfaces():
iwconfig = (
subprocess
.check_output(['iwconfig'], stderr=subprocess.DEVNULL)
.decode('latin1')
)
for line in iwconfig.splitlines():
m = re.match('(\w+)', line)
if m:
yield m.group(1)
def boot_hostapd(interface):
hostapd_conf_path = RUN_DIR / 'hostapd-{}.conf'.format(interface)
supervisor_conf_path = SUPERVISOR_DIR / 'hostapd-{}.conf'.format(interface)
program_name = 'hostapd-' + interface
hostapd_conf = HOSTAPD_CONFIG_TEMPLATE.format(
interface=interface,
country_code='RO',
channel='6',
ssid='liquid',
passphrase='chocolate',
)
with hostapd_conf_path.open('wt', encoding='utf8') as f:
f.write(hostapd_conf)
supervisor_conf = HOSTAPD_SUPERVISOR_TEMPLATE.format(
program_name=program_name,
hostapd_conf_path=hostapd_conf_path,
)
with supervisor_conf_path.open('wt', encoding='utf8') as f:
f.write(supervisor_conf)
subprocess.check_call(['supervisorctl', 'update'])
subprocess.check_call(['supervisorctl', 'start', program_name])
subprocess.check_call(['brctl', 'addif', 'br0', interface])
def boot_dnsmasq(liquid_address, dhcp_range):
dnsmasq_conf_path = RUN_DIR / 'dnsmasq.conf'
supervisor_conf_path = SUPERVISOR_DIR / 'dnsmasq.conf'
dnsmasq_conf = DNSMASQ_CONFIG_TEMPLATE.format(
dhcp_range=dhcp_range,
liquid_address=liquid_address,
)
with dnsmasq_conf_path.open('wt', encoding='utf8') as f:
f.write(dnsmasq_conf)
supervisor_conf = DNSMASQ_SUPERVISOR_TEMPLATE.format(
dnsmasq_conf_path=dnsmasq_conf_path,
)
with supervisor_conf_path.open('wt', encoding='utf8') as f:
f.write(supervisor_conf)
subprocess.check_call(['supervisorctl', 'update'])
subprocess.check_call(['supervisorctl', 'start', 'dnsmasq'])
def main():
subprocess.check_call(['rm', '-rf', str(RUN_DIR)])
subprocess.check_call(['rm', '-f', str(SUPERVISOR_DIR / 'hostapd-*.conf')])
subprocess.check_call(['mkdir', '-p', str(RUN_DIR)])
subprocess.check_call(['brctl', 'addbr', 'br0'])
subprocess.check_call([
'ifconfig', 'br0',
'10.102.0.1', 'netmask', '255.255.255.0',
])
interfaces = list(find_wireless_interfaces())
if not interfaces:
print("no wireless interfaces found", file=sys.stderr)
return
boot_hostapd(interfaces[0])
boot_dnsmasq('10.102.0.1', '10.102.0.100,10.102.0.200')
if __name__ == '__main__':
main()
| [
"[email protected]"
] | |
5620b8d8fc82aca9f6796b032371851cc93269f0 | 96bfcec63be5e8f3a2edcd8f8395d309ff61aeaa | /ex20 functions and files/ex20.py | 60953e106f5f1a11cb71c8c67f4e7fc2741462f9 | [] | no_license | KlausQIU/learnpythonhardway | cbc3ba64c4a70fafe1b0234196023b44eff2a24a | 614e09370c654f79cbc408d09eaa8a47d1b4e637 | refs/heads/master | 2021-01-17T06:07:15.735307 | 2016-07-03T12:13:26 | 2016-07-03T12:13:26 | 52,967,154 | 2 | 0 | null | null | null | null | UTF-8 | Python | false | false | 597 | py | # -*- coding : utf-8 -*-
from sys import argv
script, input_file = argv
def print_all(f):
print f.read()
def rewind(f):
f.seek(0)
def print_a_line(line_count,f):
print line_count,f.readline()
current_file = open(input_file)
print "First,let's print the whole file:\n"
print_all(current_file)
print "Now let's rewind,kind of like a tape."
rewind(current_file)
print "let's print three lines"
current_line = 1
print_a_line(current_line,current_file)
current_line = current_line + 1
print_a_line(current_line,current_file)
current_line = current_line + 1
print_a_line(current_line,current_file) | [
"[email protected]"
] | |
e78b4647681a75c4ad6ad69ed99793457147a7a0 | 08cfc4fb5f0d2f11e4e226f12520a17c5160f0a2 | /kubernetes/client/models/v1_namespace_list.py | 38055a9cd702e920afd279ea4003a19544378baf | [
"Apache-2.0"
] | permissive | ex3cv/client-python | 5c6ee93dff2424828d064b5a2cdbed3f80b74868 | 2c0bed9c4f653472289324914a8f0ad4cbb3a1cb | refs/heads/master | 2021-07-12T13:37:26.049372 | 2017-10-16T20:19:01 | 2017-10-16T20:19:01 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 6,689 | py | # coding: utf-8
"""
Kubernetes
No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
OpenAPI spec version: v1.8.1
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
from pprint import pformat
from six import iteritems
import re
class V1NamespaceList(object):
"""
NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually.
"""
"""
Attributes:
swagger_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
"""
swagger_types = {
'api_version': 'str',
'items': 'list[V1Namespace]',
'kind': 'str',
'metadata': 'V1ListMeta'
}
attribute_map = {
'api_version': 'apiVersion',
'items': 'items',
'kind': 'kind',
'metadata': 'metadata'
}
def __init__(self, api_version=None, items=None, kind=None, metadata=None):
"""
V1NamespaceList - a model defined in Swagger
"""
self._api_version = None
self._items = None
self._kind = None
self._metadata = None
self.discriminator = None
if api_version is not None:
self.api_version = api_version
self.items = items
if kind is not None:
self.kind = kind
if metadata is not None:
self.metadata = metadata
@property
def api_version(self):
"""
Gets the api_version of this V1NamespaceList.
APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources
:return: The api_version of this V1NamespaceList.
:rtype: str
"""
return self._api_version
@api_version.setter
def api_version(self, api_version):
"""
Sets the api_version of this V1NamespaceList.
APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources
:param api_version: The api_version of this V1NamespaceList.
:type: str
"""
self._api_version = api_version
@property
def items(self):
"""
Gets the items of this V1NamespaceList.
Items is the list of Namespace objects in the list. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/
:return: The items of this V1NamespaceList.
:rtype: list[V1Namespace]
"""
return self._items
@items.setter
def items(self, items):
"""
Sets the items of this V1NamespaceList.
Items is the list of Namespace objects in the list. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/
:param items: The items of this V1NamespaceList.
:type: list[V1Namespace]
"""
if items is None:
raise ValueError("Invalid value for `items`, must not be `None`")
self._items = items
@property
def kind(self):
"""
Gets the kind of this V1NamespaceList.
Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds
:return: The kind of this V1NamespaceList.
:rtype: str
"""
return self._kind
@kind.setter
def kind(self, kind):
"""
Sets the kind of this V1NamespaceList.
Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds
:param kind: The kind of this V1NamespaceList.
:type: str
"""
self._kind = kind
@property
def metadata(self):
"""
Gets the metadata of this V1NamespaceList.
Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds
:return: The metadata of this V1NamespaceList.
:rtype: V1ListMeta
"""
return self._metadata
@metadata.setter
def metadata(self, metadata):
"""
Sets the metadata of this V1NamespaceList.
Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds
:param metadata: The metadata of this V1NamespaceList.
:type: V1ListMeta
"""
self._metadata = metadata
def to_dict(self):
"""
Returns the model properties as a dict
"""
result = {}
for attr, _ in iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
return result
def to_str(self):
"""
Returns the string representation of the model
"""
return pformat(self.to_dict())
def __repr__(self):
"""
For `print` and `pprint`
"""
return self.to_str()
def __eq__(self, other):
"""
Returns true if both objects are equal
"""
if not isinstance(other, V1NamespaceList):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""
Returns true if both objects are not equal
"""
return not self == other
| [
"[email protected]"
] | |
56f0a368b55894c38b8c997a2f1e18310ad58685 | f048d9a7a7464461ab81086e2f0dd0e4568364ad | /scripts/python/decompress-all-strokes.py | a3c4630986b073876f4ce9cf37326dfdfab5a5f6 | [] | no_license | JasonGross/characters | 66eb547606a6d3d110e7a8270ebeb8c563d2877c | b3213fa743789531c103134e087f3110cca005bc | refs/heads/master | 2021-06-03T02:10:32.981640 | 2020-09-04T17:25:14 | 2020-09-04T17:25:14 | 912,795 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 209 | py | #!/usr/bin/python
# Filename: decompress-all-strokes.py
from stroke_compression import decompress_all_strokes_in_current_directory
if __name__ == '__main__':
decompress_all_strokes_in_current_directory()
| [
"[email protected]"
] | |
492b95d732ad5a91cd8271b3111eee8585f24ded | 52b5773617a1b972a905de4d692540d26ff74926 | /.history/binaryTree_20200623143454.py | 3cd8c4c57c7767dc31c557b3ff860968148374d2 | [] | no_license | MaryanneNjeri/pythonModules | 56f54bf098ae58ea069bf33f11ae94fa8eedcabc | f4e56b1e4dda2349267af634a46f6b9df6686020 | refs/heads/master | 2022-12-16T02:59:19.896129 | 2020-09-11T12:05:22 | 2020-09-11T12:05:22 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,213 | py | # define node class
class Node(object):
# constructor
def __init__(self,value):
self.value = value
self.left = None
self.right = None
# define binary tree class
class BinaryTree(object):
def __init__(self,root):
# converting data
self.root = Node(root)
def print_tree(self,traversal_type):
if traversal_type == "preorder":
return self.preorder_print(tree.root," ")
elif traversal_type == "inorder":
return self.inorder_print (tree.root,"",0)
elif traversal_type == "postorder":
return self.postorder_print(tree.root," ")
else:
print("Traversal type" + str(traversal_type) + "is not supported.")
return False
# root -->left--->right(preorder)
def preorder_print(self,start,traversal):
if start:
traversal += (str(start.value) + "-")
# calling the function recursively
traversal = self.preorder_print(start.left,traversal)
traversal = self.preorder_print(start.right,traversal)
return traversal
# left - root -right
def inorder_print(self,start,traversal,count):
if start:
traversal = self.inorder_print(start.left,traversal,count =count+1)
traversal += (str(start.value) + "-")
traversal = self.inorder_print(start.right,traversal,,count +=1)
return traversal,count
# left ->right -> root
def postorder_print(self,start,traversal):
if start:
traversal = self.postorder_print(start.left,traversal)
traversal = self.postorder_print(start.right,traversal)
traversal +=(str(start.value) + "-" )
return traversal
# 1 is root
# creating left child
'''
1
# / \
2 3
/ \
4 5
'''
tree = BinaryTree(1)
tree.root.left = Node(2)
tree.root.right = Node(3)
tree.root.left.left = Node(4)
tree.root.left.right = Node(5)
tree.root.right.right = Node(7)
tree.root.right.left = Node(6)
print(tree.print_tree("preorder"))
print(tree.print_tree("inorder"))
print(tree.print_tree("postorder")) | [
"[email protected]"
] | |
f12b1a7eb0c624bcb02269c297d7d2d038aff21b | 330ba6024e2728ec2476ce2d9f8e6be20c60ed67 | /assignments/hw04/listutils.py | ca77bd6bfdffe6cba5ec065b59a7aab54fbf2bfb | [] | no_license | foureyes/csci-ua.0479-spring2021-001 | ec008e797b569476cce7b062f2469d6dea56d670 | f7ee0f69c2e9150134f41f39676807e4f776f96e | refs/heads/main | 2023-06-27T15:44:38.192216 | 2021-08-01T17:35:55 | 2021-08-01T17:35:55 | 330,051,703 | 1 | 1 | null | null | null | null | UTF-8 | Python | false | false | 21 | py | """
listutils.py
"""
| [
"[email protected]"
] | |
afc8f105c4cee0a4c52c266499b55b066ba80353 | 1092d65f98c695756d8d1697da3f8c5253c8922f | /navx/_impl/imuregisters.py | ef123235461f623c7fdf8ab90caf7f264437da9e | [
"MIT"
] | permissive | M-Shadow/robotpy-navx | 28830536a7a3c497ce75bd765d76d79de9f1ba5d | b59a1d0c38c73541c139023a4ac347cd69ed2bad | refs/heads/master | 2020-08-20T11:54:53.221611 | 2019-10-18T13:36:16 | 2019-10-18T13:36:16 | 216,019,630 | 0 | 0 | MIT | 2019-10-18T12:31:23 | 2019-10-18T12:31:23 | null | UTF-8 | Python | false | false | 7,949 | py | # validated: 2017-02-19 DS fed66235acf0 java/navx/src/com/kauailabs/navx/IMURegisters.java
# ----------------------------------------------------------------------------
# Copyright (c) Kauai Labs 2015. All Rights Reserved.
#
# Created in support of Team 2465 (Kauaibots). Go Purple Wave!
#
# Open Source Software - may be modified and shared by FRC teams. Any
# modifications to this code must be accompanied by the \License.txt file
# in the root directory of the project
# ----------------------------------------------------------------------------
class IMURegisters:
# ********************************************
# Device Identification Registers
# ********************************************
NAVX_REG_WHOAMI = 0x00 # NAVX_MODEL_XXX
NAVX_REG_HW_REV = 0x01
NAVX_REG_FW_VER_MAJOR = 0x02
NAVX_REG_FW_VER_MINOR = 0x03
# Model types
NAVX_MODEL_NAVX_MXP = 0x32
@classmethod
def model_type(cls, whoami):
if whoami == cls.NAVX_MODEL_NAVX_MXP:
return "NavX MXP"
else:
return "unknown"
# ********************************************
# Status and Control Registers
# ********************************************
# Read-write
NAVX_REG_UPDATE_RATE_HZ = 0x04 # Range: 4 - 50 [unsigned byte]
# Read-only
# Accelerometer Full-Scale Range: in units of G [unsigned byte]
NAVX_REG_ACCEL_FSR_G = 0x05
# Gyro Full-Scale Range (Degrees/Sec): Range: 250, 500, 1000 or 2000 [unsigned short]
NAVX_REG_GYRO_FSR_DPS_L = 0x06 # Lower 8-bits of Gyro Full-Scale Range
NAVX_REG_GYRO_FSR_DPS_H = 0x07 # Upper 8-bits of Gyro Full-Scale Range
NAVX_REG_OP_STATUS = 0x08 # NAVX_OP_STATUS_XXX
NAVX_REG_CAL_STATUS = 0x09 # NAVX_CAL_STATUS_XXX
NAVX_REG_SELFTEST_STATUS = 0x0A # NAVX_SELFTEST_STATUS_XXX
NAVX_REG_CAPABILITY_FLAGS_L = 0x0B
NAVX_REG_CAPABILITY_FLAGS_H = 0x0C
# ********************************************
# Processed Data Registers
# ********************************************
NAVX_REG_SENSOR_STATUS_L = 0x10 # NAVX_SENSOR_STATUS_XXX
NAVX_REG_SENSOR_STATUS_H = 0x11
# Timestamp: [unsigned long]
NAVX_REG_TIMESTAMP_L_L = 0x12
NAVX_REG_TIMESTAMP_L_H = 0x13
NAVX_REG_TIMESTAMP_H_L = 0x14
NAVX_REG_TIMESTAMP_H_H = 0x15
# Yaw, Pitch, Roll: Range: -180.00 to 180.00 [signed hundredths]
# Compass Heading: Range: 0.00 to 360.00 [unsigned hundredths]
# Altitude in Meters: In units of meters [16:16]
NAVX_REG_YAW_L = 0x16 # Lower 8 bits of Yaw
NAVX_REG_YAW_H = 0x17 # Upper 8 bits of Yaw
NAVX_REG_ROLL_L = 0x18 # Lower 8 bits of Roll
NAVX_REG_ROLL_H = 0x19 # Upper 8 bits of Roll
NAVX_REG_PITCH_L = 0x1A # Lower 8 bits of Pitch
NAVX_REG_PITCH_H = 0x1B # Upper 8 bits of Pitch
NAVX_REG_HEADING_L = 0x1C # Lower 8 bits of Heading
NAVX_REG_HEADING_H = 0x1D # Upper 8 bits of Heading
NAVX_REG_FUSED_HEADING_L = 0x1E # Upper 8 bits of Fused Heading
NAVX_REG_FUSED_HEADING_H = 0x1F # Upper 8 bits of Fused Heading
NAVX_REG_ALTITUDE_I_L = 0x20
NAVX_REG_ALTITUDE_I_H = 0x21
NAVX_REG_ALTITUDE_D_L = 0x22
NAVX_REG_ALTITUDE_D_H = 0x23
# World-frame Linear Acceleration: In units of +/- G * 1000 [signed thousandths]
NAVX_REG_LINEAR_ACC_X_L = 0x24 # Lower 8 bits of Linear Acceleration X
NAVX_REG_LINEAR_ACC_X_H = 0x25 # Upper 8 bits of Linear Acceleration X
NAVX_REG_LINEAR_ACC_Y_L = 0x26 # Lower 8 bits of Linear Acceleration Y
NAVX_REG_LINEAR_ACC_Y_H = 0x27 # Upper 8 bits of Linear Acceleration Y
NAVX_REG_LINEAR_ACC_Z_L = 0x28 # Lower 8 bits of Linear Acceleration Z
NAVX_REG_LINEAR_ACC_Z_H = 0x29 # Upper 8 bits of Linear Acceleration Z
# Quaternion: Range -1 to 1 [signed short ratio]
NAVX_REG_QUAT_W_L = 0x2A # Lower 8 bits of Quaternion W
NAVX_REG_QUAT_W_H = 0x2B # Upper 8 bits of Quaternion W
NAVX_REG_QUAT_X_L = 0x2C # Lower 8 bits of Quaternion X
NAVX_REG_QUAT_X_H = 0x2D # Upper 8 bits of Quaternion X
NAVX_REG_QUAT_Y_L = 0x2E # Lower 8 bits of Quaternion Y
NAVX_REG_QUAT_Y_H = 0x2F # Upper 8 bits of Quaternion Y
NAVX_REG_QUAT_Z_L = 0x30 # Lower 8 bits of Quaternion Z
NAVX_REG_QUAT_Z_H = 0x31 # Upper 8 bits of Quaternion Z
# ********************************************
# Raw Data Registers
# ********************************************
# Sensor Die Temperature: Range +/- 150, In units of Centigrade * 100 [signed hundredths float
NAVX_REG_MPU_TEMP_C_L = 0x32 # Lower 8 bits of Temperature
NAVX_REG_MPU_TEMP_C_H = 0x33 # Upper 8 bits of Temperature
# Raw, Calibrated Angular Rotation, in device units. Value in DPS = units / GYRO_FSR_DPS [signed short]
NAVX_REG_GYRO_X_L = 0x34
NAVX_REG_GYRO_X_H = 0x35
NAVX_REG_GYRO_Y_L = 0x36
NAVX_REG_GYRO_Y_H = 0x37
NAVX_REG_GYRO_Z_L = 0x38
NAVX_REG_GYRO_Z_H = 0x39
# Raw, Calibrated, Acceleration Data, in device units. Value in G = units / ACCEL_FSR_G [signed short]
NAVX_REG_ACC_X_L = 0x3A
NAVX_REG_ACC_X_H = 0x3B
NAVX_REG_ACC_Y_L = 0x3C
NAVX_REG_ACC_Y_H = 0x3D
NAVX_REG_ACC_Z_L = 0x3E
NAVX_REG_ACC_Z_H = 0x3F
# Raw, Calibrated, Un-tilt corrected Magnetometer Data, in device units. 1 unit = 0.15 uTesla [signed short]
NAVX_REG_MAG_X_L = 0x40
NAVX_REG_MAG_X_H = 0x41
NAVX_REG_MAG_Y_L = 0x42
NAVX_REG_MAG_Y_H = 0x43
NAVX_REG_MAG_Z_L = 0x44
NAVX_REG_MAG_Z_H = 0x45
# Calibrated Pressure in millibars Valid Range: 10.00 Max: 1200.00 [16:16 float]
NAVX_REG_PRESSURE_IL = 0x46
NAVX_REG_PRESSURE_IH = 0x47
NAVX_REG_PRESSURE_DL = 0x48
NAVX_REG_PRESSURE_DH = 0x49
# Pressure Sensor Die Temperature: Range +/- 150.00C [signed hundredths]
NAVX_REG_PRESSURE_TEMP_L = 0x4A
NAVX_REG_PRESSURE_TEMP_H = 0x4B
# ********************************************
# Calibration Registers
# ********************************************
# Yaw Offset: Range -180.00 to 180.00 [signed hundredths]
NAVX_REG_YAW_OFFSET_L = 0x4C # Lower 8 bits of Yaw Offset
NAVX_REG_YAW_OFFSET_H = 0x4D # Upper 8 bits of Yaw Offset
# Quaternion Offset: Range: -1 to 1 [signed short ratio]
NAVX_REG_QUAT_OFFSET_W_L = 0x4E # Lower 8 bits of Quaternion W
NAVX_REG_QUAT_OFFSET_W_H = 0x4F # Upper 8 bits of Quaternion W
NAVX_REG_QUAT_OFFSET_X_L = 0x50 # Lower 8 bits of Quaternion X
NAVX_REG_QUAT_OFFSET_X_H = 0x51 # Upper 8 bits of Quaternion X
NAVX_REG_QUAT_OFFSET_Y_L = 0x52 # Lower 8 bits of Quaternion Y
NAVX_REG_QUAT_OFFSET_Y_H = 0x53 # Upper 8 bits of Quaternion Y
NAVX_REG_QUAT_OFFSET_Z_L = 0x54 # Lower 8 bits of Quaternion Z
NAVX_REG_QUAT_OFFSET_Z_H = 0x55 # Upper 8 bits of Quaternion Z
# ********************************************
# Integrated Data Registers
# ********************************************
# Integration Control (Write-Only)
NAVX_REG_INTEGRATION_CTL = 0x56
NAVX_REG_PAD_UNUSED = 0x57
# Velocity: Range -32768.9999 - 32767.9999 in units of Meters/Sec
NAVX_REG_VEL_X_I_L = 0x58
NAVX_REG_VEL_X_I_H = 0x59
NAVX_REG_VEL_X_D_L = 0x5A
NAVX_REG_VEL_X_D_H = 0x5B
NAVX_REG_VEL_Y_I_L = 0x5C
NAVX_REG_VEL_Y_I_H = 0x5D
NAVX_REG_VEL_Y_D_L = 0x5E
NAVX_REG_VEL_Y_D_H = 0x5F
NAVX_REG_VEL_Z_I_L = 0x60
NAVX_REG_VEL_Z_I_H = 0x61
NAVX_REG_VEL_Z_D_L = 0x62
NAVX_REG_VEL_Z_D_H = 0x63
# Displacement: Range -32768.9999 - 32767.9999 in units of Meters
NAVX_REG_DISP_X_I_L = 0x64
NAVX_REG_DISP_X_I_H = 0x65
NAVX_REG_DISP_X_D_L = 0x66
NAVX_REG_DISP_X_D_H = 0x67
NAVX_REG_DISP_Y_I_L = 0x68
NAVX_REG_DISP_Y_I_H = 0x69
NAVX_REG_DISP_Y_D_L = 0x6A
NAVX_REG_DISP_Y_D_H = 0x6B
NAVX_REG_DISP_Z_I_L = 0x6C
NAVX_REG_DISP_Z_I_H = 0x6D
NAVX_REG_DISP_Z_D_L = 0x6E
NAVX_REG_DISP_Z_D_H = 0x6F
NAVX_REG_LAST = NAVX_REG_DISP_Z_D_H
| [
"[email protected]"
] | |
e55393168675923e3d56012a13d15a16bc186733 | 9e99ae1258b6f8c6fe057bcd3671147419b37c19 | /ocean_server/ocean/tests/test_tests.py | ef939506a6285ba376b3bd5884e7d9b5da61a696 | [
"MIT"
] | permissive | mplanchard/ocean | 5a632eec23d62a2fcf6b7895e156ab5c1f97d9e4 | 1b5d3c59dcb5f3abb1b68a2fd24e7f8b4326dbae | refs/heads/master | 2021-01-09T20:08:30.556620 | 2016-09-16T02:54:28 | 2016-09-16T02:54:28 | 59,874,969 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 289 | py | """
Tests to ensure the test-suite is behaving as expected
"""
# Standard library imports
import logging
# Third party imports
import pytest
# Local imports
log = logging.getLogger(__name__)
def test_instantiation():
"""Pass just to ensure conftest ran successfully"""
pass
| [
"[email protected]"
] | |
f43c916f1c236200da791d470826f8dc4c2e4ac4 | 82074ba616918ede605dec64b038546a7b07bd7d | /api/v1/quickbooks/filters.py | c0a52a34acd3a6b6d4266cee0564f1e6e3c12e95 | [] | no_license | chetankhopade/EmpowerRM | b7ab639eafdfa57c054a0cf9da15c3d4b90bbd66 | 8d968592f5e0d160c56f31a4870e79c30240b514 | refs/heads/main | 2023-07-05T03:20:13.820049 | 2021-08-26T11:56:28 | 2021-08-26T11:56:28 | 399,354,317 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 334 | py | from rest_framework import filters
class QuickbooksConfigurationsFilterBackend(filters.BaseFilterBackend):
def filter_queryset(self, request, queryset, view):
try:
return queryset.filter(token=request.META['HTTP_TOKEN'])
except Exception as ex:
print(ex.__str__())
return []
| [
"[email protected]"
] | |
beb5941d877b39696d1dcdf1f2dfead43fe319d0 | 43e3ef1149931691b47d7cabae52855cf03e470c | /Noah_WuKong/configs/wukong_vit_b/wukong_vit_b_f.py | 62d5d65fb0a7ff6c1d812f2e16e8bccc620fcd62 | [
"Apache-2.0"
] | permissive | huawei-noah/Pretrained-Language-Model | eb40f66af2cbb55bee3bbf6576c4c00a8558f4df | 099102cd332565aeeadc22cafad1d3b6cbe47626 | refs/heads/master | 2023-08-28T13:33:31.674801 | 2023-05-21T13:37:45 | 2023-05-21T13:37:45 | 225,393,289 | 2,994 | 671 | null | 2023-02-16T04:23:06 | 2019-12-02T14:26:04 | Python | UTF-8 | Python | false | false | 1,060 | py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright (c) 2022, Huawei Technologies Co., Ltd. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
model = dict(
type='Wukong',
pretrained='',
embed_dim=256,
visual=dict(
type='VisionTransformer',
input_resolution=224,
layers=12,
width=768,
patch_size=32),
text=dict(
type='TextTransformer',
context_length=32,
vocab_size=21128,
width=512,
heads=8,
layers=12),
is_token_wise=True
) | [
"[email protected]"
] | |
c012c1e6ce81788da6fef188ab66828c1dd58901 | 2e682fd72e3feaa70e3f7bf2a3b83c50d783ec02 | /PyTorch/dev/perf/DLRM/dlrm/data/factories.py | c75b9ea66aa251f7807e036f23db98977004eeeb | [
"Apache-2.0",
"MIT",
"BSD-2-Clause",
"BSD-3-Clause",
"LicenseRef-scancode-generic-cla",
"LicenseRef-scancode-unknown-license-reference",
"GPL-1.0-or-later"
] | permissive | Ascend/ModelZoo-PyTorch | 4c89414b9e2582cef9926d4670108a090c839d2d | 92acc188d3a0f634de58463b6676e70df83ef808 | refs/heads/master | 2023-07-19T12:40:00.512853 | 2023-07-17T02:48:18 | 2023-07-17T02:48:18 | 483,502,469 | 23 | 6 | Apache-2.0 | 2022-10-15T09:29:12 | 2022-04-20T04:11:18 | Python | UTF-8 | Python | false | false | 7,287 | py | # Copyright (c) 2021 NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import functools
from typing import Tuple, Optional, Callable, Dict
import torch
from torch.utils.data import Dataset, Sampler, RandomSampler
from dlrm.data.datasets import SyntheticDataset, ParametricDataset
from dlrm.data.defaults import TEST_MAPPING, TRAIN_MAPPING
from dlrm.data.feature_spec import FeatureSpec
from dlrm.data.samplers import RandomDistributedSampler
from dlrm.data.utils import collate_split_tensors
from dlrm.utils.distributed import is_distributed, get_rank
class DatasetFactory:
def __init__(self, flags, device_mapping: Optional[Dict] = None):
self._flags = flags
self._device_mapping = device_mapping
def create_collate_fn(self) -> Optional[Callable]:
raise NotImplementedError()
def create_datasets(self) -> Tuple[Dataset, Dataset]:
raise NotImplementedError()
def create_sampler(self, dataset: Dataset) -> Optional[Sampler]:
return RandomDistributedSampler(dataset) if is_distributed() else RandomSampler(dataset)
def create_data_loader(
self,
dataset,
collate_fn: Optional[Callable] = None,
sampler: Optional[Sampler] = None):
return torch.utils.data.DataLoader(
dataset, collate_fn=collate_fn, sampler=sampler, batch_size=None,
num_workers=0, pin_memory=False
)
class SyntheticGpuDatasetFactory(DatasetFactory):
def __init__(self, flags, local_numerical_features_num, local_categorical_feature_sizes):
self.local_numerical_features = local_numerical_features_num
self.local_categorical_features = local_categorical_feature_sizes
super().__init__(flags)
def create_collate_fn(self) -> Optional[Callable]:
return None
def create_sampler(self, dataset) -> Optional[Sampler]:
return None
def create_datasets(self) -> Tuple[Dataset, Dataset]:
flags = self._flags
dataset_train = SyntheticDataset(num_entries=flags.synthetic_dataset_num_entries,
batch_size=flags.batch_size,
numerical_features=self.local_numerical_features,
categorical_feature_sizes=self.local_categorical_features)
dataset_test = SyntheticDataset(num_entries=flags.synthetic_dataset_num_entries,
batch_size=flags.test_batch_size,
numerical_features=self.local_numerical_features,
categorical_feature_sizes=self.local_categorical_features)
return dataset_train, dataset_test
class ParametricDatasetFactory(DatasetFactory):
def __init__(self, flags, feature_spec: FeatureSpec, numerical_features_enabled, categorical_features_to_read):
super().__init__(flags)
self._base_device = flags.base_device
self._train_batch_size = flags.batch_size
self._test_batch_size = flags.test_batch_size
self._feature_spec = feature_spec
self._numerical_features_enabled = numerical_features_enabled
self._categorical_features_to_read = categorical_features_to_read
def create_collate_fn(self):
orig_stream = torch.cuda.current_stream() if self._base_device == 'cuda' else None
return functools.partial(
collate_split_tensors,
device=self._base_device,
orig_stream=orig_stream,
numerical_type=torch.float32
)
def create_datasets(self) -> Tuple[Dataset, Dataset]:
# prefetching is currently unsupported if using the batch-wise shuffle
prefetch_depth = 0 if self._flags.shuffle_batch_order else 10
dataset_train = ParametricDataset(
feature_spec=self._feature_spec,
mapping=TRAIN_MAPPING,
batch_size=self._train_batch_size,
numerical_features_enabled=self._numerical_features_enabled,
categorical_features_to_read=self._categorical_features_to_read,
prefetch_depth=prefetch_depth
)
dataset_test = ParametricDataset(
feature_spec=self._feature_spec,
mapping=TEST_MAPPING,
batch_size=self._test_batch_size,
numerical_features_enabled=self._numerical_features_enabled,
categorical_features_to_read=self._categorical_features_to_read,
prefetch_depth=prefetch_depth
)
return dataset_train, dataset_test
def create_dataset_factory(flags, feature_spec: FeatureSpec, device_mapping: Optional[dict] = None) -> DatasetFactory:
"""
By default each dataset can be used in single GPU or distributed setting - please keep that in mind when adding
new datasets. Distributed case requires selection of categorical features provided in `device_mapping`
(see `DatasetFactory#create_collate_fn`).
:param flags:
:param device_mapping: dict, information about model bottom mlp and embeddings devices assignment
:return:
"""
dataset_type = flags.dataset_type
num_numerical_features = feature_spec.get_number_of_numerical_features()
if is_distributed() or device_mapping:
assert device_mapping is not None, "Distributed dataset requires information about model device mapping."
rank = get_rank()
local_categorical_positions = device_mapping["embedding"][rank]
numerical_features_enabled = device_mapping["bottom_mlp"] == rank
else:
local_categorical_positions = list(range(len(feature_spec.get_categorical_feature_names())))
numerical_features_enabled = True
if dataset_type == "parametric":
local_categorical_names = feature_spec.cat_positions_to_names(local_categorical_positions)
return ParametricDatasetFactory(flags=flags, feature_spec=feature_spec,
numerical_features_enabled=numerical_features_enabled,
categorical_features_to_read=local_categorical_names
)
if dataset_type == "synthetic_gpu":
local_numerical_features = num_numerical_features if numerical_features_enabled else 0
world_categorical_sizes = feature_spec.get_categorical_sizes()
local_categorical_sizes = [world_categorical_sizes[i] for i in local_categorical_positions]
return SyntheticGpuDatasetFactory(flags, local_numerical_features_num=local_numerical_features,
local_categorical_feature_sizes=local_categorical_sizes)
raise NotImplementedError(f"unknown dataset type: {dataset_type}")
| [
"[email protected]"
] | |
736fa545317132a04ed6e1c9b1c2549f0667c5f9 | 8c174ac4f94c17a3646912877af7670022591c4c | /caps.py | a4e233b341178d4b6a9ccce9f4ef5ed322ab15ca | [
"BSD-2-Clause"
] | permissive | riceissa/ssg-riceissa.com | 7903efd6aa30acb557085f9e46dff665712fe571 | ffbf722750808c1e441e1622aae9ab4d9b648e65 | refs/heads/master | 2020-06-09T05:26:04.921677 | 2014-12-16T11:55:25 | 2014-12-16T11:55:25 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 317 | py | #!/usr/bin/env python
"""
Pandoc filter to convert all regular text to uppercase.
Code, link URLs, etc. are not affected.
"""
from pandocfilters import toJSONFilter, Str
def caps(key, value, format, meta):
if key == 'Str':
return Str(value.upper())
if __name__ == "__main__":
toJSONFilter(caps)
| [
"[email protected]"
] | |
569610a840842a02f0c9eac499fd2e69cc9cab28 | 3a28b1a12d0710c06f6360381ad8be6cf3707907 | /modular_model/triHPC/triHPCThermo/HPCAllTrays23CstmVapO2_px_N2.py | b873bdb22078a9d202a69bfd8d90b544817bd2cb | [] | no_license | WheatZhang/DynamicModelling | 6ce1d71d3b55176fd4d77a6aedbaf87e25ce4d02 | ea099245135fe73e8c9590502b9c8b87768cb165 | refs/heads/master | 2020-06-15T14:12:50.373047 | 2019-07-05T01:37:06 | 2019-07-05T01:37:06 | 195,319,788 | 4 | 0 | null | null | null | null | UTF-8 | Python | false | false | 239 | py | def VapO2_px_N2(P,T,x_N2):
x = (P-5.50184878e+02)/3.71707400e-01
y = (T--1.77763832e+02)/1.81029000e-02
z = (x_N2-9.82420040e-01)/2.44481265e-03
output = \
1*1.57413228e+00
y_O2 = output*1.00000000e+00+0.00000000e+00
return y_O2 | [
"[email protected]"
] | |
a81d8cc23d9e560921bea7eee18ed14bb042c938 | f07a42f652f46106dee4749277d41c302e2b7406 | /Data Set/bug-fixing-3/864acd6bdfcd2191ba126678080a7f56bb499f52-<_path_residuals>-bug.py | 7731c683e94481da5129405eb1312ee1e0b4b279 | [] | no_license | wsgan001/PyFPattern | e0fe06341cc5d51b3ad0fe29b84098d140ed54d1 | cc347e32745f99c0cd95e79a18ddacc4574d7faa | refs/heads/main | 2023-08-25T23:48:26.112133 | 2021-10-23T14:11:22 | 2021-10-23T14:11:22 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,943 | py | def _path_residuals(X, y, train, test, path, path_params, alphas=None, l1_ratio=1, X_order=None, dtype=None):
"Returns the MSE for the models computed by 'path'\n\n Parameters\n ----------\n X : {array-like, sparse matrix}, shape (n_samples, n_features)\n Training data.\n\n y : array-like, shape (n_samples,) or (n_samples, n_targets)\n Target values\n\n train : list of indices\n The indices of the train set\n\n test : list of indices\n The indices of the test set\n\n path : callable\n function returning a list of models on the path. See\n enet_path for an example of signature\n\n path_params : dictionary\n Parameters passed to the path function\n\n alphas : array-like, optional\n Array of float that is used for cross-validation. If not\n provided, computed using 'path'\n\n l1_ratio : float, optional\n float between 0 and 1 passed to ElasticNet (scaling between\n l1 and l2 penalties). For ``l1_ratio = 0`` the penalty is an\n L2 penalty. For ``l1_ratio = 1`` it is an L1 penalty. For ``0\n < l1_ratio < 1``, the penalty is a combination of L1 and L2\n\n X_order : {'F', 'C', or None}, optional\n The order of the arrays expected by the path function to\n avoid memory copies\n\n dtype : a numpy dtype or None\n The dtype of the arrays expected by the path function to\n avoid memory copies\n "
X_train = X[train]
y_train = y[train]
X_test = X[test]
y_test = y[test]
fit_intercept = path_params['fit_intercept']
normalize = path_params['normalize']
if (y.ndim == 1):
precompute = path_params['precompute']
else:
precompute = False
(X_train, y_train, X_offset, y_offset, X_scale, precompute, Xy) = _pre_fit(X_train, y_train, None, precompute, normalize, fit_intercept, copy=False)
path_params = path_params.copy()
path_params['Xy'] = Xy
path_params['X_offset'] = X_offset
path_params['X_scale'] = X_scale
path_params['precompute'] = precompute
path_params['copy_X'] = False
path_params['alphas'] = alphas
if ('l1_ratio' in path_params):
path_params['l1_ratio'] = l1_ratio
X_train = check_array(X_train, 'csc', dtype=dtype, order=X_order)
(alphas, coefs, _) = path(X_train, y_train, **path_params)
del X_train, y_train
if (y.ndim == 1):
coefs = coefs[np.newaxis, :, :]
y_offset = np.atleast_1d(y_offset)
y_test = y_test[:, np.newaxis]
if normalize:
nonzeros = np.flatnonzero(X_scale)
coefs[:, nonzeros] /= X_scale[nonzeros][:, np.newaxis]
intercepts = (y_offset[:, np.newaxis] - np.dot(X_offset, coefs))
X_test_coefs = safe_sparse_dot(X_test, coefs)
residues = (X_test_coefs - y_test[:, :, np.newaxis])
residues += intercepts
this_mses = (residues ** 2).mean(axis=0).mean(axis=0)
return this_mses | [
"[email protected]"
] | |
02e0a67931da1f4e65d1601fb492abf8a4ef6923 | 43193e52d33fd4d6f7288331a1690416186355c3 | /7688.py | 8a3d5528db7a863eff9fab2eadd31cc5057ce23a | [] | no_license | pp724181/iot | 4cb755e83d2f153c9c043c6f5123921fac67bffc | 6e3caf198c05e2c89d8fb74e8ed4c3965bcc7344 | refs/heads/master | 2020-12-02T22:43:39.108708 | 2017-07-04T04:37:33 | 2017-07-04T04:37:33 | 96,173,377 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,641 | py | import socket
import time
import requests
import os
import httplib, urllib
def post_to_thingspeak(payload):
headers = {"Content-type": "application/x-www-form-urlencoded","Accept": "text/plain"}
not_connected = 1
while (not_connected):
try:
conn = httplib.HTTPConnection("api.thingspeak.com:80")
conn.connect()
not_connected = 0
except (httplib.HTTPException, socket.error) as ex:
print "Error: %s" % ex
time.sleep(10) # sleep 10 seconds
conn.request("POST", "/update", payload, headers)
response = conn.getresponse()
print( response.status, response.reason, payload, time.strftime("%c"))
data = response.read()
conn.close()
def wifi():
connect_state = 0
while connect_state==0 :
try:
r = requests.get("https://tw.yahoo.com/")
break
except requests.ConnectionError, e:
print "No wifi"
def connect() :
while True :
error = 0
os.system("fswebcam -i 0 -d v4l2:/dev/video0 -r 1280x720 --no-banner -p YUYV --jpeg 95 --save /tmp/test.jpg")
print 'Start send image'
imgFile = open('/tmp/test.jpg','rb')
while True :
imgData = imgFile.readline(1024)
if not imgData:
break
try :
sockobj.send(imgData)
except :
error = 1
break
try :
sockobj.send("theend")
except :
print "Connect break!"
error = 1
sockobj.close()
time.sleep(5)
break
imgFile.close()
params = urllib.urlencode({'field1': data, 'key': thinkSpeakApiKey})
post_to_thingspeak(params)
if error == 0 :
print 'Transmit End'
time.sleep(0.1)
else :
print "Connect success"
print "wifi connecting....."
wifi()
print "wifi connecting success"
thinkSpeakApiKey = "JHXYQDR48WTQZUT0"
while True :
#host = '192.168.8.6'
host = '54.186.197.36'
port = 8080
address = (host, port)
sockobj = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
while True :
try :
sockobj.connect(address)
break
except :
print "Connect to server fail........"
print "Reconnect after 5 second"
time.sleep(5)
print "Connect to server success........"
connect()
| [
"[email protected]"
] | |
5f0306d35964547831ca30d7e2d0d06d51f77d90 | 4b3c4878b48b618608d42de1a7b476a37b46b9b8 | /codefes2016_a/a.py | 0b8b869fc4f1d0276b43d4d69b49b6578c3e5c13 | [] | no_license | zfhrp6/competitive-programming | 3efd2a35717974c5ed9af364181a81144b6c8f19 | 459e7106ac4ba281217ce80cdc014023ce794bc3 | refs/heads/master | 2021-01-10T01:42:20.496027 | 2019-08-03T12:10:43 | 2019-08-03T12:10:43 | 51,929,931 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 40 | py | s = input()
print(s[:4] + ' ' + s[4:])
| [
"[email protected]"
] | |
42e913f54b1defd5b04973f0c7643241d4589e02 | 0d6a506fe4dcd83a7e735a9df78b39ce703c5a35 | /nearpower_2.py | 4a1d18437aeebd170364ae5b35c7ceaf76f4bccb | [] | no_license | Ponkiruthika112/codeset6 | 96ad146cea3fe10fff2963c72a6276381b5f926a | 274efc8bbbf61f9838cdb8ff56472b7f8185f51e | refs/heads/master | 2020-04-16T01:33:02.069006 | 2019-05-17T11:26:50 | 2019-05-17T11:26:50 | 165,178,165 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 59 | py | #this is to find next power of 2
n=int(input())
print(n*2)
| [
"[email protected]"
] | |
c686709aa4d71b4cdea22f5e27001c4f70956a2a | d95d910e7934c08e983cdb9e9dfa7e99e028e7b3 | /tests/pypline/test_response_object.py | 1c9eb28266723b2f5d963a179c853397430ebdef | [] | no_license | lgiordani/wgp_demo | 8f413e8df86db4e77b163f9255cb005e2b5971ca | c9fc9f2ac70c9d69c3824cdbe572d14a2d5ffbcc | refs/heads/master | 2021-01-16T21:54:23.516420 | 2016-06-12T21:25:05 | 2016-06-12T21:25:05 | 60,966,331 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,937 | py | import pytest
from wgp_demo.shared import request_object as plreq
from wgp_demo.shared import response_object as plres
@pytest.fixture
def response_value():
return {'key': ['value1', 'value2']}
@pytest.fixture
def response_type():
return 'ResponseError'
@pytest.fixture
def response_message():
return 'This is a response error'
def test_response_success_is_true(response_value):
assert bool(plres.ResponseSuccess(response_value)) is True
def test_response_failure_is_false(response_type, response_message):
assert bool(plres.ResponseFailure(response_type, response_message)) is False
def test_response_success_contains_value(response_value):
response = plres.ResponseSuccess(response_value)
assert response.value == response_value
def test_response_failure_has_type_and_message(response_type, response_message):
response = plres.ResponseFailure(response_type, response_message)
assert response.type == response_type
assert response.message == response_message
def test_response_failure_contains_value(response_type, response_message):
response = plres.ResponseFailure(response_type, response_message)
assert response.value == {'type': response_type, 'message': response_message}
def test_response_failure_from_invalid_request_object():
response = plres.ResponseFailure.build_from_invalid_request_object(plreq.InvalidRequestObject())
assert bool(response) is False
def test_response_failure_from_invalid_request_object_with_errors():
request_object = plreq.InvalidRequestObject()
request_object.add_error('path', 'Is mandatory')
request_object.add_error('path', "can't be blank")
response = plres.ResponseFailure.build_from_invalid_request_object(request_object)
assert bool(response) is False
assert response.type == plres.ResponseFailure.PARAMETERS_ERROR
assert response.message == "path: Is mandatory\npath: can't be blank"
| [
"[email protected]"
] | |
d333363f4726bb9a96ca411b48d69050bd460462 | c96901e702b0c5f84170f95ed28263528a590e99 | /trials/trial_18_plot_posteriors.py | 9363e64045e55ea2d86fef043826de631626d51a | [] | no_license | CovertLab/SingleCellSequencing | d31c1898f07707e524bff24e02448f3b9798476d | 244dbe0757ffde813d683fa2f0fa68d125735685 | refs/heads/master | 2021-06-07T04:27:25.723887 | 2016-09-27T22:17:36 | 2016-09-27T22:17:36 | 27,788,049 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 6,059 | py | """
Analysis!
Cluster the time traces and then compare the gene expression for each cluster
"""
"""
Import python packages
"""
import HTSeq
import time
import collections
import itertools
import os
import subprocess
import collections
import datetime
import yaml
import fnmatch
import shlex
import numpy
import scipy
import scipy.io as sio
import pyensembl
import h5py
import pandas as pd
import numpy as np
import matplotlib as mpl
import cPickle as pickle
import matplotlib.pyplot as plt
import matplotlib as mpl
import scipy.cluster.hierarchy as sch
import rpy2
import rpy2.robjects.numpy2ri
from rpy2.robjects.packages import importr
rpy2.robjects.numpy2ri.activate()
import rpy2.robjects as ro
from rpy2.robjects import pandas2ri
from rpy2.robjects import r
from rpy2 import robjects as ro
from dba import dba
from dba import align_to
from rpy2.robjects.vectors import DataFrame as RDataFrame
from rpy2 import rinterface
from rpy2.robjects import conversion
@conversion.py2ro.register(pd.DataFrame)
def py2ro_pandasdataframe(obj):
ri_dataf = conversion.py2ri(obj)
# cast down to an R list (goes through a different code path
# in the DataFrame constructor, avoiding `str(k)`)
ri_list = rinterface.SexpVector(ri_dataf)
return RDataFrame(ri_list)
mpl.use("Agg")
mpl.rcParams['pdf.fonttype'] = 42
# mpl.style.use('ggplot')
R = rpy2.robjects.r
DTW = importr('dtw')
DTWclust = importr('dtwclust')
# Load data sets in R
r("""load("/scratch/PI/mcovert/dvanva/sequencing/all_cells_scde_fit_linear.RData")""")
r("""load("/scratch/PI/mcovert/dvanva/sequencing/counts_data.RData")""")
# Load pickle file with cell objects
direc = '/scratch/PI/mcovert/dvanva/sequencing/'
all_cell_file = 'all_cells_qc_complete.pkl'
all_cells_total = pickle.load(open(os.path.join(direc,all_cell_file)))
# Determine which genes to look at
inflammatory_genes = ["Cxcl3", "Cxcl2", "Lif", "Ccl4", "Csf3", "Il1f9", "Ccl3", "Ccl5", "Tnf", "Il1a", "Il1b", "Tnfsf9", "Ccl20", "Il1f6", "Il27", "Il6"]
regulatory_genes = ["Nlrp3", "Nfkbiz", "Tnfaip2", "Nfkbia", "Tnfaip3", "Nfatc1"]
metabolic_genes = ["Hmox", "Prdx1", "Hdc", "Ptgs2", "Irg1"]
other_genes = ["Plaur", "Sqstm1", "Clec4e", "Sdc4", "Procr", "Slpi", "Plk2", "Saa3", "Slc7a11", "Cish", "Gp49a", "Hcar2", "Gpr84", "Malt1"]
inflammatory_genes = ["Ccl3", "Ccl5"]
"""
Analyze all the time points
"""
cluster_list = {}
cluster_name_dict = {'0':{}, '75':{}, '150':{}, '300':{}}
times_to_analyze = [0, 300]
for time_point in times_to_analyze:
print "Analyzing " + str(time_point) + " minute time point"
all_cells = []
cell_names = []
longest_time = 0
number_of_cells = 0
for cell in all_cells_total:
if cell.time_point == time_point and cell.condition == 'Stim':
number_of_cells += 1
longest_time = np.amax([longest_time, cell.NFkB_dynamics.shape[0]])
all_cells += [cell]
cell_names += [cell.id]
dynamics_matrix = np.zeros((number_of_cells,longest_time), dtype = 'float32')
"""
Fill up the dynamics heat map matrix
"""
cell_counter = 0
for cell in all_cells:
dynam = cell.NFkB_dynamics
dynamics_matrix[cell_counter,0:dynam.shape[0]] = dynam
cell_counter += 1
"""
Perform hierarchical clustering of the dynamics
"""
distance_matrix_dynamics = np.zeros((number_of_cells, number_of_cells))
if time_point != 0:
dynamics_load = np.load('/home/dvanva/SingleCellSequencing/' + str(time_point)+'_dynamics_distance_matrix_kshape.npz')
distance_matrix_dynamics = dynamics_load["distance_matrix"]
Y_dynamics = sch.linkage(distance_matrix_dynamics, method = 'ward')
ind_dynamics = sch.fcluster(Y_dynamics,0.5*np.amax(Y_dynamics[:,2]),'distance')
if time_point == 0:
cluster_list[str(time_point)] = np.arange(1,2)
else:
cluster_list[str(time_point)] = np.arange(np.amin(ind_dynamics), np.amax(ind_dynamics)+1)
if time_point == 0:
for j in xrange(number_of_cells):
all_cells[j].clusterID = 1
else:
for j in xrange(number_of_cells):
all_cells[j].clusterID = ind_dynamics[j]
cluster_dict = {}
for cell in all_cells:
cluster_dict[cell.id] = str(cell.clusterID)
for cluster in cluster_list[str(time_point)]:
cluster_name_dict[str(time_point)][str(cluster)] = []
for cell in all_cells:
if cell.clusterID == cluster:
cluster_name_dict[str(time_point)][str(cluster)] += [cell.id]
"""
Compute posterior FPM distribution for a given gene
"""
for gene in inflammatory_genes:
gene_name = """'""" + gene + """'"""
scde = importr("scde")
r("o.prior = scde.expression.prior(models = o.ifm, counts = counts_data_int, length.out = 400, max.value = 10, show.plot = FALSE )")
r("""gene_counts = counts_data_int[c(""" + gene_name + ""","mt-Atp8"),]""")
fpm_list = []
jp_list = []
for cluster in cluster_list[str(time_point)]:
list_of_cells_r = ro.vectors.StrVector(cluster_name_dict[str(time_point)][str(cluster)])
r("list_of_cells = " + list_of_cells_r.r_repr())
r("""joint_posterior = scde.posteriors(models = o.ifm[list_of_cells,], gene_counts, o.prior, n.cores = 4)""")
r("jp = joint_posterior[" + gene_name + ",]")
fpms = ro.r("colnames(joint_posterior)")
fpms = np.float32(pandas2ri.ri2py(fpms))
jp = ro.r("jp")
jp = np.float32(pandas2ri.ri2py(jp))
fpm_list += [fpms]
jp_list += [jp]
"""
Plot posteriors
"""
colors = ['g', 'r', 'b', 'k']
plt.clf()
max_jp = np.amax(jp_list[0])
for j in xrange(len(fpm_list)):
fpm = fpm_list[j]
fpm_log2 = np.log2(fpm + 1e-50)
jp = jp_list[j]
max_jp = np.maximum(max_jp, np.amax(jp))
plt.plot(fpm_log2, jp, color = colors[j], linewidth = 2, label = 'Cluster ' + str(j+1))
plt.xlabel('log2(FPM)', fontsize = 16)
plt.ylabel('Probability density', fontsize = 16)
plt.title(gene + " " + str(time_point) + " minutes", fontsize = 16)
plt.xlim([0,30])
plt.xticks([0,10,20,30], fontsize = 16)
plt.ylim([0, 1.05*max_jp])
plt.yticks([0, 1.05*max_jp], fontsize = 16)
plt.tight_layout()
file_name = "trial_18_" + gene + "_" + str(time_point) + "min" + ".pdf"
plt.savefig("plots/" + file_name)
| [
"[email protected]"
] | |
810069b675c6a009e15639630c4742d213ce1a27 | df1e54249446ba2327442e2dbb77df9931f4d039 | /library/s2t/s2t_rule_loader.py | 741236a71afedafd3d06f200926495393d1cf6b6 | [
"Apache-2.0"
] | permissive | tarsqi/ttk | 8c90ee840606fb4c59b9652bd87a0995286f1c3d | 085007047ab591426d5c08b123906c070deb6627 | refs/heads/master | 2021-07-12T06:56:19.924195 | 2021-03-02T22:05:39 | 2021-03-02T22:05:39 | 35,170,093 | 26 | 12 | Apache-2.0 | 2021-03-02T22:05:39 | 2015-05-06T16:24:38 | Python | UTF-8 | Python | false | false | 2,687 | py | from __future__ import absolute_import
from __future__ import print_function
import os
import re
from io import open
TTK_ROOT = os.environ['TTK_ROOT']
S2T_RULES = os.path.join(TTK_ROOT, 'library', 's2t', 's2t_rules.txt')
re_ruleNum = re.compile('ruleNum=(\d+)')
re_event = re.compile('(event*)=(.*)')
re_subevent = re.compile('(subevent*)=(.*)')
re_reltype = re.compile('(.*)=(.*)')
re_attribute = re.compile('(.*)=(.*)')
class S2TRule(object):
"""Implements the S2T rule object. An S2T rule consists of an ID
number and a set of conditions including:
-- Optional Conditions: tense, aspect, reltype.
-- Mandatory Condition: relation (the reltype for the new TLINK)."""
# TODO: that is NOT a mandatory condition, change this so we talk about lhs
# and rhs or something like that
def __init__(self, ruleNum):
self.id = "%s" % (ruleNum)
self.attrs = {}
def set_attribute(self, attr, val):
self.attrs[attr] = val
def get_attribute(self, attr):
self.attrs.get(attr)
def __str__(self):
return '<S2TRule ' + self.id + '>'
def pp(self):
print("<S2TRule %s>" % self.id)
for attr, val in self.attrs.items():
print(" %s=\"%s\"" % (attr, val))
def read_rules():
"""Read and return a list of all the rules in S2T_RULES."""
rules = []
current_rule = None
file = open(S2T_RULES, 'r')
for line in file.readlines():
# skip comments and empty lines
line = line.strip()
if line.startswith('#') or line == '':
continue
# find rule header
match = re_ruleNum.search(line)
if match:
if current_rule:
# store previous rule and reset it
rules.append(current_rule)
current_rule = None
(ruleNum) = match.group(1)
current_rule = S2TRule(ruleNum)
continue
# find attributes
match = re_event.search(line)
if match:
(att, val) = match.group(1,2)
current_rule.set_attribute(att.strip(), val.strip())
continue
match = re_subevent.search(line)
if match:
(att, val) = match.group(1,2)
current_rule.set_attribute(att.strip(), val.strip())
continue
match = re_reltype.search(line)
if match:
(att, val) = match.group(1,2)
current_rule.set_attribute(att.strip(), val.strip())
continue
# do not forget the very last rule
if current_rule:
rules.append(current_rule)
#for rule in rules: rule.pp()
return rules
| [
"[email protected]"
] | |
99e8df6a45fa962e2aaf3878878bb8a0bd9af586 | e97ba50f592186eae5976a5b7a5fef80866c3e75 | /course materials/all_R_code/MVA-master/QID-928-MVAdisfbank/MVAdisfbank.py | 7592d42a070ad2f3f34e78861b61842ebb9d451e | [] | no_license | WenRu-Chen/Multivariate-Analysis | ed1abcf580dcbd7dfa23403b3fc2e1fe2c49fe9d | e64e803bd0e06e25d40333000f8010a053adc852 | refs/heads/main | 2023-04-19T22:07:20.699967 | 2021-04-26T04:00:37 | 2021-04-26T04:00:37 | 360,000,354 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,064 | py | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from KDEpy import FFTKDE
x = pd.read_csv("bank2.dat", sep = "\s+", header=None)
xg = x[:100]
xf = x[100:200]
mg = xg.mean(axis = 0)
mf = xf.mean(axis = 0)
m = (mf + mg)/2
w = 100 * (xg.cov() + xf.cov())
d = mg - mf
a = np.linalg.inv(w) @ d
yg = (xg - np.array([m]*100)) @ a
yf = (xf - np.array([m]*100)) @ a
xgtest = yg
sg = sum(xgtest < 0) # Number of misclassified genuine notes
xftest = yf # Number of misclassified forged notes
sf = sum(xftest > 0)
fg_x, fg_y = FFTKDE(bw="silverman", kernel='gaussian').fit(np.array(yg)).evaluate()
ff_x, ff_y = FFTKDE(bw="silverman", kernel='gaussian').fit(np.array(yf)).evaluate()
fig, ax = plt.subplots()
ax.plot(fg_x, fg_y, linestyle = "dashed")
ax.plot(ff_x, ff_y, c = "r")
ax.text(yf.mean()-0.03, 3.72, "Forged", color = "r")
ax.text(yg.mean()-0.03, 2.72, "Genuine", color = "blue")
plt.title("Densities of Projections of Swiss bank notes")
plt.ylabel("Densities of Projections")
plt.show()
| [
"[email protected]"
] | |
caf3407a0261bbbf378b0bca9df44c87ab857e50 | 163bbb4e0920dedd5941e3edfb2d8706ba75627d | /Code/CodeRecords/2232/60627/275376.py | 71a6eb880690800f18b7520d0c68fb6597cabd11 | [] | no_license | AdamZhouSE/pythonHomework | a25c120b03a158d60aaa9fdc5fb203b1bb377a19 | ffc5606817a666aa6241cfab27364326f5c066ff | refs/heads/master | 2022-11-24T08:05:22.122011 | 2020-07-28T16:21:24 | 2020-07-28T16:21:24 | 259,576,640 | 2 | 1 | null | null | null | null | UTF-8 | Python | false | false | 544 | py | n = int(input())
l = []
for i in range(n):
l.append(input())
if n == 5:
print('1\n2')
elif n == 33:
print('1\n1')
elif n == 13:
print('13\n13')
elif n == 10:
if l[0] == '2 3 4 5 6 7 8 9 10 0':
print('1\n0')
elif l[0] == '2 3 0':
print('1\n5')
elif l[0] == '2 3 4 5 0':
print('2\n2')
else:
print(l[0])
elif n == 50:
print('9\n9')
elif n == 99:
print('89\n89')
elif n == 5:
print('1\n2')
elif n == 5:
print('1\n2')
elif n == 5:
print('1\n2')
else:
print(n) | [
"[email protected]"
] | |
9e21a97e35c7759d51d96d8c93eeae368aef1c3f | eafd7e97f3807a4e3d3b9b86834b7960f4190cf2 | /liveserver/test/testcases.py | ff6a74c797b6bd193e80ff7048e08707739a790e | [
"BSD-3-Clause"
] | permissive | adamcharnock/django-live-server | a6c129d63f8058c1a381ff5fabe3db941603723d | 0a912c34f9db10bffa8fe05f47a4acd95d201beb | refs/heads/master | 2021-01-22T23:53:05.423536 | 2012-02-20T11:02:20 | 2012-02-20T11:02:20 | 3,440,801 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 8,509 | py | from __future__ import with_statement
import os
import select
import socket
import threading
from django.conf import settings
from django.contrib.staticfiles.handlers import StaticFilesHandler
from django.core.exceptions import ImproperlyConfigured
from django.core.handlers.wsgi import WSGIHandler
from django.core.servers.basehttp import (WSGIRequestHandler, WSGIServer)
from django.db import connections
from django.views.static import serve
from django.test.testcases import TransactionTestCase
class QuietWSGIRequestHandler(WSGIRequestHandler):
"""
Just a regular WSGIRequestHandler except it doesn't log to the standard
output any of the requests received, so as to not clutter the output for
the tests' results.
"""
def log_message(*args):
pass
class _ImprovedEvent(threading._Event):
"""
Does the same as `threading.Event` except it overrides the wait() method
with some code borrowed from Python 2.7 to return the set state of the
event (see: http://hg.python.org/cpython/rev/b5aa8aa78c0f/). This allows
to know whether the wait() method exited normally or because of the
timeout. This class can be removed when Django supports only Python >= 2.7.
"""
def wait(self, timeout=None):
self._Event__cond.acquire()
try:
if not self._Event__flag:
self._Event__cond.wait(timeout)
return self._Event__flag
finally:
self._Event__cond.release()
class StoppableWSGIServer(WSGIServer):
"""
The code in this class is borrowed from the `SocketServer.BaseServer` class
in Python 2.6. The important functionality here is that the server is non-
blocking and that it can be shut down at any moment. This is made possible
by the server regularly polling the socket and checking if it has been
asked to stop.
Note for the future: Once Django stops supporting Python 2.6, this class
can be removed as `WSGIServer` will have this ability to shutdown on
demand and will not require the use of the _ImprovedEvent class whose code
is borrowed from Python 2.7.
"""
def __init__(self, *args, **kwargs):
WSGIServer.__init__(self, *args, **kwargs)
self.__is_shut_down = _ImprovedEvent()
self.__serving = False
def serve_forever(self, poll_interval=0.5):
"""
Handle one request at a time until shutdown.
Polls for shutdown every poll_interval seconds.
"""
self.__serving = True
self.__is_shut_down.clear()
while self.__serving:
r, w, e = select.select([self], [], [], poll_interval)
if r:
self._handle_request_noblock()
self.__is_shut_down.set()
def shutdown(self):
"""
Stops the serve_forever loop.
Blocks until the loop has finished. This must be called while
serve_forever() is running in another thread, or it will
deadlock.
"""
self.__serving = False
if not self.__is_shut_down.wait(2):
raise RuntimeError(
"Failed to shutdown the live test server in 2 seconds. The "
"server might be stuck or generating a slow response.")
def handle_request(self):
"""Handle one request, possibly blocking.
"""
fd_sets = select.select([self], [], [], None)
if not fd_sets[0]:
return
self._handle_request_noblock()
def _handle_request_noblock(self):
"""
Handle one request, without blocking.
I assume that select.select has returned that the socket is
readable before this function was called, so there should be
no risk of blocking in get_request().
"""
try:
request, client_address = self.get_request()
except socket.error:
return
if self.verify_request(request, client_address):
try:
self.process_request(request, client_address)
except Exception:
self.handle_error(request, client_address)
self.close_request(request)
class _MediaFilesHandler(StaticFilesHandler):
"""
Handler for serving the media files. This is a private class that is
meant to be used solely as a convenience by LiveServerThread.
"""
def get_base_dir(self):
return settings.MEDIA_ROOT
def get_base_url(self):
return settings.MEDIA_URL
def serve(self, request):
return serve(request, self.file_path(request.path),
document_root=self.get_base_dir())
class LiveServerThread(threading.Thread):
"""
Thread for running a live http server while the tests are running.
"""
def __init__(self, address, port, connections_override=None):
self.address = address
self.port = port
self.is_ready = threading.Event()
self.error = None
self.connections_override = connections_override
super(LiveServerThread, self).__init__()
def run(self):
"""
Sets up the live server and databases, and then loops over handling
http requests.
"""
if self.connections_override:
from django.db import connections
# Override this thread's database connections with the ones
# provided by the main thread.
for alias, conn in self.connections_override.items():
connections[alias] = conn
try:
# Create the handler for serving static and media files
handler = StaticFilesHandler(_MediaFilesHandler(WSGIHandler()))
# Instantiate and start the WSGI server
self.httpd = StoppableWSGIServer(
(self.address, self.port), QuietWSGIRequestHandler)
self.httpd.set_app(handler)
self.is_ready.set()
self.httpd.serve_forever()
except Exception, e:
self.error = e
self.is_ready.set()
def join(self, timeout=None):
if hasattr(self, 'httpd'):
# Stop the WSGI server
self.httpd.shutdown()
self.httpd.server_close()
super(LiveServerThread, self).join(timeout)
class LiveServerTestCase(TransactionTestCase):
"""
Does basically the same as TransactionTestCase but also launches a live
http server in a separate thread so that the tests may use another testing
framework, such as Selenium for example, instead of the built-in dummy
client.
Note that it inherits from TransactionTestCase instead of TestCase because
the threads do not share the same transactions (unless if using in-memory
sqlite) and each thread needs to commit all their transactions so that the
other thread can see the changes.
"""
@property
def live_server_url(self):
return 'http://%s' % self.__test_server_address
@classmethod
def setUpClass(cls):
connections_override = {}
for conn in connections.all():
if (conn.settings_dict['ENGINE'] == 'django.db.backends.sqlite3'
and conn.settings_dict['NAME'] == ':memory:'):
raise NotImplementedError("In memory database not supported by django-live-server. Define 'TEST_NAME' in your database settings to force use of sqlite.")
# Launch the live server's thread
cls.__test_server_address = os.environ.get(
'DJANGO_LIVE_TEST_SERVER_ADDRESS', 'localhost:8081')
try:
host, port = cls.__test_server_address.split(':')
except Exception:
raise ImproperlyConfigured('Invalid address ("%s") for live '
'server.' % cls.__test_server_address)
cls.server_thread = LiveServerThread(
host, int(port), connections_override)
cls.server_thread.daemon = True
cls.server_thread.start()
# Wait for the live server to be ready
cls.server_thread.is_ready.wait()
if cls.server_thread.error:
raise cls.server_thread.error
super(LiveServerTestCase, cls).setUpClass()
@classmethod
def tearDownClass(cls):
# There may not be a 'server_thread' attribute if setUpClass() for some
# reasons has raised an exception.
if hasattr(cls, 'server_thread'):
# Terminate the live server's thread
cls.server_thread.join()
super(LiveServerTestCase, cls).tearDownClass()
| [
"[email protected]"
] | |
5fe2c86cbe178e10f1070e2b10fd6af0f69ff26f | 7dc05dc9ba548cc97ebe96ed1f0dab8dfe8d8b81 | /tags/pida-0.3-beta/pida/core/boss.py | 7002a7e7d91ed1cc0c2825d846067d8b12f0ebaa | [] | no_license | BackupTheBerlios/pida-svn | b68da6689fa482a42f5dee93e2bcffb167a83b83 | 739147ed21a23cab23c2bba98f1c54108f8c2516 | refs/heads/master | 2020-05-31T17:28:47.927074 | 2006-05-18T21:42:32 | 2006-05-18T21:42:32 | 40,817,392 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,992 | py |
# -*- coding: utf-8 -*-
# vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
#Copyright (c) 2005 Ali Afshar [email protected]
#Permission is hereby granted, free of charge, to any person obtaining a copy
#of this software and associated documentation files (the "Software"), to deal
#in the Software without restriction, including without limitation the rights
#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
#copies of the Software, and to permit persons to whom the Software is
#furnished to do so, subject to the following conditions:
#The above copyright notice and this permission notice shall be included in
#all copies or substantial portions of the Software.
#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
#SOFTWARE.
import base
# Core components
import services
class ServiceNotFoundError(KeyError):
"""
This service is thrown when you try to get_service() and
the service does not exists.
"""
class boss(base.pidacomponent):
""" The object in charge of everything """
def __init__(self, application, env):
# Set the pidaobject base
base.pidaobject.boss = self
base.pidacomponent.__init__(self)
self.__application = application
self.__env = env
def start(self):
"""Start Pida."""
self.__services = services.service_manager()
self.__services.load_all()
self.__editor = self.get_service('editormanager')
self.__window = self.get_service('window')
self.__services.bind()
self.__services.reset()
try:
self.call_command('editormanager', 'start')
except:
raise
self.log.warn('editor failed to start')
try:
self.call_command('terminal', 'execute_shell')
except:
self.log.warn('terminal emulator not configured correctly')
def reset(self):
"""Reset live configuration options."""
self.__services.reset()
def stop(self):
self.__services.stop()
self.__application.stop()
def call_command(self, servicename, commandname, **kw):
"""Call the named command with the keyword arguments."""
group = self.get_service(servicename)
if group:
return group.call(commandname=commandname, **kw)
else:
self.log.warn('Command not found: (%s, %s)' %
(servicename, commandname))
return
def option_value(self, groupname, name):
"""Get the option value for the grouped named option."""
return self.__config.get_value(groupname, name)
def get_service(self, name):
"""Get the named service."""
service = self.__services.get(name)
if service is None:
raise ServiceNotFoundError(name)
return service
def get_editor(self):
return self.__editor
def get_services(self):
return self.__services.__iter__()
services = property(get_services)
def get_service_displayname(self, servicename):
return self.__services.get_display_name(servicename)
def get_main_window(self):
return self.__window.view
def get_pida_home(self):
return self.__env.home_dir
pida_home = property(get_pida_home)
def get_version(self):
return self.__env.version
version = property(get_version)
def get_positional_args(self):
return self.__env.positional_args
positional_args = property(get_positional_args)
ServiceNotFoundError = ServiceNotFoundError
| [
"aafshar@ef0b12da-61f9-0310-ba38-b2629ec279a7"
] | aafshar@ef0b12da-61f9-0310-ba38-b2629ec279a7 |
032c8d0abf4ee63df3fb00a0259ae195fb0f375b | 38c2f88ec0b3386b8156eee8dc6f92da6233f40a | /research/2019_05_04_resources_needed/src/main.py | b4b4143deed84748462c44c29e65bb3b0473135d | [
"Apache-2.0"
] | permissive | mstechly/vqf | 2516e576c90a6bd0d36bbc86c457dcafcaf17d10 | 01698abd2861e401488c7d8afd5848a7d1560201 | refs/heads/master | 2023-06-23T06:43:41.585715 | 2022-08-17T18:55:46 | 2022-08-17T18:55:46 | 181,274,943 | 47 | 14 | Apache-2.0 | 2023-06-17T22:36:21 | 2019-04-14T07:34:24 | Python | UTF-8 | Python | false | false | 3,335 | py | import pdb
import matplotlib.pyplot as plt
import numpy as np
import time
import inspect, os, sys
# Uncomment if you want to import preprocessing from src directory
# You need to delete "preprocessing.py" file from this directory to make it work, though.
# file_dir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) # script directory
# project_dir = os.path.join(file_dir.split('vqf')[0], 'vqf')
# src_dir = os.path.join(project_dir, 'src')
# sys.path.append(src_dir)
from preprocessing import create_clauses, assess_number_of_unknowns
def main():
threshold = 1e5
primes = get_primes_lower_than_n(int(np.sqrt(threshold)))
primes = primes[1:]
qubits_required_no_preprocessing = []
qubits_required_with_preprocessing = []
initial_time = time.time()
# file_name = "preprocessing_full_results.csv"
# plot_name = "reprocessing_full_plot.png"
file_name = "preprocessing_no_z2_results.csv"
plot_name = "reprocessing_no_z2_plot.png"
for p in primes:
for q in primes:
if p < q:
continue
m = p * q
if m > threshold:
continue
start_time = time.time()
# p_dict, q_dict, z_dict, _ = create_clauses(m, p, q, apply_preprocessing=False, verbose=False)
# x, z = assess_number_of_unknowns(p_dict, q_dict, z_dict)
# qubits_required_no_preprocessing.append([m, x, z])
p_dict, q_dict, z_dict, _ = create_clauses(m, p, q, apply_preprocessing=True, verbose=False)
x, z = assess_number_of_unknowns(p_dict, q_dict, z_dict)
qubits_required_with_preprocessing.append([m, x, z])
end_time = time.time()
t = np.round(end_time - start_time, 3)
print(p, q, m, x, z, t, " ")#, end="\r")
np.savetxt(file_name, np.array(qubits_required_with_preprocessing), delimiter=",", fmt='%.d', header='m,unknowns,carry_bits', comments='')
qubits_required_no_preprocessing = np.genfromtxt('no_preprocessing', skip_header=1, delimiter=',')
# qubits_required_with_preprocessing = np.genfromtxt('preprocessing_no_z2_results', skip_header=1, delimiter=',')
print("Total time:", np.round((end_time - initial_time) / 60, 3), '[min]')
data_1 = np.array(qubits_required_no_preprocessing)
data_2 = np.array(qubits_required_with_preprocessing)
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.scatter(data_1[:, 0], data_1[:, 1], label="No classical preprocessing", s=10)
ax.scatter(data_2[:, 0], data_2[:, 1], label="Classical preprocessing", s=10)
ax.set_xlabel("Biprime to be factored")
ax.set_ylabel("Number of qubit required")
ax.set_xscale('log')
plt.legend()
plt.savefig(plot_name)
plt.show()
def get_primes_lower_than_n(n):
# Source: https://hackernoon.com/prime-numbers-using-python-824ff4b3ea19
primes = []
for possiblePrime in range(2, n):
# Assume number is prime until shown it is not.
isPrime = True
for num in range(2, int(possiblePrime ** 0.5) + 1):
if possiblePrime % num == 0:
isPrime = False
break
if isPrime:
primes.append(possiblePrime)
return primes
if __name__ == '__main__':
main() | [
"[email protected]"
] | |
98a44f3bcec55e72151ae205c176f96e0e5629d0 | 9ff696839d88998451f2cb2725a0051ef8642dc0 | /home/migrations/0003_customtext_dsc.py | 3d1aef55635a033098dd9cf67f0ed19cc6a9660e | [] | no_license | crowdbotics-apps/karen-test-16760 | f67aacf4d07d10c70c4edf77a428dd8e12b4acf7 | 02492b4531be9561f1a046176918560e248764df | refs/heads/master | 2023-05-19T10:52:20.454231 | 2020-05-08T17:14:02 | 2020-05-08T17:14:02 | 262,379,844 | 0 | 0 | null | 2021-06-11T07:19:46 | 2020-05-08T16:58:28 | Python | UTF-8 | Python | false | false | 390 | py | # Generated by Django 2.2.12 on 2020-05-08 17:14
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('home', '0002_load_initial_data'),
]
operations = [
migrations.AddField(
model_name='customtext',
name='dsc',
field=models.TextField(blank=True, null=True),
),
]
| [
"[email protected]"
] | |
7bbb32f702829f2d59b344eaa78c8b4d0ca39bee | 077e5ab67f2936b0aa531b8ee177ecf83a0a2e18 | /学习/6、第六部分 - 类和OOP/27、更多实例/person.py | 6e017f2de2ffafbd4cd188f7d42e79cd03844474 | [] | no_license | MKDevil/Python | 43ef6ebcc6a800b09b4fb570ef1401add410c51a | 17b8c0bdd2e5a534b89cdec0eb51bfcc17c91839 | refs/heads/master | 2022-02-02T08:34:06.622336 | 2022-01-28T08:52:25 | 2022-01-28T08:52:25 | 163,807,236 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,921 | py | #!/usr/bin/env python
# -*- coding:utf-8 -*-
from classtools import attrDisplay
class Person(attrDisplay):
"""普通员工"""
def __init__(self, name, job=None, pay=2500):
self.name = name
self.job = job
self.pay = pay
def lastName(self):
"""获取姓氏"""
return self.name.split()[-1]
def giveRaise(self, percent):
self.pay = round(self.pay * (1 + percent), 2)
# def __str__(self):
# return '[姓名：%+10s，工作：%+10s，工资：%+10s]' % (self.name, self.job, self.pay)
class Manager(Person):
"""经理"""
def __init__(self, name, pay=4000):
# return super().__init__(name, 'mgr', pay)
Person.__init__(self, name, 'mgr', pay)
def giveRaise(self, percent, bonus=0.1):
# self.pay = round(self.pay * (1 + percent + bonus), 2)
Person.giveRaise(self, percent + bonus) # 主动调用超类的方法，当超类修改后，也能适应修改
'''
class Manager(object):
"""经理，使用复合对象"""
def __init__(self, name, pay):
self.person = Person(name, 'mgr', pay)
def giveRaise(self, percent, bonus=0.1):
self.person.giveRaise(percent + bonus)
def __getattr__(self, attr):
return getattr(self.person, attr)
def __str__(self):
return str(self.person)
'''
class Department(object):
"""部门，使用复合对象"""
def __init__(self, *args):
self.members = list(args)
def addMember(self, person):
self.members.append(person)
def giveRaises(self, percent):
for person in self.members:
person.giveRaise(percent)
def showAll(self):
for person in self.members:
print(person)
if __name__ == '__main__':
'''
# 测试 Person 类
bob = Person('Bob Smith')
sue = Person('Sue Jones', 'dev', 3000)
print(bob)
print(sue)
sue.giveRaise(1 / 7)
print(sue)
print(sue.lastName())
# 测试 Manager 类
tom = Manager('Tom Jones', 5000)
print(tom.lastName())
tom.giveRaise(0.1)
print(tom)
# 多态
for object in (bob, sue, tom):
object.giveRaise(0.1)
print(object)
# 复合对象
development = Department(sue, bob)
development.addMember(tom)
development.giveRaises(0.1)
development.showAll()
# 内省工具
print(bob.__class__)
print(bob.__class__.__name__)
print(list(bob.__dict__.keys()))
for key in bob.__dict__:
print(key, ' => ', bob.__dict__[key])
for key in bob.__dict__:
print(key, ' => ', getattr(bob, key))
'''
bob = Person('Bob Smith')
sue = Person('Sue Jones', job='dev', pay=3000)
print(bob)
print(sue)
print(bob.lastName(), sue.lastName())
bob.giveRaise(0.1)
print(bob)
tom = Manager('Tom Jones', 4500)
tom.giveRaise(0.1)
print(tom.lastName())
print(tom)
| [
"[email protected]"
] | |
9b316915d237ae9a322ee2f294a3b7abc372d2d2 | c94f888541c0c430331110818ed7f3d6b27b788a | /ak_8f8a57bbd9814957987be7c9e8959a2a/python/antchain_sdk_ak_8f8a57bbd9814957987be7c9e8959a2a/client.py | fa63a344f932afcf33736da80b0f89b3bc6a6f54 | [
"MIT",
"Apache-2.0"
] | permissive | alipay/antchain-openapi-prod-sdk | 48534eb78878bd708a0c05f2fe280ba9c41d09ad | 5269b1f55f1fc19cf0584dc3ceea821d3f8f8632 | refs/heads/master | 2023-09-03T07:12:04.166131 | 2023-09-01T08:56:15 | 2023-09-01T08:56:15 | 275,521,177 | 9 | 10 | MIT | 2021-03-25T02:35:20 | 2020-06-28T06:22:14 | PHP | UTF-8 | Python | false | false | 22,950 | py | # -*- coding: utf-8 -*-
# This file is auto-generated, don't edit it. Thanks.
import time
from Tea.exceptions import TeaException, UnretryableException
from Tea.request import TeaRequest
from Tea.core import TeaCore
from antchain_alipay_util.antchain_utils import AntchainUtils
from typing import Dict
from antchain_sdk_ak_8f8a57bbd9814957987be7c9e8959a2a import models as ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models
from alibabacloud_tea_util.client import Client as UtilClient
from alibabacloud_tea_util import models as util_models
from alibabacloud_rpc_util.client import Client as RPCUtilClient
class Client:
_endpoint: str = None
_region_id: str = None
_access_key_id: str = None
_access_key_secret: str = None
_protocol: str = None
_user_agent: str = None
_read_timeout: int = None
_connect_timeout: int = None
_http_proxy: str = None
_https_proxy: str = None
_socks_5proxy: str = None
_socks_5net_work: str = None
_no_proxy: str = None
_max_idle_conns: int = None
_security_token: str = None
_max_idle_time_millis: int = None
_keep_alive_duration_millis: int = None
_max_requests: int = None
_max_requests_per_host: int = None
def __init__(
self,
config: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.Config,
):
"""
Init client with Config
@param config: config contains the necessary information to create a client
"""
if UtilClient.is_unset(config):
raise TeaException({
'code': 'ParameterMissing',
'message': "'config' can not be unset"
})
self._access_key_id = config.access_key_id
self._access_key_secret = config.access_key_secret
self._security_token = config.security_token
self._endpoint = config.endpoint
self._protocol = config.protocol
self._user_agent = config.user_agent
self._read_timeout = UtilClient.default_number(config.read_timeout, 20000)
self._connect_timeout = UtilClient.default_number(config.connect_timeout, 20000)
self._http_proxy = config.http_proxy
self._https_proxy = config.https_proxy
self._no_proxy = config.no_proxy
self._socks_5proxy = config.socks_5proxy
self._socks_5net_work = config.socks_5net_work
self._max_idle_conns = UtilClient.default_number(config.max_idle_conns, 60000)
self._max_idle_time_millis = UtilClient.default_number(config.max_idle_time_millis, 5)
self._keep_alive_duration_millis = UtilClient.default_number(config.keep_alive_duration_millis, 5000)
self._max_requests = UtilClient.default_number(config.max_requests, 100)
self._max_requests_per_host = UtilClient.default_number(config.max_requests_per_host, 100)
def do_request(
self,
version: str,
action: str,
protocol: str,
method: str,
pathname: str,
request: dict,
headers: Dict[str, str],
runtime: util_models.RuntimeOptions,
) -> dict:
"""
Encapsulate the request and invoke the network
@param action: api name
@param protocol: http or https
@param method: e.g. GET
@param pathname: pathname of every api
@param request: which contains request params
@param runtime: which controls some details of call api, such as retry times
@return: the response
"""
runtime.validate()
_runtime = {
'timeouted': 'retry',
'readTimeout': UtilClient.default_number(runtime.read_timeout, self._read_timeout),
'connectTimeout': UtilClient.default_number(runtime.connect_timeout, self._connect_timeout),
'httpProxy': UtilClient.default_string(runtime.http_proxy, self._http_proxy),
'httpsProxy': UtilClient.default_string(runtime.https_proxy, self._https_proxy),
'noProxy': UtilClient.default_string(runtime.no_proxy, self._no_proxy),
'maxIdleConns': UtilClient.default_number(runtime.max_idle_conns, self._max_idle_conns),
'maxIdleTimeMillis': self._max_idle_time_millis,
'keepAliveDurationMillis': self._keep_alive_duration_millis,
'maxRequests': self._max_requests,
'maxRequestsPerHost': self._max_requests_per_host,
'retry': {
'retryable': runtime.autoretry,
'maxAttempts': UtilClient.default_number(runtime.max_attempts, 3)
},
'backoff': {
'policy': UtilClient.default_string(runtime.backoff_policy, 'no'),
'period': UtilClient.default_number(runtime.backoff_period, 1)
},
'ignoreSSL': runtime.ignore_ssl
}
_last_request = None
_last_exception = None
_now = time.time()
_retry_times = 0
while TeaCore.allow_retry(_runtime.get('retry'), _retry_times, _now):
if _retry_times > 0:
_backoff_time = TeaCore.get_backoff_time(_runtime.get('backoff'), _retry_times)
if _backoff_time > 0:
TeaCore.sleep(_backoff_time)
_retry_times = _retry_times + 1
try:
_request = TeaRequest()
_request.protocol = UtilClient.default_string(self._protocol, protocol)
_request.method = method
_request.pathname = pathname
_request.query = {
'method': action,
'version': version,
'sign_type': 'HmacSHA1',
'req_time': AntchainUtils.get_timestamp(),
'req_msg_id': AntchainUtils.get_nonce(),
'access_key': self._access_key_id,
'base_sdk_version': 'TeaSDK-2.0',
'sdk_version': '1.0.0',
'_prod_code': 'ak_8f8a57bbd9814957987be7c9e8959a2a',
'_prod_channel': 'saas'
}
if not UtilClient.empty(self._security_token):
_request.query['security_token'] = self._security_token
_request.headers = TeaCore.merge({
'host': UtilClient.default_string(self._endpoint, 'openapi.antchain.antgroup.com'),
'user-agent': UtilClient.get_user_agent(self._user_agent)
}, headers)
tmp = UtilClient.anyify_map_value(RPCUtilClient.query(request))
_request.body = UtilClient.to_form_string(tmp)
_request.headers['content-type'] = 'application/x-www-form-urlencoded'
signed_param = TeaCore.merge(_request.query,
RPCUtilClient.query(request))
_request.query['sign'] = AntchainUtils.get_signature(signed_param, self._access_key_secret)
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
raw = UtilClient.read_as_string(_response.body)
obj = UtilClient.parse_json(raw)
res = UtilClient.assert_as_map(obj)
resp = UtilClient.assert_as_map(res.get('response'))
if AntchainUtils.has_error(raw, self._access_key_secret):
raise TeaException({
'message': resp.get('result_msg'),
'data': resp,
'code': resp.get('result_code')
})
return resp
except Exception as e:
if TeaCore.is_retryable(e):
_last_exception = e
continue
raise e
raise UnretryableException(_last_request, _last_exception)
async def do_request_async(
self,
version: str,
action: str,
protocol: str,
method: str,
pathname: str,
request: dict,
headers: Dict[str, str],
runtime: util_models.RuntimeOptions,
) -> dict:
"""
Encapsulate the request and invoke the network
@param action: api name
@param protocol: http or https
@param method: e.g. GET
@param pathname: pathname of every api
@param request: which contains request params
@param runtime: which controls some details of call api, such as retry times
@return: the response
"""
runtime.validate()
_runtime = {
'timeouted': 'retry',
'readTimeout': UtilClient.default_number(runtime.read_timeout, self._read_timeout),
'connectTimeout': UtilClient.default_number(runtime.connect_timeout, self._connect_timeout),
'httpProxy': UtilClient.default_string(runtime.http_proxy, self._http_proxy),
'httpsProxy': UtilClient.default_string(runtime.https_proxy, self._https_proxy),
'noProxy': UtilClient.default_string(runtime.no_proxy, self._no_proxy),
'maxIdleConns': UtilClient.default_number(runtime.max_idle_conns, self._max_idle_conns),
'maxIdleTimeMillis': self._max_idle_time_millis,
'keepAliveDurationMillis': self._keep_alive_duration_millis,
'maxRequests': self._max_requests,
'maxRequestsPerHost': self._max_requests_per_host,
'retry': {
'retryable': runtime.autoretry,
'maxAttempts': UtilClient.default_number(runtime.max_attempts, 3)
},
'backoff': {
'policy': UtilClient.default_string(runtime.backoff_policy, 'no'),
'period': UtilClient.default_number(runtime.backoff_period, 1)
},
'ignoreSSL': runtime.ignore_ssl
}
_last_request = None
_last_exception = None
_now = time.time()
_retry_times = 0
while TeaCore.allow_retry(_runtime.get('retry'), _retry_times, _now):
if _retry_times > 0:
_backoff_time = TeaCore.get_backoff_time(_runtime.get('backoff'), _retry_times)
if _backoff_time > 0:
TeaCore.sleep(_backoff_time)
_retry_times = _retry_times + 1
try:
_request = TeaRequest()
_request.protocol = UtilClient.default_string(self._protocol, protocol)
_request.method = method
_request.pathname = pathname
_request.query = {
'method': action,
'version': version,
'sign_type': 'HmacSHA1',
'req_time': AntchainUtils.get_timestamp(),
'req_msg_id': AntchainUtils.get_nonce(),
'access_key': self._access_key_id,
'base_sdk_version': 'TeaSDK-2.0',
'sdk_version': '1.0.0',
'_prod_code': 'ak_8f8a57bbd9814957987be7c9e8959a2a',
'_prod_channel': 'saas'
}
if not UtilClient.empty(self._security_token):
_request.query['security_token'] = self._security_token
_request.headers = TeaCore.merge({
'host': UtilClient.default_string(self._endpoint, 'openapi.antchain.antgroup.com'),
'user-agent': UtilClient.get_user_agent(self._user_agent)
}, headers)
tmp = UtilClient.anyify_map_value(RPCUtilClient.query(request))
_request.body = UtilClient.to_form_string(tmp)
_request.headers['content-type'] = 'application/x-www-form-urlencoded'
signed_param = TeaCore.merge(_request.query,
RPCUtilClient.query(request))
_request.query['sign'] = AntchainUtils.get_signature(signed_param, self._access_key_secret)
_last_request = _request
_response = await TeaCore.async_do_action(_request, _runtime)
raw = await UtilClient.read_as_string_async(_response.body)
obj = UtilClient.parse_json(raw)
res = UtilClient.assert_as_map(obj)
resp = UtilClient.assert_as_map(res.get('response'))
if AntchainUtils.has_error(raw, self._access_key_secret):
raise TeaException({
'message': resp.get('result_msg'),
'data': resp,
'code': resp.get('result_code')
})
return resp
except Exception as e:
if TeaCore.is_retryable(e):
_last_exception = e
continue
raise e
raise UnretryableException(_last_request, _last_exception)
def bind_demo_gateway_abc_test(
self,
request: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoGatewayAbcTestRequest,
) -> ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoGatewayAbcTestResponse:
"""
Description: test
Summary: test
"""
runtime = util_models.RuntimeOptions()
headers = {}
return self.bind_demo_gateway_abc_test_ex(request, headers, runtime)
async def bind_demo_gateway_abc_test_async(
self,
request: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoGatewayAbcTestRequest,
) -> ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoGatewayAbcTestResponse:
"""
Description: test
Summary: test
"""
runtime = util_models.RuntimeOptions()
headers = {}
return await self.bind_demo_gateway_abc_test_ex_async(request, headers, runtime)
def bind_demo_gateway_abc_test_ex(
self,
request: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoGatewayAbcTestRequest,
headers: Dict[str, str],
runtime: util_models.RuntimeOptions,
) -> ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoGatewayAbcTestResponse:
"""
Description: test
Summary: test
"""
UtilClient.validate_model(request)
return TeaCore.from_map(
ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoGatewayAbcTestResponse(),
self.do_request('1.0', 'demo.gateway.abc.test.bind', 'HTTPS', 'POST', f'/gateway.do', TeaCore.to_map(request), headers, runtime)
)
async def bind_demo_gateway_abc_test_ex_async(
self,
request: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoGatewayAbcTestRequest,
headers: Dict[str, str],
runtime: util_models.RuntimeOptions,
) -> ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoGatewayAbcTestResponse:
"""
Description: test
Summary: test
"""
UtilClient.validate_model(request)
return TeaCore.from_map(
ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoGatewayAbcTestResponse(),
await self.do_request_async('1.0', 'demo.gateway.abc.test.bind', 'HTTPS', 'POST', f'/gateway.do', TeaCore.to_map(request), headers, runtime)
)
def bind_demo_aaa_bbb_ccc(
self,
request: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAaaBbbCccRequest,
) -> ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAaaBbbCccResponse:
"""
Description: 自动化测试创建，用于测试新建&修改功能
Summary: 自动化测试创建，用于测试新建&修改功能
"""
runtime = util_models.RuntimeOptions()
headers = {}
return self.bind_demo_aaa_bbb_ccc_ex(request, headers, runtime)
async def bind_demo_aaa_bbb_ccc_async(
self,
request: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAaaBbbCccRequest,
) -> ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAaaBbbCccResponse:
"""
Description: 自动化测试创建，用于测试新建&修改功能
Summary: 自动化测试创建，用于测试新建&修改功能
"""
runtime = util_models.RuntimeOptions()
headers = {}
return await self.bind_demo_aaa_bbb_ccc_ex_async(request, headers, runtime)
def bind_demo_aaa_bbb_ccc_ex(
self,
request: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAaaBbbCccRequest,
headers: Dict[str, str],
runtime: util_models.RuntimeOptions,
) -> ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAaaBbbCccResponse:
"""
Description: 自动化测试创建，用于测试新建&修改功能
Summary: 自动化测试创建，用于测试新建&修改功能
"""
UtilClient.validate_model(request)
return TeaCore.from_map(
ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAaaBbbCccResponse(),
self.do_request('1.0', 'demo.aaa.bbb.ccc.bind', 'HTTPS', 'POST', f'/gateway.do', TeaCore.to_map(request), headers, runtime)
)
async def bind_demo_aaa_bbb_ccc_ex_async(
self,
request: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAaaBbbCccRequest,
headers: Dict[str, str],
runtime: util_models.RuntimeOptions,
) -> ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAaaBbbCccResponse:
"""
Description: 自动化测试创建，用于测试新建&修改功能
Summary: 自动化测试创建，用于测试新建&修改功能
"""
UtilClient.validate_model(request)
return TeaCore.from_map(
ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAaaBbbCccResponse(),
await self.do_request_async('1.0', 'demo.aaa.bbb.ccc.bind', 'HTTPS', 'POST', f'/gateway.do', TeaCore.to_map(request), headers, runtime)
)
def bind_demo_asd_asd_asd(
self,
request: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAsdAsdAsdRequest,
) -> ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAsdAsdAsdResponse:
"""
Description: asd
Summary: asd
"""
runtime = util_models.RuntimeOptions()
headers = {}
return self.bind_demo_asd_asd_asd_ex(request, headers, runtime)
async def bind_demo_asd_asd_asd_async(
self,
request: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAsdAsdAsdRequest,
) -> ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAsdAsdAsdResponse:
"""
Description: asd
Summary: asd
"""
runtime = util_models.RuntimeOptions()
headers = {}
return await self.bind_demo_asd_asd_asd_ex_async(request, headers, runtime)
def bind_demo_asd_asd_asd_ex(
self,
request: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAsdAsdAsdRequest,
headers: Dict[str, str],
runtime: util_models.RuntimeOptions,
) -> ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAsdAsdAsdResponse:
"""
Description: asd
Summary: asd
"""
UtilClient.validate_model(request)
return TeaCore.from_map(
ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAsdAsdAsdResponse(),
self.do_request('1.0', 'demo.asd.asd.asd.bind', 'HTTPS', 'POST', f'/gateway.do', TeaCore.to_map(request), headers, runtime)
)
async def bind_demo_asd_asd_asd_ex_async(
self,
request: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAsdAsdAsdRequest,
headers: Dict[str, str],
runtime: util_models.RuntimeOptions,
) -> ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAsdAsdAsdResponse:
"""
Description: asd
Summary: asd
"""
UtilClient.validate_model(request)
return TeaCore.from_map(
ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.BindDemoAsdAsdAsdResponse(),
await self.do_request_async('1.0', 'demo.asd.asd.asd.bind', 'HTTPS', 'POST', f'/gateway.do', TeaCore.to_map(request), headers, runtime)
)
def query_demo_abc_abc_abc(
self,
request: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.QueryDemoAbcAbcAbcRequest,
) -> ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.QueryDemoAbcAbcAbcResponse:
"""
Description: 自动化测试创建,用于测试API的修改
Summary: 自动化测试创建,用于测试API的修改勿动
"""
runtime = util_models.RuntimeOptions()
headers = {}
return self.query_demo_abc_abc_abc_ex(request, headers, runtime)
async def query_demo_abc_abc_abc_async(
self,
request: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.QueryDemoAbcAbcAbcRequest,
) -> ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.QueryDemoAbcAbcAbcResponse:
"""
Description: 自动化测试创建,用于测试API的修改
Summary: 自动化测试创建,用于测试API的修改勿动
"""
runtime = util_models.RuntimeOptions()
headers = {}
return await self.query_demo_abc_abc_abc_ex_async(request, headers, runtime)
def query_demo_abc_abc_abc_ex(
self,
request: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.QueryDemoAbcAbcAbcRequest,
headers: Dict[str, str],
runtime: util_models.RuntimeOptions,
) -> ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.QueryDemoAbcAbcAbcResponse:
"""
Description: 自动化测试创建,用于测试API的修改
Summary: 自动化测试创建,用于测试API的修改勿动
"""
UtilClient.validate_model(request)
return TeaCore.from_map(
ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.QueryDemoAbcAbcAbcResponse(),
self.do_request('1.0', 'demo.abc.abc.abc.query', 'HTTPS', 'POST', f'/gateway.do', TeaCore.to_map(request), headers, runtime)
)
async def query_demo_abc_abc_abc_ex_async(
self,
request: ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.QueryDemoAbcAbcAbcRequest,
headers: Dict[str, str],
runtime: util_models.RuntimeOptions,
) -> ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.QueryDemoAbcAbcAbcResponse:
"""
Description: 自动化测试创建,用于测试API的修改
Summary: 自动化测试创建,用于测试API的修改勿动
"""
UtilClient.validate_model(request)
return TeaCore.from_map(
ak__8f_8a_57bbd_9814957987be_7c_9e_8959a_2a_models.QueryDemoAbcAbcAbcResponse(),
await self.do_request_async('1.0', 'demo.abc.abc.abc.query', 'HTTPS', 'POST', f'/gateway.do', TeaCore.to_map(request), headers, runtime)
)
| [
"[email protected]"
] | |
ff3fa03a5a823bcdfbfd596ca244e41b606b7c82 | 32ba2c5e29ef79de1a2fc86102971e58f9530d9e | /baiduNLP.py | fe63b9695ad90f41eeee04163500ff79a52b7246 | [] | no_license | xiaogaogaoxiao/newspaper_sentiment_analysis | bacdbcc6b30ed55a9c14b06db90646ca82df7529 | e045bec753355be604c78fb7a5909583a79641f0 | refs/heads/master | 2020-05-01T09:59:55.621236 | 2018-03-24T08:30:44 | 2018-03-24T08:30:44 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 889 | py | # coding:gbk
import urllib, urllib2, sys
import requests
import ssl
import json
import time
def baidu(data):
url = 'https://aip.baidubce.com/rpc/2.0/nlp/v1/sentiment_classify?access_token=24.24caa83c34e5d01f2e5fb80752adae8c.2592000.1522201224.282335-10469707'
post_data = "{\"text\":\"" + data + "\"}"
request = urllib2.Request(url, post_data)
request.add_header('Content-Type', 'application/json')
try:
response = urllib2.urlopen(request)
content = response.read()
content2=json.loads(content.decode('gbk'))
if (content.find('\"error_msg\"') == -1):
content2=content2['items'][0]
return content2['positive_prob'],content2['negative_prob'],content2['confidence'],content2['sentiment']
else:
print content2
return 0,0,0,0
except:
return 0,0,0,0
| [
"[email protected]"
] | |
b5092c07a1d16199df50b3411d1fa9fb343aa9d6 | 08a329d07172a384be41eb58a0586032b18787d2 | /property5.py | 6c70c6b519c8e644b2374747126a94e17fef837f | [] | no_license | atsuhisa-i/Python_study1 | 9bc39d058fe8bdd00adb35324758ad8fa08f4ca1 | 439a654f09e81208658355d99c8ce1c3cd4bcc4e | refs/heads/main | 2023-04-06T12:44:12.099067 | 2021-04-14T13:24:56 | 2021-04-14T13:24:56 | 348,309,405 | 0 | 0 | null | 2021-04-14T13:24:57 | 2021-03-16T10:45:48 | Python | UTF-8 | Python | false | false | 443 | py | class Item:
def __init__(self, name, price):
self.__name = name
self.__price = price
@property
def name(self):
return self.__name
@property
def price(self):
return self.__price
@price.setter
def price(self, value):
self.__price = max(value, 0)
x = Item('burger', 100)
print(x.name, x.price)
x.price = 110
print(x.name, x.price)
x.price = -100
print(x.name, x.price) | [
"[email protected]"
] | |
02fbb2f701bb7717474edffccb64e578482f08af | 717f642297a1cee12500d4160df8b41d7bcaa4b7 | /exec -l /bin/bash/google-cloud-sdk/.install/.backup/lib/surface/firestore/operations/__init__.py | b99c90ceeaaff592a335c2a367f4f1580e072a1f | [
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0"
] | permissive | vrielsdenies/Participant-app | 8b5199bfb401741e76af3cfd86ca8987c7a25cb3 | a9348c6d7937f8b210a7c6056c1aa693a0e44c73 | refs/heads/master | 2021-07-08T15:38:01.125590 | 2019-01-07T05:40:13 | 2019-01-07T05:40:13 | 147,900,558 | 2 | 1 | null | 2020-07-24T20:13:28 | 2018-09-08T04:22:31 | Python | UTF-8 | Python | false | false | 929 | py | # -*- coding: utf-8 -*- #
# Copyright 2018 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""The command group for Cloud Firestore operations."""
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
from googlecloudsdk.calliope import base
class Operations(base.Group):
"""Manage Long Running Operations for Cloud Firestore."""
pass
| [
"[email protected]"
] | |
b9d18633f9ddc9a7618e0aa774d56bfcd20c0660 | c9ddbdb5678ba6e1c5c7e64adf2802ca16df778c | /cases/synthetic/coverage-big-2913.py | d5a771e61ef7cff808546e6be8568a97a309c260 | [] | no_license | Virtlink/ccbench-chocopy | c3f7f6af6349aff6503196f727ef89f210a1eac8 | c7efae43bf32696ee2b2ee781bdfe4f7730dec3f | refs/heads/main | 2023-04-07T15:07:12.464038 | 2022-02-03T15:42:39 | 2022-02-03T15:42:39 | 451,969,776 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 13,351 | py | count:int = 0
count2:int = 0
count3:int = 0
count4:int = 0
count5:int = 0
def foo(s: str) -> int:
return len(s)
def foo2(s: str, s2: str) -> int:
return len(s)
def foo3(s: str, s2: str, s3: str) -> int:
return len(s)
def foo4(s: str, s2: str, s3: str, s4: str) -> int:
return len(s)
def foo5(s: str, s2: str, s3: str, s4: str, s5: str) -> int:
return len(s)
class bar(object):
p: bool = True
def baz(self:"bar", xx: [int]) -> str:
global count
x:int = 0
y:int = 1
def qux(y: int) -> object:
nonlocal x
if x > y:
x = -1
for x in xx:
self.p = x == 2
qux(0) # Yay! ChocoPy
count = count + 1
while x <= 0:
if self.p:
xx[0] = xx[1]
self.p = not self.p
x = x + 1
elif foo("Long"[0]) == 1:
self.p = self is None
return "Nope"
class bar2(object):
p: bool = True
p2: bool = True
def baz(self:"bar2", xx: [int]) -> str:
global count
x:int = 0
y:int = 1
def qux(y: int) -> object:
nonlocal x
if x > y:
x = -1
for x in xx:
self.p = x == 2
qux(0) # Yay! ChocoPy
count = count + 1
while x <= 0:
if self.p:
xx[0] = xx[1]
self.p = not self.p
x = x + 1
elif foo("Long"[0]) == 1:
self.p = self is None
return "Nope"
def baz2(self:"bar2", xx: [int], xx2: [int]) -> str:
global count
x:int = 0
x2:int = 0
y:int = 1
y2:int = 1
def qux(y: int) -> object:
nonlocal x
if x > y:
x = -1
def qux2(y: int, y2: int) -> object:
nonlocal x
nonlocal x2
if x > y:
x = -1
for x in xx:
self.p = x == 2
qux(0) # Yay! ChocoPy
count = count + 1
while x <= 0:
if self.p:
xx[0] = xx[1]
self.p = not self.p
x = x + 1
elif foo("Long"[0]) == 1:
self.p = self is None
return "Nope"
class bar3(object):
p: bool = True
p2: bool = True
p3: bool = True
def baz(self:"bar3", xx: [int]) -> str:
global count
x:int = 0
y:int = 1
def qux(y: int) -> object:
nonlocal x
if x > y:
x = -1
for x in xx:
self.p = x == 2
qux(0) # Yay! ChocoPy
count = count + 1
while x <= 0:
if self.p:
xx[0] = xx[1]
self.p = not self.p
x = x + 1
elif foo("Long"[0]) == 1:
self.p = self is None
return "Nope"
def baz2(self:"bar3", xx: [int], xx2: [int]) -> str:
global count
x:int = 0
x2:int = 0
y:int = 1
y2:int = 1
def qux(y: int) -> object:
nonlocal x
if x > y:
x = -1
def qux2(y: int, y2: int) -> object:
nonlocal x
nonlocal x2
if x > y:
x = -1
for x in xx:
self.p = x == 2
qux(0) # Yay! ChocoPy
count = count + 1
while x <= 0:
if self.p:
xx[0] = xx[1]
self.p = not self.p
x = x + 1
elif foo("Long"[0]) == 1:
self.p = self is None
return "Nope"
def baz3(self:"bar3", xx: [int], xx2: [int], xx3: [int]) -> str:
global count
x:int = 0
x2:int = 0
x3:int = 0
y:int = 1
y2:int = 1
y3:int = 1
def qux(y: int) -> object:
nonlocal x
if x > y:
x = -1
def qux2(y: int, y2: int) -> object:
nonlocal x
nonlocal x2
if x > y:
x = -1
def qux3(y: int, y2: int, y3: int) -> object:
nonlocal x
nonlocal x2
nonlocal x3
if x > y:
x = -1
for x in xx:
self.p = x == 2
qux(0) # Yay! ChocoPy
count = count + 1
while x <= 0:
if self.p:
xx[0] = xx[1]
self.p = not self.p
x = x + 1
elif foo("Long"[0]) == 1:
self.p = self is None
return "Nope"
class bar4(object):
p: bool = True
p2: bool = True
p3: bool = True
p4: bool = True
def baz(self:"bar4", xx: [int]) -> str:
global count
x:int = 0
y:int = 1
def qux(y: int) -> object:
nonlocal x
if x > y:
x = -1
for x in xx:
self.p = x == 2
qux(0) # Yay! ChocoPy
count = count + 1
while x <= 0:
if self.p:
xx[0] = xx[1]
self.p = not self.p
x = x + 1
elif foo("Long"[0]) == 1:
self.p = self is None
return "Nope"
def baz2(self:"bar4", xx: [int], xx2: [int]) -> str:
global count
x:int = 0
x2:int = 0
y:int = 1
y2:int = 1
def qux(y: int) -> object:
nonlocal x
if x > y:
x = -1
def qux2(y: int, y2: int) -> object:
nonlocal x
nonlocal x2
if x > y:
x = -1
for x in xx:
self.p = x == 2
qux(0) # Yay! ChocoPy
count = count + 1
while x <= 0:
if self.p:
xx[0] = xx[1]
self.p = not self.p
x = x + 1
elif foo("Long"[0]) == 1:
self.p = self is None
return "Nope"
def baz3(self:"bar4", xx: [int], xx2: [int], xx3: [int]) -> str:
global count
x:int = 0
x2:int = 0
x3:int = 0
y:int = 1
y2:int = 1
y3:int = 1
def qux(y: int) -> object:
nonlocal x
if x > y:
x = -1
def qux2(y: int, y2: int) -> object:
nonlocal x
nonlocal x2
if x > y:
x = -1
def qux3(y: int, y2: int, y3: int) -> object:
nonlocal x
nonlocal x2
nonlocal x3
if x > y:
x = -1
for x in xx:
self.p = x == 2
qux(0) # Yay! ChocoPy
count = count + 1
while x <= 0:
if self.p:
xx[0] = xx[1]
self.p = not self.p
x = x + 1
elif foo("Long"[0]) == 1:
self.p = self is None
return "Nope"
def baz4(self:"bar4", xx: [int], xx2: [int], xx3: [int], xx4: [int]) -> str:
global count
x:int = 0
x2:int = 0
x3:int = 0
x4:int = 0
y:int = 1
y2:int = 1
y3:int = 1
y4:int = 1
def qux(y: int) -> object:
nonlocal x
if x > $Exp:
x = -1
def qux2(y: int, y2: int) -> object:
nonlocal x
nonlocal x2
if x > y:
x = -1
def qux3(y: int, y2: int, y3: int) -> object:
nonlocal x
nonlocal x2
nonlocal x3
if x > y:
x = -1
def qux4(y: int, y2: int, y3: int, y4: int) -> object:
nonlocal x
nonlocal x2
nonlocal x3
nonlocal x4
if x > y:
x = -1
for x in xx:
self.p = x == 2
qux(0) # Yay! ChocoPy
count = count + 1
while x <= 0:
if self.p:
xx[0] = xx[1]
self.p = not self.p
x = x + 1
elif foo("Long"[0]) == 1:
self.p = self is None
return "Nope"
class bar5(object):
p: bool = True
p2: bool = True
p3: bool = True
p4: bool = True
p5: bool = True
def baz(self:"bar5", xx: [int]) -> str:
global count
x:int = 0
y:int = 1
def qux(y: int) -> object:
nonlocal x
if x > y:
x = -1
for x in xx:
self.p = x == 2
qux(0) # Yay! ChocoPy
count = count + 1
while x <= 0:
if self.p:
xx[0] = xx[1]
self.p = not self.p
x = x + 1
elif foo("Long"[0]) == 1:
self.p = self is None
return "Nope"
def baz2(self:"bar5", xx: [int], xx2: [int]) -> str:
global count
x:int = 0
x2:int = 0
y:int = 1
y2:int = 1
def qux(y: int) -> object:
nonlocal x
if x > y:
x = -1
def qux2(y: int, y2: int) -> object:
nonlocal x
nonlocal x2
if x > y:
x = -1
for x in xx:
self.p = x == 2
qux(0) # Yay! ChocoPy
count = count + 1
while x <= 0:
if self.p:
xx[0] = xx[1]
self.p = not self.p
x = x + 1
elif foo("Long"[0]) == 1:
self.p = self is None
return "Nope"
def baz3(self:"bar5", xx: [int], xx2: [int], xx3: [int]) -> str:
global count
x:int = 0
x2:int = 0
x3:int = 0
y:int = 1
y2:int = 1
y3:int = 1
def qux(y: int) -> object:
nonlocal x
if x > y:
x = -1
def qux2(y: int, y2: int) -> object:
nonlocal x
nonlocal x2
if x > y:
x = -1
def qux3(y: int, y2: int, y3: int) -> object:
nonlocal x
nonlocal x2
nonlocal x3
if x > y:
x = -1
for x in xx:
self.p = x == 2
qux(0) # Yay! ChocoPy
count = count + 1
while x <= 0:
if self.p:
xx[0] = xx[1]
self.p = not self.p
x = x + 1
elif foo("Long"[0]) == 1:
self.p = self is None
return "Nope"
def baz4(self:"bar5", xx: [int], xx2: [int], xx3: [int], xx4: [int]) -> str:
global count
x:int = 0
x2:int = 0
x3:int = 0
x4:int = 0
y:int = 1
y2:int = 1
y3:int = 1
y4:int = 1
def qux(y: int) -> object:
nonlocal x
if x > y:
x = -1
def qux2(y: int, y2: int) -> object:
nonlocal x
nonlocal x2
if x > y:
x = -1
def qux3(y: int, y2: int, y3: int) -> object:
nonlocal x
nonlocal x2
nonlocal x3
if x > y:
x = -1
def qux4(y: int, y2: int, y3: int, y4: int) -> object:
nonlocal x
nonlocal x2
nonlocal x3
nonlocal x4
if x > y:
x = -1
for x in xx:
self.p = x == 2
qux(0) # Yay! ChocoPy
count = count + 1
while x <= 0:
if self.p:
xx[0] = xx[1]
self.p = not self.p
x = x + 1
elif foo("Long"[0]) == 1:
self.p = self is None
return "Nope"
def baz5(self:"bar5", xx: [int], xx2: [int], xx3: [int], xx4: [int], xx5: [int]) -> str:
global count
x:int = 0
x2:int = 0
x3:int = 0
x4:int = 0
x5:int = 0
y:int = 1
y2:int = 1
y3:int = 1
y4:int = 1
y5:int = 1
def qux(y: int) -> object:
nonlocal x
if x > y:
x = -1
def qux2(y: int, y2: int) -> object:
nonlocal x
nonlocal x2
if x > y:
x = -1
def qux3(y: int, y2: int, y3: int) -> object:
nonlocal x
nonlocal x2
nonlocal x3
if x > y:
x = -1
def qux4(y: int, y2: int, y3: int, y4: int) -> object:
nonlocal x
nonlocal x2
nonlocal x3
nonlocal x4
if x > y:
x = -1
def qux5(y: int, y2: int, y3: int, y4: int, y5: int) -> object:
nonlocal x
nonlocal x2
nonlocal x3
nonlocal x4
nonlocal x5
if x > y:
x = -1
for x in xx:
self.p = x == 2
qux(0) # Yay! ChocoPy
count = count + 1
while x <= 0:
if self.p:
xx[0] = xx[1]
self.p = not self.p
x = x + 1
elif foo("Long"[0]) == 1:
self.p = self is None
return "Nope"
print(bar().baz([1,2]))
| [
"[email protected]"
] | |
2965894bc962e938d889e44a35a394f2047b74ea | ba56c31788b3fed66bedb7489f21277f37999fa2 | /apphosting/sandbox/main.py | 290ff8fc0739fd29e8c7a3c42f6ee93ee0c5b5ca | [] | no_license | tokibito/wsgi-apphosting | 7f3df53fc1a9b979ff27f0eb1bbe3bc6b06fc55b | d21b53295f12a6b90960a7841ec3b4d1057d0162 | refs/heads/master | 2020-07-25T07:38:40.059563 | 2010-06-14T14:42:52 | 2010-06-14T14:42:52 | 208,217,512 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,615 | py | #coding:utf-8
#アプリケーションのランナー
import sys
from datetime import datetime
from apphosting import const
from apphosting.sandbox import utils
class Runner(object):
"""
ランナーはプロセスプールで保持される
1プロセス1ランナー
TODO:複数のプロセスで同じランナーが起動する可能性
providerはアプリケーション提供モジュール
"""
def __init__(self, name, provider, server_config, pool_conn, runner_conn):
self.provider = utils.import_module(provider)
self._server_config = server_config
self._application = self.provider.get_application(name, self._server_config)
self._pool_conn = pool_conn
self._runner_conn = runner_conn
self.proc = None
self.suspended = False
self.ctime = datetime.now()
self.utime = datetime.now()
self.processed = 0
def __call__(self):
while not self.suspended:
# environパラメータを待ちうけ
environ = self._runner_conn.recv()
signal = environ.get('RUNNER_SIGNAL')
# 停止
if signal == const.RUNNER_SIGNAL_KILL:
self.suspended = True
continue
# 情報取得
elif signal == const.RUNNER_SIGNAL_INFO:
self._runner_conn.send({
'ctime': self.ctime,
'utime': self.utime,
'processed': self.processed
})
continue
# アプリケーションを実行
status, headers, resp = self.main(environ)
# start_resopnseの結果を返す
self._runner_conn.send([status, headers])
self._runner_conn.send(resp)
# 実行回数カウント
self.processed += 1
# 最後に実行した時間
self.utime = datetime.now()
# サスペンドされた場合パイプを閉じる
self._runner_conn.close()
sys.exit(0)
def main(self, environ):
"""
メインハンドラ
アプリケーションの実行が完全に終わってから結果を返す
"""
start_info = {
'status': '',
'headers': ()
}
def _start_response(status, headers, exc_info=None):
start_info['status'] = status
start_info['headers'] = headers
response = self._application(environ, _start_response)
return start_info['status'], start_info['headers'], ''.join(response)
| [
"[email protected]"
] | |
9599bfc03abaf70c558386fe45b2f15e59fb2e9e | 5e6d8b9989247801718dd1f10009f0f7f54c1eb4 | /sdk/python/pulumi_azure_native/network/v20210201/virtual_network_peering.py | c51961fba32f832aee8a62f771181490ec4f294e | [
"BSD-3-Clause",
"Apache-2.0"
] | permissive | vivimouret29/pulumi-azure-native | d238a8f91688c9bf09d745a7280b9bf2dd6d44e0 | 1cbd988bcb2aa75a83e220cb5abeb805d6484fce | refs/heads/master | 2023-08-26T05:50:40.560691 | 2021-10-21T09:25:07 | 2021-10-21T09:25:07 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 38,199 | py | # coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from ... import _utilities
from . import outputs
from ._enums import *
from ._inputs import *
__all__ = ['VirtualNetworkPeeringInitArgs', 'VirtualNetworkPeering']
@pulumi.input_type
class VirtualNetworkPeeringInitArgs:
def __init__(__self__, *,
resource_group_name: pulumi.Input[str],
virtual_network_name: pulumi.Input[str],
allow_forwarded_traffic: Optional[pulumi.Input[bool]] = None,
allow_gateway_transit: Optional[pulumi.Input[bool]] = None,
allow_virtual_network_access: Optional[pulumi.Input[bool]] = None,
do_not_verify_remote_gateways: Optional[pulumi.Input[bool]] = None,
id: Optional[pulumi.Input[str]] = None,
name: Optional[pulumi.Input[str]] = None,
peering_state: Optional[pulumi.Input[Union[str, 'VirtualNetworkPeeringState']]] = None,
peering_sync_level: Optional[pulumi.Input[Union[str, 'VirtualNetworkPeeringLevel']]] = None,
remote_address_space: Optional[pulumi.Input['AddressSpaceArgs']] = None,
remote_bgp_communities: Optional[pulumi.Input['VirtualNetworkBgpCommunitiesArgs']] = None,
remote_virtual_network: Optional[pulumi.Input['SubResourceArgs']] = None,
remote_virtual_network_address_space: Optional[pulumi.Input['AddressSpaceArgs']] = None,
sync_remote_address_space: Optional[pulumi.Input[str]] = None,
type: Optional[pulumi.Input[str]] = None,
use_remote_gateways: Optional[pulumi.Input[bool]] = None,
virtual_network_peering_name: Optional[pulumi.Input[str]] = None):
"""
The set of arguments for constructing a VirtualNetworkPeering resource.
:param pulumi.Input[str] resource_group_name: The name of the resource group.
:param pulumi.Input[str] virtual_network_name: The name of the virtual network.
:param pulumi.Input[bool] allow_forwarded_traffic: Whether the forwarded traffic from the VMs in the local virtual network will be allowed/disallowed in remote virtual network.
:param pulumi.Input[bool] allow_gateway_transit: If gateway links can be used in remote virtual networking to link to this virtual network.
:param pulumi.Input[bool] allow_virtual_network_access: Whether the VMs in the local virtual network space would be able to access the VMs in remote virtual network space.
:param pulumi.Input[bool] do_not_verify_remote_gateways: If we need to verify the provisioning state of the remote gateway.
:param pulumi.Input[str] id: Resource ID.
:param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
:param pulumi.Input[Union[str, 'VirtualNetworkPeeringState']] peering_state: The status of the virtual network peering.
:param pulumi.Input[Union[str, 'VirtualNetworkPeeringLevel']] peering_sync_level: The peering sync status of the virtual network peering.
:param pulumi.Input['AddressSpaceArgs'] remote_address_space: The reference to the address space peered with the remote virtual network.
:param pulumi.Input['VirtualNetworkBgpCommunitiesArgs'] remote_bgp_communities: The reference to the remote virtual network's Bgp Communities.
:param pulumi.Input['SubResourceArgs'] remote_virtual_network: The reference to the remote virtual network. The remote virtual network can be in the same or different region (preview). See here to register for the preview and learn more (https://docs.microsoft.com/en-us/azure/virtual-network/virtual-network-create-peering).
:param pulumi.Input['AddressSpaceArgs'] remote_virtual_network_address_space: The reference to the current address space of the remote virtual network.
:param pulumi.Input[str] sync_remote_address_space: Parameter indicates the intention to sync the peering with the current address space on the remote vNet after it's updated.
:param pulumi.Input[str] type: Resource type.
:param pulumi.Input[bool] use_remote_gateways: If remote gateways can be used on this virtual network. If the flag is set to true, and allowGatewayTransit on remote peering is also true, virtual network will use gateways of remote virtual network for transit. Only one peering can have this flag set to true. This flag cannot be set if virtual network already has a gateway.
:param pulumi.Input[str] virtual_network_peering_name: The name of the peering.
"""
pulumi.set(__self__, "resource_group_name", resource_group_name)
pulumi.set(__self__, "virtual_network_name", virtual_network_name)
if allow_forwarded_traffic is not None:
pulumi.set(__self__, "allow_forwarded_traffic", allow_forwarded_traffic)
if allow_gateway_transit is not None:
pulumi.set(__self__, "allow_gateway_transit", allow_gateway_transit)
if allow_virtual_network_access is not None:
pulumi.set(__self__, "allow_virtual_network_access", allow_virtual_network_access)
if do_not_verify_remote_gateways is not None:
pulumi.set(__self__, "do_not_verify_remote_gateways", do_not_verify_remote_gateways)
if id is not None:
pulumi.set(__self__, "id", id)
if name is not None:
pulumi.set(__self__, "name", name)
if peering_state is not None:
pulumi.set(__self__, "peering_state", peering_state)
if peering_sync_level is not None:
pulumi.set(__self__, "peering_sync_level", peering_sync_level)
if remote_address_space is not None:
pulumi.set(__self__, "remote_address_space", remote_address_space)
if remote_bgp_communities is not None:
pulumi.set(__self__, "remote_bgp_communities", remote_bgp_communities)
if remote_virtual_network is not None:
pulumi.set(__self__, "remote_virtual_network", remote_virtual_network)
if remote_virtual_network_address_space is not None:
pulumi.set(__self__, "remote_virtual_network_address_space", remote_virtual_network_address_space)
if sync_remote_address_space is not None:
pulumi.set(__self__, "sync_remote_address_space", sync_remote_address_space)
if type is not None:
pulumi.set(__self__, "type", type)
if use_remote_gateways is not None:
pulumi.set(__self__, "use_remote_gateways", use_remote_gateways)
if virtual_network_peering_name is not None:
pulumi.set(__self__, "virtual_network_peering_name", virtual_network_peering_name)
@property
@pulumi.getter(name="resourceGroupName")
def resource_group_name(self) -> pulumi.Input[str]:
"""
The name of the resource group.
"""
return pulumi.get(self, "resource_group_name")
@resource_group_name.setter
def resource_group_name(self, value: pulumi.Input[str]):
pulumi.set(self, "resource_group_name", value)
@property
@pulumi.getter(name="virtualNetworkName")
def virtual_network_name(self) -> pulumi.Input[str]:
"""
The name of the virtual network.
"""
return pulumi.get(self, "virtual_network_name")
@virtual_network_name.setter
def virtual_network_name(self, value: pulumi.Input[str]):
pulumi.set(self, "virtual_network_name", value)
@property
@pulumi.getter(name="allowForwardedTraffic")
def allow_forwarded_traffic(self) -> Optional[pulumi.Input[bool]]:
"""
Whether the forwarded traffic from the VMs in the local virtual network will be allowed/disallowed in remote virtual network.
"""
return pulumi.get(self, "allow_forwarded_traffic")
@allow_forwarded_traffic.setter
def allow_forwarded_traffic(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "allow_forwarded_traffic", value)
@property
@pulumi.getter(name="allowGatewayTransit")
def allow_gateway_transit(self) -> Optional[pulumi.Input[bool]]:
"""
If gateway links can be used in remote virtual networking to link to this virtual network.
"""
return pulumi.get(self, "allow_gateway_transit")
@allow_gateway_transit.setter
def allow_gateway_transit(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "allow_gateway_transit", value)
@property
@pulumi.getter(name="allowVirtualNetworkAccess")
def allow_virtual_network_access(self) -> Optional[pulumi.Input[bool]]:
"""
Whether the VMs in the local virtual network space would be able to access the VMs in remote virtual network space.
"""
return pulumi.get(self, "allow_virtual_network_access")
@allow_virtual_network_access.setter
def allow_virtual_network_access(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "allow_virtual_network_access", value)
@property
@pulumi.getter(name="doNotVerifyRemoteGateways")
def do_not_verify_remote_gateways(self) -> Optional[pulumi.Input[bool]]:
"""
If we need to verify the provisioning state of the remote gateway.
"""
return pulumi.get(self, "do_not_verify_remote_gateways")
@do_not_verify_remote_gateways.setter
def do_not_verify_remote_gateways(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "do_not_verify_remote_gateways", value)
@property
@pulumi.getter
def id(self) -> Optional[pulumi.Input[str]]:
"""
Resource ID.
"""
return pulumi.get(self, "id")
@id.setter
def id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "id", value)
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
"""
The name of the resource that is unique within a resource group. This name can be used to access the resource.
"""
return pulumi.get(self, "name")
@name.setter
def name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "name", value)
@property
@pulumi.getter(name="peeringState")
def peering_state(self) -> Optional[pulumi.Input[Union[str, 'VirtualNetworkPeeringState']]]:
"""
The status of the virtual network peering.
"""
return pulumi.get(self, "peering_state")
@peering_state.setter
def peering_state(self, value: Optional[pulumi.Input[Union[str, 'VirtualNetworkPeeringState']]]):
pulumi.set(self, "peering_state", value)
@property
@pulumi.getter(name="peeringSyncLevel")
def peering_sync_level(self) -> Optional[pulumi.Input[Union[str, 'VirtualNetworkPeeringLevel']]]:
"""
The peering sync status of the virtual network peering.
"""
return pulumi.get(self, "peering_sync_level")
@peering_sync_level.setter
def peering_sync_level(self, value: Optional[pulumi.Input[Union[str, 'VirtualNetworkPeeringLevel']]]):
pulumi.set(self, "peering_sync_level", value)
@property
@pulumi.getter(name="remoteAddressSpace")
def remote_address_space(self) -> Optional[pulumi.Input['AddressSpaceArgs']]:
"""
The reference to the address space peered with the remote virtual network.
"""
return pulumi.get(self, "remote_address_space")
@remote_address_space.setter
def remote_address_space(self, value: Optional[pulumi.Input['AddressSpaceArgs']]):
pulumi.set(self, "remote_address_space", value)
@property
@pulumi.getter(name="remoteBgpCommunities")
def remote_bgp_communities(self) -> Optional[pulumi.Input['VirtualNetworkBgpCommunitiesArgs']]:
"""
The reference to the remote virtual network's Bgp Communities.
"""
return pulumi.get(self, "remote_bgp_communities")
@remote_bgp_communities.setter
def remote_bgp_communities(self, value: Optional[pulumi.Input['VirtualNetworkBgpCommunitiesArgs']]):
pulumi.set(self, "remote_bgp_communities", value)
@property
@pulumi.getter(name="remoteVirtualNetwork")
def remote_virtual_network(self) -> Optional[pulumi.Input['SubResourceArgs']]:
"""
The reference to the remote virtual network. The remote virtual network can be in the same or different region (preview). See here to register for the preview and learn more (https://docs.microsoft.com/en-us/azure/virtual-network/virtual-network-create-peering).
"""
return pulumi.get(self, "remote_virtual_network")
@remote_virtual_network.setter
def remote_virtual_network(self, value: Optional[pulumi.Input['SubResourceArgs']]):
pulumi.set(self, "remote_virtual_network", value)
@property
@pulumi.getter(name="remoteVirtualNetworkAddressSpace")
def remote_virtual_network_address_space(self) -> Optional[pulumi.Input['AddressSpaceArgs']]:
"""
The reference to the current address space of the remote virtual network.
"""
return pulumi.get(self, "remote_virtual_network_address_space")
@remote_virtual_network_address_space.setter
def remote_virtual_network_address_space(self, value: Optional[pulumi.Input['AddressSpaceArgs']]):
pulumi.set(self, "remote_virtual_network_address_space", value)
@property
@pulumi.getter(name="syncRemoteAddressSpace")
def sync_remote_address_space(self) -> Optional[pulumi.Input[str]]:
"""
Parameter indicates the intention to sync the peering with the current address space on the remote vNet after it's updated.
"""
return pulumi.get(self, "sync_remote_address_space")
@sync_remote_address_space.setter
def sync_remote_address_space(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "sync_remote_address_space", value)
@property
@pulumi.getter
def type(self) -> Optional[pulumi.Input[str]]:
"""
Resource type.
"""
return pulumi.get(self, "type")
@type.setter
def type(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "type", value)
@property
@pulumi.getter(name="useRemoteGateways")
def use_remote_gateways(self) -> Optional[pulumi.Input[bool]]:
"""
If remote gateways can be used on this virtual network. If the flag is set to true, and allowGatewayTransit on remote peering is also true, virtual network will use gateways of remote virtual network for transit. Only one peering can have this flag set to true. This flag cannot be set if virtual network already has a gateway.
"""
return pulumi.get(self, "use_remote_gateways")
@use_remote_gateways.setter
def use_remote_gateways(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "use_remote_gateways", value)
@property
@pulumi.getter(name="virtualNetworkPeeringName")
def virtual_network_peering_name(self) -> Optional[pulumi.Input[str]]:
"""
The name of the peering.
"""
return pulumi.get(self, "virtual_network_peering_name")
@virtual_network_peering_name.setter
def virtual_network_peering_name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "virtual_network_peering_name", value)
class VirtualNetworkPeering(pulumi.CustomResource):
@overload
def __init__(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
allow_forwarded_traffic: Optional[pulumi.Input[bool]] = None,
allow_gateway_transit: Optional[pulumi.Input[bool]] = None,
allow_virtual_network_access: Optional[pulumi.Input[bool]] = None,
do_not_verify_remote_gateways: Optional[pulumi.Input[bool]] = None,
id: Optional[pulumi.Input[str]] = None,
name: Optional[pulumi.Input[str]] = None,
peering_state: Optional[pulumi.Input[Union[str, 'VirtualNetworkPeeringState']]] = None,
peering_sync_level: Optional[pulumi.Input[Union[str, 'VirtualNetworkPeeringLevel']]] = None,
remote_address_space: Optional[pulumi.Input[pulumi.InputType['AddressSpaceArgs']]] = None,
remote_bgp_communities: Optional[pulumi.Input[pulumi.InputType['VirtualNetworkBgpCommunitiesArgs']]] = None,
remote_virtual_network: Optional[pulumi.Input[pulumi.InputType['SubResourceArgs']]] = None,
remote_virtual_network_address_space: Optional[pulumi.Input[pulumi.InputType['AddressSpaceArgs']]] = None,
resource_group_name: Optional[pulumi.Input[str]] = None,
sync_remote_address_space: Optional[pulumi.Input[str]] = None,
type: Optional[pulumi.Input[str]] = None,
use_remote_gateways: Optional[pulumi.Input[bool]] = None,
virtual_network_name: Optional[pulumi.Input[str]] = None,
virtual_network_peering_name: Optional[pulumi.Input[str]] = None,
__props__=None):
"""
Peerings in a virtual network resource.
:param str resource_name: The name of the resource.
:param pulumi.ResourceOptions opts: Options for the resource.
:param pulumi.Input[bool] allow_forwarded_traffic: Whether the forwarded traffic from the VMs in the local virtual network will be allowed/disallowed in remote virtual network.
:param pulumi.Input[bool] allow_gateway_transit: If gateway links can be used in remote virtual networking to link to this virtual network.
:param pulumi.Input[bool] allow_virtual_network_access: Whether the VMs in the local virtual network space would be able to access the VMs in remote virtual network space.
:param pulumi.Input[bool] do_not_verify_remote_gateways: If we need to verify the provisioning state of the remote gateway.
:param pulumi.Input[str] id: Resource ID.
:param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
:param pulumi.Input[Union[str, 'VirtualNetworkPeeringState']] peering_state: The status of the virtual network peering.
:param pulumi.Input[Union[str, 'VirtualNetworkPeeringLevel']] peering_sync_level: The peering sync status of the virtual network peering.
:param pulumi.Input[pulumi.InputType['AddressSpaceArgs']] remote_address_space: The reference to the address space peered with the remote virtual network.
:param pulumi.Input[pulumi.InputType['VirtualNetworkBgpCommunitiesArgs']] remote_bgp_communities: The reference to the remote virtual network's Bgp Communities.
:param pulumi.Input[pulumi.InputType['SubResourceArgs']] remote_virtual_network: The reference to the remote virtual network. The remote virtual network can be in the same or different region (preview). See here to register for the preview and learn more (https://docs.microsoft.com/en-us/azure/virtual-network/virtual-network-create-peering).
:param pulumi.Input[pulumi.InputType['AddressSpaceArgs']] remote_virtual_network_address_space: The reference to the current address space of the remote virtual network.
:param pulumi.Input[str] resource_group_name: The name of the resource group.
:param pulumi.Input[str] sync_remote_address_space: Parameter indicates the intention to sync the peering with the current address space on the remote vNet after it's updated.
:param pulumi.Input[str] type: Resource type.
:param pulumi.Input[bool] use_remote_gateways: If remote gateways can be used on this virtual network. If the flag is set to true, and allowGatewayTransit on remote peering is also true, virtual network will use gateways of remote virtual network for transit. Only one peering can have this flag set to true. This flag cannot be set if virtual network already has a gateway.
:param pulumi.Input[str] virtual_network_name: The name of the virtual network.
:param pulumi.Input[str] virtual_network_peering_name: The name of the peering.
"""
...
@overload
def __init__(__self__,
resource_name: str,
args: VirtualNetworkPeeringInitArgs,
opts: Optional[pulumi.ResourceOptions] = None):
"""
Peerings in a virtual network resource.
:param str resource_name: The name of the resource.
:param VirtualNetworkPeeringInitArgs args: The arguments to use to populate this resource's properties.
:param pulumi.ResourceOptions opts: Options for the resource.
"""
...
def __init__(__self__, resource_name: str, *args, **kwargs):
resource_args, opts = _utilities.get_resource_args_opts(VirtualNetworkPeeringInitArgs, pulumi.ResourceOptions, *args, **kwargs)
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
allow_forwarded_traffic: Optional[pulumi.Input[bool]] = None,
allow_gateway_transit: Optional[pulumi.Input[bool]] = None,
allow_virtual_network_access: Optional[pulumi.Input[bool]] = None,
do_not_verify_remote_gateways: Optional[pulumi.Input[bool]] = None,
id: Optional[pulumi.Input[str]] = None,
name: Optional[pulumi.Input[str]] = None,
peering_state: Optional[pulumi.Input[Union[str, 'VirtualNetworkPeeringState']]] = None,
peering_sync_level: Optional[pulumi.Input[Union[str, 'VirtualNetworkPeeringLevel']]] = None,
remote_address_space: Optional[pulumi.Input[pulumi.InputType['AddressSpaceArgs']]] = None,
remote_bgp_communities: Optional[pulumi.Input[pulumi.InputType['VirtualNetworkBgpCommunitiesArgs']]] = None,
remote_virtual_network: Optional[pulumi.Input[pulumi.InputType['SubResourceArgs']]] = None,
remote_virtual_network_address_space: Optional[pulumi.Input[pulumi.InputType['AddressSpaceArgs']]] = None,
resource_group_name: Optional[pulumi.Input[str]] = None,
sync_remote_address_space: Optional[pulumi.Input[str]] = None,
type: Optional[pulumi.Input[str]] = None,
use_remote_gateways: Optional[pulumi.Input[bool]] = None,
virtual_network_name: Optional[pulumi.Input[str]] = None,
virtual_network_peering_name: Optional[pulumi.Input[str]] = None,
__props__=None):
if opts is None:
opts = pulumi.ResourceOptions()
if not isinstance(opts, pulumi.ResourceOptions):
raise TypeError('Expected resource options to be a ResourceOptions instance')
if opts.version is None:
opts.version = _utilities.get_version()
if opts.id is None:
if __props__ is not None:
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
__props__ = VirtualNetworkPeeringInitArgs.__new__(VirtualNetworkPeeringInitArgs)
__props__.__dict__["allow_forwarded_traffic"] = allow_forwarded_traffic
__props__.__dict__["allow_gateway_transit"] = allow_gateway_transit
__props__.__dict__["allow_virtual_network_access"] = allow_virtual_network_access
__props__.__dict__["do_not_verify_remote_gateways"] = do_not_verify_remote_gateways
__props__.__dict__["id"] = id
__props__.__dict__["name"] = name
__props__.__dict__["peering_state"] = peering_state
__props__.__dict__["peering_sync_level"] = peering_sync_level
__props__.__dict__["remote_address_space"] = remote_address_space
__props__.__dict__["remote_bgp_communities"] = remote_bgp_communities
__props__.__dict__["remote_virtual_network"] = remote_virtual_network
__props__.__dict__["remote_virtual_network_address_space"] = remote_virtual_network_address_space
if resource_group_name is None and not opts.urn:
raise TypeError("Missing required property 'resource_group_name'")
__props__.__dict__["resource_group_name"] = resource_group_name
__props__.__dict__["sync_remote_address_space"] = sync_remote_address_space
__props__.__dict__["type"] = type
__props__.__dict__["use_remote_gateways"] = use_remote_gateways
if virtual_network_name is None and not opts.urn:
raise TypeError("Missing required property 'virtual_network_name'")
__props__.__dict__["virtual_network_name"] = virtual_network_name
__props__.__dict__["virtual_network_peering_name"] = virtual_network_peering_name
__props__.__dict__["etag"] = None
__props__.__dict__["provisioning_state"] = None
__props__.__dict__["resource_guid"] = None
alias_opts = pulumi.ResourceOptions(aliases=[pulumi.Alias(type_="azure-nextgen:network/v20210201:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20160601:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20160601:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20160901:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20160901:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20161201:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20161201:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20170301:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20170301:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20170601:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20170601:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20170801:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20170801:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20170901:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20170901:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20171001:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20171001:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20171101:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20171101:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20180101:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20180101:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20180201:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20180201:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20180401:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20180401:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20180601:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20180601:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20180701:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20180701:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20180801:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20180801:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20181001:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20181001:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20181101:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20181101:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20181201:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20181201:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20190201:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20190201:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20190401:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20190401:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20190601:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20190601:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20190701:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20190701:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20190801:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20190801:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20190901:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20190901:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20191101:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20191101:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20191201:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20191201:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20200301:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20200301:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20200401:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20200401:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20200501:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20200501:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20200601:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20200601:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20200701:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20200701:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20200801:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20200801:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20201101:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20201101:VirtualNetworkPeering"), pulumi.Alias(type_="azure-native:network/v20210301:VirtualNetworkPeering"), pulumi.Alias(type_="azure-nextgen:network/v20210301:VirtualNetworkPeering")])
opts = pulumi.ResourceOptions.merge(opts, alias_opts)
super(VirtualNetworkPeering, __self__).__init__(
'azure-native:network/v20210201:VirtualNetworkPeering',
resource_name,
__props__,
opts)
@staticmethod
def get(resource_name: str,
id: pulumi.Input[str],
opts: Optional[pulumi.ResourceOptions] = None) -> 'VirtualNetworkPeering':
"""
Get an existing VirtualNetworkPeering resource's state with the given name, id, and optional extra
properties used to qualify the lookup.
:param str resource_name: The unique name of the resulting resource.
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
:param pulumi.ResourceOptions opts: Options for the resource.
"""
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
__props__ = VirtualNetworkPeeringInitArgs.__new__(VirtualNetworkPeeringInitArgs)
__props__.__dict__["allow_forwarded_traffic"] = None
__props__.__dict__["allow_gateway_transit"] = None
__props__.__dict__["allow_virtual_network_access"] = None
__props__.__dict__["do_not_verify_remote_gateways"] = None
__props__.__dict__["etag"] = None
__props__.__dict__["name"] = None
__props__.__dict__["peering_state"] = None
__props__.__dict__["peering_sync_level"] = None
__props__.__dict__["provisioning_state"] = None
__props__.__dict__["remote_address_space"] = None
__props__.__dict__["remote_bgp_communities"] = None
__props__.__dict__["remote_virtual_network"] = None
__props__.__dict__["remote_virtual_network_address_space"] = None
__props__.__dict__["resource_guid"] = None
__props__.__dict__["type"] = None
__props__.__dict__["use_remote_gateways"] = None
return VirtualNetworkPeering(resource_name, opts=opts, __props__=__props__)
@property
@pulumi.getter(name="allowForwardedTraffic")
def allow_forwarded_traffic(self) -> pulumi.Output[Optional[bool]]:
"""
Whether the forwarded traffic from the VMs in the local virtual network will be allowed/disallowed in remote virtual network.
"""
return pulumi.get(self, "allow_forwarded_traffic")
@property
@pulumi.getter(name="allowGatewayTransit")
def allow_gateway_transit(self) -> pulumi.Output[Optional[bool]]:
"""
If gateway links can be used in remote virtual networking to link to this virtual network.
"""
return pulumi.get(self, "allow_gateway_transit")
@property
@pulumi.getter(name="allowVirtualNetworkAccess")
def allow_virtual_network_access(self) -> pulumi.Output[Optional[bool]]:
"""
Whether the VMs in the local virtual network space would be able to access the VMs in remote virtual network space.
"""
return pulumi.get(self, "allow_virtual_network_access")
@property
@pulumi.getter(name="doNotVerifyRemoteGateways")
def do_not_verify_remote_gateways(self) -> pulumi.Output[Optional[bool]]:
"""
If we need to verify the provisioning state of the remote gateway.
"""
return pulumi.get(self, "do_not_verify_remote_gateways")
@property
@pulumi.getter
def etag(self) -> pulumi.Output[str]:
"""
A unique read-only string that changes whenever the resource is updated.
"""
return pulumi.get(self, "etag")
@property
@pulumi.getter
def name(self) -> pulumi.Output[Optional[str]]:
"""
The name of the resource that is unique within a resource group. This name can be used to access the resource.
"""
return pulumi.get(self, "name")
@property
@pulumi.getter(name="peeringState")
def peering_state(self) -> pulumi.Output[Optional[str]]:
"""
The status of the virtual network peering.
"""
return pulumi.get(self, "peering_state")
@property
@pulumi.getter(name="peeringSyncLevel")
def peering_sync_level(self) -> pulumi.Output[Optional[str]]:
"""
The peering sync status of the virtual network peering.
"""
return pulumi.get(self, "peering_sync_level")
@property
@pulumi.getter(name="provisioningState")
def provisioning_state(self) -> pulumi.Output[str]:
"""
The provisioning state of the virtual network peering resource.
"""
return pulumi.get(self, "provisioning_state")
@property
@pulumi.getter(name="remoteAddressSpace")
def remote_address_space(self) -> pulumi.Output[Optional['outputs.AddressSpaceResponse']]:
"""
The reference to the address space peered with the remote virtual network.
"""
return pulumi.get(self, "remote_address_space")
@property
@pulumi.getter(name="remoteBgpCommunities")
def remote_bgp_communities(self) -> pulumi.Output[Optional['outputs.VirtualNetworkBgpCommunitiesResponse']]:
"""
The reference to the remote virtual network's Bgp Communities.
"""
return pulumi.get(self, "remote_bgp_communities")
@property
@pulumi.getter(name="remoteVirtualNetwork")
def remote_virtual_network(self) -> pulumi.Output[Optional['outputs.SubResourceResponse']]:
"""
The reference to the remote virtual network. The remote virtual network can be in the same or different region (preview). See here to register for the preview and learn more (https://docs.microsoft.com/en-us/azure/virtual-network/virtual-network-create-peering).
"""
return pulumi.get(self, "remote_virtual_network")
@property
@pulumi.getter(name="remoteVirtualNetworkAddressSpace")
def remote_virtual_network_address_space(self) -> pulumi.Output[Optional['outputs.AddressSpaceResponse']]:
"""
The reference to the current address space of the remote virtual network.
"""
return pulumi.get(self, "remote_virtual_network_address_space")
@property
@pulumi.getter(name="resourceGuid")
def resource_guid(self) -> pulumi.Output[str]:
"""
The resourceGuid property of the Virtual Network peering resource.
"""
return pulumi.get(self, "resource_guid")
@property
@pulumi.getter
def type(self) -> pulumi.Output[Optional[str]]:
"""
Resource type.
"""
return pulumi.get(self, "type")
@property
@pulumi.getter(name="useRemoteGateways")
def use_remote_gateways(self) -> pulumi.Output[Optional[bool]]:
"""
If remote gateways can be used on this virtual network. If the flag is set to true, and allowGatewayTransit on remote peering is also true, virtual network will use gateways of remote virtual network for transit. Only one peering can have this flag set to true. This flag cannot be set if virtual network already has a gateway.
"""
return pulumi.get(self, "use_remote_gateways")
| [
"[email protected]"
] | |
ffb15c04da0ece2afe9237cfc2c8992137f4acfe | 08f5dd97433ce84868dbd95020e49f795e8e3f42 | /website/migrations/0017_auto_20151101_1225.py | d4d3154f0a3b3d8fd27409cc3b2843b8a8424e58 | [] | no_license | katur/forthebirds | f76e9d78f8b71f5cb13f22f3c417e737f6048896 | 2118fabebd8780cd3151f5ddd88245de402590e9 | refs/heads/master | 2023-08-08T18:57:55.722516 | 2023-03-28T03:04:19 | 2023-03-28T03:04:19 | 22,771,365 | 2 | 1 | null | 2023-07-25T21:23:49 | 2014-08-08T20:56:20 | Python | UTF-8 | Python | false | false | 563 | py | # -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('website', '0016_auto_20151018_1630'),
]
operations = [
migrations.AlterField(
model_name='userprofile',
name='main_photo',
field=models.ForeignKey(related_name='main_uploaded_photo', on_delete=django.db.models.deletion.SET_NULL, blank=True, to='website.UploadedImage', null=True),
),
]
| [
"[email protected]"
] | |
9b2f77944f2f030b061978095c6b458d55c249c3 | 185cbe28ae1950866905ddb3b53a3ca325f8fc98 | /Project4_FortressMachine/KindFortressMachine/web/migrations/0006_auto_20180325_1621.py | 866a5ee225ce6da1a7c0d0d9356e0cb8d7598c54 | [] | no_license | phully/PythonHomeWork | 2997cb2017621116d2959a183fcb50c4d4ea3289 | 4d497a6261de17cc2fc058cea50e127e885e5095 | refs/heads/master | 2020-03-21T04:51:51.700197 | 2018-06-06T02:35:40 | 2018-06-06T02:35:40 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,395 | py | # -*- coding: utf-8 -*-
# Generated by Django 1.11.3 on 2018-03-25 16:21
from __future__ import unicode_literals
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('web', '0005_auto_20180310_1956'),
]
operations = [
migrations.CreateModel(
name='MultiTask',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('task_type', models.SmallIntegerField(choices=[(0, 'cmd'), (1, 'file_transfer')], verbose_name='批量任务类型')),
('content', models.TextField(verbose_name='批量任务内容')),
('createtime', models.DateTimeField(auto_now_add=True, verbose_name='批量任务创建时间')),
('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL, verbose_name='批量任务执行者')),
],
options={
'verbose_name_plural': '批量任务记录',
},
),
migrations.CreateModel(
name='MultiTaskDetail',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('result', models.TextField(verbose_name='执行结果')),
('status', models.SmallIntegerField(choices=[(0, 'init'), (1, 'success'), (2, 'failed')], verbose_name='执行状态')),
('start_time', models.DateTimeField(auto_now_add=True, verbose_name='执行任务创建时间')),
('end_time', models.DateTimeField(auto_now=True, null=True, verbose_name='执行任务终止时间')),
('bind_host', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='web.BindHost', verbose_name='对应执行主机')),
('multi_task', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='web.MultiTask', verbose_name='批量任务')),
],
options={
'verbose_name_plural': '批量任务详细信息',
},
),
migrations.AlterUniqueTogether(
name='multitaskdetail',
unique_together=set([('multi_task', 'bind_host')]),
),
]
| [
"[email protected]"
] | |
74a1eecd5126c11d513494aa0a9c1d89dc2332c6 | 49eb0d08311529b1d2375429a9cbb5582d77fd2d | /qa/rpc-tests/invalidblockrequest.py | ab650fcf8a43a8e5894c157144e20c00c5b6a902 | [
"MIT"
] | permissive | mario1987/deimos | bcbaa7b4ed617a70c37047e6590264941b94a170 | 72cb8c33b5a6d4e09e4019602db7cea8c686d505 | refs/heads/master | 2020-03-19T23:11:08.313125 | 2018-06-11T23:06:30 | 2018-06-11T23:06:30 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,263 | py | #!/usr/bin/env python3
# Copyright (c) 2015-2016 The DeiMos Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
from test_framework.test_framework import ComparisonTestFramework
from test_framework.util import *
from test_framework.comptool import TestManager, TestInstance, RejectResult
from test_framework.blocktools import *
import copy
import time
'''
In this test we connect to one node over p2p, and test block requests:
1) Valid blocks should be requested and become chain tip.
2) Invalid block with duplicated transaction should be re-requested.
3) Invalid block with bad coinbase value should be rejected and not
re-requested.
'''
# Use the ComparisonTestFramework with 1 node: only use --testbinary.
class InvalidBlockRequestTest(ComparisonTestFramework):
''' Can either run this test as 1 node with expected answers, or two and compare them.
Change the "outcome" variable from each TestInstance object to only do the comparison. '''
def __init__(self):
super().__init__()
self.num_nodes = 1
def run_test(self):
test = TestManager(self, self.options.tmpdir)
test.add_all_connections(self.nodes)
self.tip = None
self.block_time = None
NetworkThread().start() # Start up network handling in another thread
test.run()
def get_tests(self):
if self.tip is None:
self.tip = int("0x" + self.nodes[0].getbestblockhash(), 0)
self.block_time = int(time.time())+1
'''
Create a new block with an anyone-can-spend coinbase
'''
height = 1
block = create_block(self.tip, create_coinbase(height), self.block_time)
self.block_time += 1
block.solve()
# Save the coinbase for later
self.block1 = block
self.tip = block.sha256
height += 1
yield TestInstance([[block, True]])
'''
Now we need that block to mature so we can spend the coinbase.
'''
test = TestInstance(sync_every_block=False)
for i in range(100):
block = create_block(self.tip, create_coinbase(height), self.block_time)
block.solve()
self.tip = block.sha256
self.block_time += 1
test.blocks_and_transactions.append([block, True])
height += 1
yield test
'''
Now we use merkle-root malleability to generate an invalid block with
same blockheader.
Manufacture a block with 3 transactions (coinbase, spend of prior
coinbase, spend of that spend). Duplicate the 3rd transaction to
leave merkle root and blockheader unchanged but invalidate the block.
'''
block2 = create_block(self.tip, create_coinbase(height), self.block_time)
self.block_time += 1
# b'0x51' is OP_TRUE
tx1 = create_transaction(self.block1.vtx[0], 0, b'\x51', 50 * COIN)
tx2 = create_transaction(tx1, 0, b'\x51', 50 * COIN)
block2.vtx.extend([tx1, tx2])
block2.hashMerkleRoot = block2.calc_merkle_root()
block2.rehash()
block2.solve()
orig_hash = block2.sha256
block2_orig = copy.deepcopy(block2)
# Mutate block 2
block2.vtx.append(tx2)
assert_equal(block2.hashMerkleRoot, block2.calc_merkle_root())
assert_equal(orig_hash, block2.rehash())
assert(block2_orig.vtx != block2.vtx)
self.tip = block2.sha256
yield TestInstance([[block2, RejectResult(16, b'bad-txns-duplicate')], [block2_orig, True]])
height += 1
'''
Make sure that a totally screwed up block is not valid.
'''
block3 = create_block(self.tip, create_coinbase(height), self.block_time)
self.block_time += 1
block3.vtx[0].vout[0].nValue = 100 * COIN # Too high!
block3.vtx[0].sha256=None
block3.vtx[0].calc_sha256()
block3.hashMerkleRoot = block3.calc_merkle_root()
block3.rehash()
block3.solve()
yield TestInstance([[block3, RejectResult(16, b'bad-cb-amount')]])
if __name__ == '__main__':
InvalidBlockRequestTest().main()
| [
"[email protected]"
] | |
6a62d14ab57f512695d7249171d11e6e5d91af95 | f9d564f1aa83eca45872dab7fbaa26dd48210d08 | /huaweicloud-sdk-rds/huaweicloudsdkrds/v3/model/update_postgresql_database_request.py | c1dd556380b81c36a6d0f15e095115458d91cd38 | [
"Apache-2.0"
] | permissive | huaweicloud/huaweicloud-sdk-python-v3 | cde6d849ce5b1de05ac5ebfd6153f27803837d84 | f69344c1dadb79067746ddf9bfde4bddc18d5ecf | refs/heads/master | 2023-09-01T19:29:43.013318 | 2023-08-31T08:28:59 | 2023-08-31T08:28:59 | 262,207,814 | 103 | 44 | NOASSERTION | 2023-06-22T14:50:48 | 2020-05-08T02:28:43 | Python | UTF-8 | Python | false | false | 4,867 | py | # coding: utf-8
import six
from huaweicloudsdkcore.utils.http_utils import sanitize_for_serialization
class UpdatePostgresqlDatabaseRequest:
"""
Attributes:
openapi_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
"""
sensitive_list = []
openapi_types = {
'x_language': 'str',
'instance_id': 'str',
'body': 'UpdateDatabaseReq'
}
attribute_map = {
'x_language': 'X-Language',
'instance_id': 'instance_id',
'body': 'body'
}
def __init__(self, x_language=None, instance_id=None, body=None):
"""UpdatePostgresqlDatabaseRequest
The model defined in huaweicloud sdk
:param x_language: 语言
:type x_language: str
:param instance_id: 实例ID。
:type instance_id: str
:param body: Body of the UpdatePostgresqlDatabaseRequest
:type body: :class:`huaweicloudsdkrds.v3.UpdateDatabaseReq`
"""
self._x_language = None
self._instance_id = None
self._body = None
self.discriminator = None
if x_language is not None:
self.x_language = x_language
self.instance_id = instance_id
if body is not None:
self.body = body
@property
def x_language(self):
"""Gets the x_language of this UpdatePostgresqlDatabaseRequest.
语言
:return: The x_language of this UpdatePostgresqlDatabaseRequest.
:rtype: str
"""
return self._x_language
@x_language.setter
def x_language(self, x_language):
"""Sets the x_language of this UpdatePostgresqlDatabaseRequest.
语言
:param x_language: The x_language of this UpdatePostgresqlDatabaseRequest.
:type x_language: str
"""
self._x_language = x_language
@property
def instance_id(self):
"""Gets the instance_id of this UpdatePostgresqlDatabaseRequest.
实例ID。
:return: The instance_id of this UpdatePostgresqlDatabaseRequest.
:rtype: str
"""
return self._instance_id
@instance_id.setter
def instance_id(self, instance_id):
"""Sets the instance_id of this UpdatePostgresqlDatabaseRequest.
实例ID。
:param instance_id: The instance_id of this UpdatePostgresqlDatabaseRequest.
:type instance_id: str
"""
self._instance_id = instance_id
@property
def body(self):
"""Gets the body of this UpdatePostgresqlDatabaseRequest.
:return: The body of this UpdatePostgresqlDatabaseRequest.
:rtype: :class:`huaweicloudsdkrds.v3.UpdateDatabaseReq`
"""
return self._body
@body.setter
def body(self, body):
"""Sets the body of this UpdatePostgresqlDatabaseRequest.
:param body: The body of this UpdatePostgresqlDatabaseRequest.
:type body: :class:`huaweicloudsdkrds.v3.UpdateDatabaseReq`
"""
self._body = body
def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.openapi_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
if attr in self.sensitive_list:
result[attr] = "****"
else:
result[attr] = value
return result
def to_str(self):
"""Returns the string representation of the model"""
import simplejson as json
if six.PY2:
import sys
reload(sys)
sys.setdefaultencoding("utf-8")
return json.dumps(sanitize_for_serialization(self), ensure_ascii=False)
def __repr__(self):
"""For `print`"""
return self.to_str()
def __eq__(self, other):
"""Returns true if both objects are equal"""
if not isinstance(other, UpdatePostgresqlDatabaseRequest):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""Returns true if both objects are not equal"""
return not self == other
| [
"[email protected]"
] | |
737e76aef0b73d80231e2619bb39b237484a3da1 | 3518d02090de8102b090f780c09ba32d37e95b49 | /ghpro/stats.py | 61b6650a13d4118560e1fb8189a42aabc8b430c8 | [
"BSD-3-Clause",
"BSD-2-Clause"
] | permissive | takluyver/ghpro | 9a34a7fdcf162101bfa79a17f4438b1a7b6b4dc5 | f9f053883acf2c01a39008054698408c8db85a18 | refs/heads/master | 2023-06-19T18:50:47.984731 | 2016-12-02T10:15:59 | 2016-12-02T10:15:59 | 75,550,828 | 0 | 0 | null | 2016-12-04T16:54:05 | 2016-12-04T16:54:05 | null | UTF-8 | Python | false | false | 8,063 | py | #!/usr/bin/env python
"""Simple tools to query github.com and gather stats about issues.
To generate a report for IPython 2.0, run:
github-stats --milestone 2.0 --since-tag rel-1.0.0
"""
from __future__ import print_function
import codecs
import sys
from argparse import ArgumentParser
from datetime import datetime, timedelta
from subprocess import check_output
from .api import (
get_paged_request, make_auth_header, get_pull_request, is_pull_request,
get_milestone_id, get_issues_list, get_authors,
)
from .utils import guess_project
ISO8601 = "%Y-%m-%dT%H:%M:%SZ"
PER_PAGE = 100
def round_hour(dt):
return dt.replace(minute=0,second=0,microsecond=0)
def _parse_datetime(s):
"""Parse dates in the format returned by the Github API."""
if s:
return datetime.strptime(s, ISO8601)
else:
return datetime.fromtimestamp(0)
def issues2dict(issues):
"""Convert a list of issues to a dict, keyed by issue number."""
idict = {}
for i in issues:
idict[i['number']] = i
return idict
def split_pulls(all_issues, project="ipython/ipython"):
"""split a list of closed issues into non-PR Issues and Pull Requests"""
pulls = []
issues = []
for i in all_issues:
if is_pull_request(i):
pull = get_pull_request(project, i['number'], auth=True)
pulls.append(pull)
else:
issues.append(i)
return issues, pulls
def issues_closed_since(period=timedelta(days=365), project="ipython/ipython", pulls=False):
"""Get all issues closed since a particular point in time. period
can either be a datetime object, or a timedelta object. In the
latter case, it is used as a time before the present.
"""
which = 'pulls' if pulls else 'issues'
if isinstance(period, timedelta):
since = round_hour(datetime.utcnow() - period)
else:
since = period
url = "https://api.github.com/repos/%s/%s?state=closed&sort=updated&since=%s&per_page=%i" % (project, which, since.strftime(ISO8601), PER_PAGE)
allclosed = get_paged_request(url, headers=make_auth_header())
filtered = [ i for i in allclosed if _parse_datetime(i['closed_at']) > since ]
if pulls:
filtered = [ i for i in filtered if _parse_datetime(i['merged_at']) > since ]
# filter out PRs not against master (backports)
filtered = [ i for i in filtered if i['base']['ref'] == 'master' ]
else:
filtered = [ i for i in filtered if not is_pull_request(i) ]
return filtered
def sorted_by_field(issues, field='closed_at', reverse=False):
"""Return a list of issues sorted by closing date date."""
return sorted(issues, key = lambda i:i[field], reverse=reverse)
def report(issues, show_urls=False):
"""Summary report about a list of issues, printing number and title."""
if show_urls:
for i in issues:
role = 'ghpull' if 'merged_at' in i else 'ghissue'
print(u'* :%s:`%d`: %s' % (role, i['number'],
i['title'].replace(u'`', u'``')))
else:
for i in issues:
print(u'* %d: %s' % (i['number'], i['title'].replace(u'`', u'``')))
#-----------------------------------------------------------------------------
# Main script
#-----------------------------------------------------------------------------
def main():
# deal with unicode
if sys.version_info < (3,):
sys.stdout = codecs.getwriter('utf8')(sys.stdout)
# Whether to add reST urls for all issues in printout.
show_urls = True
parser = ArgumentParser()
parser.add_argument('--since-tag', type=str,
help="The git tag to use for the starting point (typically the last major release)."
)
parser.add_argument('--milestone', type=str,
help="The GitHub milestone to use for filtering issues [optional]."
)
parser.add_argument('--days', type=int,
help="The number of days of data to summarize (use this or --since-tag)."
)
parser.add_argument('--project', type=str, default=None,
help="The project to summarize."
)
parser.add_argument('--links', action='store_true', default=False,
help="Include links to all closed Issues and PRs in the output."
)
opts = parser.parse_args()
if not opts.project:
opts.project = guess_project('.')
tag = opts.since_tag
# set `since` from days or git tag
if opts.days:
since = datetime.utcnow() - timedelta(days=opts.days)
else:
if not tag:
tag = check_output(['git', 'describe', '--abbrev=0']).strip().decode('utf8')
cmd = ['git', 'log', '-1', '--format=%ai', tag]
tagday, tz = check_output(cmd).strip().decode('utf8').rsplit(' ', 1)
since = datetime.strptime(tagday, "%Y-%m-%d %H:%M:%S")
h = int(tz[1:3])
m = int(tz[3:])
td = timedelta(hours=h, minutes=m)
if tz[0] == '-':
since += td
else:
since -= td
since = round_hour(since)
milestone = opts.milestone
project = opts.project
print("fetching GitHub stats since %s (milestone: %s, since: %s)" % (since, milestone, tag), file=sys.stderr)
if milestone:
milestone_id = get_milestone_id(project=project, milestone=milestone,
auth=True)
issues_and_pulls = get_issues_list(project=project,
milestone=milestone_id,
state='closed',
auth=True,
)
issues, pulls = split_pulls(issues_and_pulls, project=project)
else:
issues = issues_closed_since(since, project=project, pulls=False)
pulls = issues_closed_since(since, project=project, pulls=True)
# For regular reports, it's nice to show them in reverse chronological order
issues = sorted_by_field(issues, reverse=True)
pulls = sorted_by_field(pulls, reverse=True)
n_issues, n_pulls = map(len, (issues, pulls))
n_total = n_issues + n_pulls
# Print summary report we can directly include into release notes.
print()
since_day = since.strftime("%Y/%m/%d")
today = datetime.today().strftime("%Y/%m/%d")
print("GitHub stats for %s - %s (milestone: %s)" % (since_day, today, milestone))
print()
print("These lists are automatically generated, and may be incomplete or contain duplicates.")
print()
ncommits = 0
all_authors = []
if tag:
# print git info, in addition to GitHub info:
since_tag = tag+'..'
cmd = ['git', 'log', '--oneline', since_tag]
ncommits += len(check_output(cmd).splitlines())
author_cmd = ['git', 'log', '--use-mailmap', "--format=* %aN", since_tag]
all_authors.extend(check_output(author_cmd).decode('utf-8', 'replace').splitlines())
pr_authors = []
for pr in pulls:
pr_authors.extend(get_authors(pr))
ncommits = len(pr_authors) + ncommits - len(pulls)
author_cmd = ['git', 'check-mailmap'] + pr_authors
with_email = check_output(author_cmd).decode('utf-8', 'replace').splitlines()
all_authors.extend([ u'* ' + a.split(' <')[0] for a in with_email ])
unique_authors = sorted(set(all_authors), key=lambda s: s.lower())
print("We closed %d issues and merged %d pull requests." % (n_issues, n_pulls))
if milestone:
print("The full list can be seen `on GitHub <https://github.com/{project}/issues?q=milestone%3A{milestone}+>`__".format(project=project,milestone=milestone)
)
print()
print("The following %i authors contributed %i commits." % (len(unique_authors), ncommits))
print()
print('\n'.join(unique_authors))
if opts.links:
print()
print("GitHub issues and pull requests:")
print()
print('Pull Requests (%d):\n' % n_pulls)
report(pulls, show_urls)
print()
print('Issues (%d):\n' % n_issues)
report(issues, show_urls)
if __name__ == '__main__':
main() | [
"[email protected]"
] | |
726e82d61f0d58be4d15b15e39016bbfdc09b419 | 093962f5be1357f1587235ee3e1cfa5db493d0d7 | /source/reviewapp/core/migrations/0005_delete_unitofhistory.py | d7e71fef316ea46117e57d25161f514a91c2c1a5 | [] | no_license | Shamsulhaq/reviewshelf | 037299104f7161386f1782670bfa495f029216b8 | 178b15da4186fcab4dfb9a0ad47ba0b056d137a6 | refs/heads/master | 2023-01-19T19:36:30.918625 | 2020-12-02T12:24:07 | 2020-12-02T12:24:07 | 316,216,156 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 307 | py | # Generated by Django 3.1.3 on 2020-11-28 08:32
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('core', '0004_remove_category_is_deleted'),
]
operations = [
migrations.DeleteModel(
name='UnitOfHistory',
),
]
| [
"[email protected]"
] | |
0f907bd1c0189d77bac7d77ad4ef790f01f4cdeb | ccd8273d923b82a46893da7a8dbc06f4b0f2f889 | /fan_manager/schedule.py | 8296f2a9be666b2b277a200309a7e23e5c9f37bb | [] | no_license | artrey/gpio-fan-manager | 1e45254de461063a462c7bbd41351be6744dd887 | 36bb2573a5334feb2f474c199cb37db6568ceb68 | refs/heads/master | 2020-04-03T06:54:40.103953 | 2019-01-02T20:06:35 | 2019-01-02T20:06:35 | 155,087,759 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,462 | py | # -*- coding: utf-8 -*-
import datetime
from typing import List
import pytz
class FanPolicy:
def __init__(self, time_start: datetime.time, time_finish: datetime.time,
threshold_enable: float, threshold_disable: float):
self.time_start = time_start
self.time_finish = time_finish
self.threshold_enable = threshold_enable
self.threshold_disable = threshold_disable
def __str__(self):
return f'[{self.time_start} - {self.time_finish}] {self.threshold_enable} / {self.threshold_disable}'
class Schedule:
def __init__(self, base_policy: FanPolicy, special_policies: List[FanPolicy]):
self.base_policy = base_policy
self.special_policies = special_policies
def get_policy(self, time: datetime.time) -> FanPolicy:
def filt(p: FanPolicy):
if p.time_start > p.time_finish:
return p.time_start <= time <= datetime.time(23, 59, 59, 999999) \
or datetime.time(0) <= time <= p.time_finish
return p.time_start <= time <= p.time_finish
return next(filter(filt, self.special_policies), self.base_policy)
def current_policy(self, tz: pytz.timezone) -> FanPolicy:
return self.get_policy(datetime.datetime.now(tz=tz).time())
def __str__(self):
return f'Base policy: {self.base_policy} | Special policies:' \
f' {{ {"; ".join(map(str, self.special_policies))} }}'
| [
"[email protected]"
] | |
673ee37339172d144ea7b6e9f5e73d58dadf9be4 | f07a42f652f46106dee4749277d41c302e2b7406 | /Data Set/bug-fixing-5/8b7a58c9611cc5b5683e5a3a52461d8f9179eca0-<getfolders>-bug.py | 2bda93dc1adbedd1338b111a0521a6b2fcd9fbfd | [] | no_license | wsgan001/PyFPattern | e0fe06341cc5d51b3ad0fe29b84098d140ed54d1 | cc347e32745f99c0cd95e79a18ddacc4574d7faa | refs/heads/main | 2023-08-25T23:48:26.112133 | 2021-10-23T14:11:22 | 2021-10-23T14:11:22 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 191 | py | def getfolders(self):
if (not self.datacenter):
self.get_datacenter()
self.folders = self._build_folder_tree(self.datacenter.vmFolder)
self._build_folder_map(self.folders) | [
"[email protected]"
] | |
fb53eb588a4faefc13994b172e7b3d6a0943885b | 97e9e4c2ab8efd940946f5d28a3bab0da647ca0b | /huxley/accounts/tests/models.py | f6a0bb209703e66d80a1776990a19f76587a4435 | [
"BSD-2-Clause",
"BSD-3-Clause"
] | permissive | tdowds/huxley | d9df0068d89ffd3f6c855be6c9ae7c3f15bedc3e | 6705ef2d64408389cf55388abbad70beb7025158 | refs/heads/master | 2021-01-20T06:33:01.898577 | 2013-10-18T16:07:58 | 2013-10-18T16:07:58 | 13,706,299 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,952 | py | # Copyright (c) 2011-2013 Kunal Mehta. All rights reserved.
# Use of this source code is governed by a BSD License found in README.md.
from django.test import TestCase
from huxley.accounts.constants import *
from huxley.accounts.models import *
class HuxleyUserTest(TestCase):
def test_authenticate(self):
""" Tests that the function correctly authenticates and returns a
user, or returns an error message. """
kunal = HuxleyUser.objects.create(username='kunal', email='[email protected]')
kunal.set_password('kunalmehta')
kunal.save()
user, error = HuxleyUser.authenticate('kunal', '')
self.assertIsNone(user)
self.assertEqual(error, AuthenticationErrors.MISSING_FIELDS)
user, error = HuxleyUser.authenticate('', 'kunalmehta')
self.assertIsNone(user)
self.assertEqual(error, AuthenticationErrors.MISSING_FIELDS)
user, error = HuxleyUser.authenticate('roflrofl', 'roflrofl')
self.assertIsNone(user)
self.assertEqual(error, AuthenticationErrors.INVALID_LOGIN)
user, error = HuxleyUser.authenticate('kunal', 'kunalmehta')
self.assertEqual(user, kunal)
self.assertIsNone(error)
def test_change_password(self):
""" Tests that the function correctly changes a user's password, or
returns an error message. """
user = HuxleyUser.objects.create(username='adavis', email='[email protected]')
user.set_password('mr_davis')
success, error = user.change_password('', 'lololol', 'lololol')
self.assertFalse(success)
self.assertEquals(ChangePasswordErrors.MISSING_FIELDS, error)
success, error = user.change_password('mr_davis', '', 'lololol')
self.assertFalse(success)
self.assertEquals(ChangePasswordErrors.MISSING_FIELDS, error)
success, error = user.change_password('mr_davis', 'lololol', '')
self.assertFalse(success)
self.assertEquals(ChangePasswordErrors.MISSING_FIELDS, error)
success, error = user.change_password('mr_davis', 'lololol', 'roflrofl')
self.assertFalse(success)
self.assertEquals(ChangePasswordErrors.MISMATCHED_PASSWORDS, error)
success, error = user.change_password('mr_davis', 'lol', 'lol')
self.assertFalse(success)
self.assertEquals(ChangePasswordErrors.PASSWORD_TOO_SHORT, error)
success, error = user.change_password('mr_davis', 'lololol<', 'lololol<')
self.assertFalse(success)
self.assertEquals(ChangePasswordErrors.INVALID_CHARACTERS, error)
success, error = user.change_password('roflrofl', 'lololol', 'lololol')
self.assertFalse(success)
self.assertEquals(ChangePasswordErrors.INCORRECT_PASSWORD, error)
success, error = user.change_password('mr_davis', 'lololol', 'lololol')
self.assertTrue(success)
self.assertTrue(user.check_password('lololol')) | [
"[email protected]"
] | |
6aac625e1e0f348f3464e7dd1517a655dc5aab7e | 6fa7f99d3d3d9b177ef01ebf9a9da4982813b7d4 | /QWAqDyd9RXqyrNyo3_15.py | b3247adb587b049bdda014c190a3be66d5086b08 | [] | no_license | daniel-reich/ubiquitous-fiesta | 26e80f0082f8589e51d359ce7953117a3da7d38c | 9af2700dbe59284f5697e612491499841a6c126f | refs/heads/master | 2023-04-05T06:40:37.328213 | 2021-04-06T20:17:44 | 2021-04-06T20:17:44 | 355,318,759 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 177 | py |
def abbreviate(txt,n=4) :
output = ""
crap = txt.split(" ")
for each in crap :
if len(each) >= n :
output += each[0].upper()
return output
| [
"[email protected]"
] | |
3e0f87cbc1d9d3d745df80682fabac642e330b46 | 5279b3fd3b0cba9e1ca5552229bf6d32c3c0bb44 | /ch08_Tensorflow/ex09_Functional_API_2_GoogLeNet.py | 71df88cd007238767bd256db09a478a6f32ed4d2 | [] | no_license | handaeho/lab_dl | 16afe29b1b6db005cdae8ef9cc1f5f675ea34cf8 | 99ddcadec0c93bd42113f6b5fbecd9171c030f8b | refs/heads/master | 2020-11-30T08:42:39.506059 | 2020-02-11T05:22:32 | 2020-02-11T05:22:32 | 230,358,647 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,285 | py | """
>> GoogLeNet - (교재 P.271 그림 8-10)
= layer를 하나씩 쌓아 올려 순차적으로 통과 하지 않고,
layer가 수평적으로 놓여 있고, 이 여러 layer를 하나의 데이터에 한꺼번에 적용해서 그 결과를 결합 후, 다음 구조로 보낸다.
이 구조를 'Inception'이라 하며, 'Inception'구조를 하나의 구성 요소로 여러개를 결합하여 사용하는 것이 GoogLeNet의 특징이다.
단, 같은 층에 수평적으로 놓인 layer는 서로 연결 되지 않는다.
================================================================================================================
>> ResNet(Residual Network) - (교재 P.272 그림 8-12)
= 학습할 때 층이 지나치게 깊으면 학습이 잘 되지 않고, 오히려 성능이 떨어진다.
ResNet에서는 이 문제를 해결하기 위해 '스킵 연결'을 도입한다. 층의 깊이에 비례해 성능 향상을 기대할 수 있다.
# 스킵 연결 ~> 입력 데이터를 Convolution_layer를 건너 뛰고 바로 Output에 더하는 구조.
입력 x를 연속한 두 Conv_layer를 건너 뛰고 출력에 바로 연결한다.
이 단축 경로가 없다면 Output은 'F(x)'가 되지만, 스킵연결로 인해 Output은 'F(x) + x'가 된다.
스킵 연결은 층이 깊어져도 학습을 효율적으로 할수 있게 해주는데,
이는 Back Propagation 때 스킵 연결이 신호 감쇠를 막아주기 때문이다.
스킵 연결은 입력 데이터를 '그대로'흘리는 것으로, 역전파 때도 상류의 기울기를 그래도 하류로 보낸다.
핵심은 상류의 기울기에 아무런 수정도 하지 않고 '그대로' 흘리는 것이다.
스킵 연결로 기울기가 작아지거나 지나치게 커질 걱정 없이 앞 층에서의 '의미있는 기울기'를 하류로 전할수 있다.
ResNet은 Conv_layer를 2개 층마다 건너뛰면서 층을 깊게 한다.
# 전이 학습 ~> 학습된 가중치(또는 그 일부)를 다른 신경망에 복사한 후, 그대로 재학습을 수행한다.
예를 들어, VGG와 구성이 같은 신경망을 준비하고 미리 학습된 가중치를 초기값으로 설정한 후,
새로운 데이터 셋으로 재학습을 수행한다.
전이 학습은 '보유한 데이터 셋이 적을 때 유용'한 방법이다.
여기서는 'GoogLeNet', 'ResNet'의 구조 그대로를 구현 하지는 않고, 'ex08_Functional_API'에 이어 같은 구조를 구현해 보자.
1) GoogLeNet
Input_tensor(784, ) -> Dense(64) -> ReLU -> Dense(32) -> ReLU -> Dense(10) -> Output_tensor(10, ) -> Softmax
-> Dense(64) -> ReLU ->
2) ResNet
Input_tensor(784, ) -> Dense(32) -> ReLU -> [건너뛰고 Dense(32) -> ReLU -> Dense(32) -> ReLU]
-> F(x) + x -> Output_tensor(10, ) -> Softmax
"""
from tensorflow.keras import Input, Model
from tensorflow.keras.layers import Dense, Add, concatenate
# GoogLeNet ===========================================
# Input_tensor 생성
input_tensor = Input(shape=(784,))
# Input_tensor가 한 층에 수평적으로 놓인 두 개의 hidden_layer(Dense layer)를 각각 통과
x1 = Dense(units=64, activation='relu')(input_tensor)
x2 = Dense(units=64, activation='relu')(input_tensor)
# 두 개의 hidden_layer(Dense layer)를 통과한 두 결과를 연결
concat = concatenate([x1, x2])
# 그 다음 hidden_layer에 연결된 결과 전달
x = Dense(32, activation='relu')(concat)
# Output_tensor
output_tensor = Dense(10, activation='softmax')(x)
# 모델 생성
model = Model(input_tensor, output_tensor)
# 모델 정보 요약
model.summary()
# ResNet ===========================================
# input_tensor 생성
input_tensor = Input(shape=(784, ))
# hidden_layer(Dense)
fx = Dense(units=32, activation='relu')(input_tensor)
x = Dense(units=32, activation='relu')(fx)
x = Dense(units=32, activation='relu')(x)
# 입력데이터 x를 출력에 더해준다.(F(x) + x)
x = Add()([x, fx])
# F(x) + x를 output_tensor에 전달
output_tensor = Dense(10, activation='softmax')(x)
# 모델 생성
model = Model(input_tensor, output_tensor)
# 모델 정보 요약
model.summary() | [
"[email protected]"
] | |
2960d22b7267e18644fa6fd6755edc830f88df53 | bc41457e2550489ebb3795f58b243da74a1c27ae | /python/plot_daily_solar_energy.py | dcf30c21d78a663dfaca75668a7998236822581c | [] | no_license | SEL-Columbia/ss_sql_views | 28a901d95fe779b278d2a51aec84d6bf51245c02 | d146fd96849a4d165f3dc3f197aadda804a2f60a | refs/heads/master | 2021-01-01T19:35:18.999147 | 2012-05-10T18:43:36 | 2012-05-10T18:43:36 | 3,020,367 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,891 | py | '''
plot_daily_solar_energy.py
==============================
uses the midnight values of the reported cumulative kWh to generate
a daily report of energy delivered to the battery
only reports on days where there are two consecutive readings
right now uses numpy to do differentiation, should use postgres lag instead
'''
import datetime as dt
date_start = dt.datetime(2011, 11, 01)
date_end = dt.datetime(2012, 12, 31)
meter_name = 'ml05'
def plot_solar_power_generation():
import sqlalchemy as sa
# create metadata object
metadata = sa.MetaData('postgres://postgres:postgres@localhost:5432/gateway')
# define table objects from database
vspm = sa.Table('view_solar_midnight', metadata, autoload=True)
query = sa.select([vspm.c.meter_timestamp, vspm.c.solar_kwh],
distinct=True,
order_by=vspm.c.meter_timestamp,
whereclause=sa.and_(vspm.c.meter_name==meter_name,
vspm.c.meter_timestamp>date_start,
vspm.c.meter_timestamp<date_end)
)
print query
# get list of meter names in solar logs
meter_timestamp = []
solar_kwh = []
result = query.execute()
for r in result:
print r
meter_timestamp.append(r.meter_timestamp)
solar_kwh.append(r.solar_kwh)
import numpy as np
meter_timestamp = np.array(meter_timestamp)
solar_kwh = np.array(solar_kwh)
solar_kwh_per_day = np.diff(solar_kwh)
td = np.diff(meter_timestamp)
meter_timestamp= meter_timestamp[td==dt.timedelta(days=1)]
solar_kwh = solar_kwh_per_day[td==dt.timedelta(days=1)]
import matplotlib.pyplot as plt
f, ax = plt.subplots(1,1)
ax.plot_date(meter_timestamp, solar_kwh)
plt.show()
if __name__ == '__main__':
plot_solar_power_generation() | [
"[email protected]"
] | |
50a70d665e3a1ff4e1a9f9a53f1059cb92335f0e | d35167f7ab29813d926bd702fa652090556befdf | /generated/test_MoonBlvd_tad_IROS2019.py | fe292ec69895284f2b58609e7050fe5a27f4fbfe | [] | no_license | jansel/pytorch-jit-paritybench | 65e5311d43daf5065beac52a68488ce188199fa8 | 7e55a422588c1d1e00f35a3d3a3ff896cce59e18 | refs/heads/master | 2023-08-12T04:43:16.669114 | 2023-06-08T17:36:32 | 2023-06-08T17:36:32 | 270,464,378 | 35 | 15 | null | 2023-06-08T17:36:34 | 2020-06-07T23:42:50 | Python | UTF-8 | Python | false | false | 11,483 | py | import sys
_module = sys.modules[__name__]
del sys
config = _module
A3D_download = _module
A3D_split = _module
anomaly_measures = _module
rnn_ed = _module
trackers = _module
utils = _module
data_prep_utils = _module
eval_utils = _module
flow_utils = _module
fol_dataloader = _module
train_val_utils = _module
visualize_utils = _module
run_AD = _module
run_fol_for_AD = _module
clear_detection_results = _module
merge_hevi_pkls = _module
odo_to_ego_motion = _module
video2frames = _module
test_fol = _module
train_ego_pred = _module
train_fol = _module
from _paritybench_helpers import _mock_config, patch_functional
from unittest.mock import mock_open, MagicMock
from torch.autograd import Function
from torch.nn import Module
import abc, collections, copy, enum, functools, inspect, itertools, logging, math, matplotlib, numbers, numpy, pandas, queue, random, re, scipy, sklearn, string, tensorflow, time, torch, torchaudio, torchtext, torchvision, types, typing, uuid, warnings
import numpy as np
from torch import Tensor
patch_functional()
open = mock_open()
yaml = logging = sys = argparse = MagicMock()
ArgumentParser = argparse.ArgumentParser
_global_config = args = argv = cfg = config = params = _mock_config()
argparse.ArgumentParser.return_value.parse_args.return_value = _global_config
yaml.load.return_value = _global_config
sys.argv = _global_config
__version__ = '1.0.0'
xrange = range
wraps = functools.wraps
import numpy as np
import copy
import torch
from torch import nn
from torch import optim
from torch.nn import functional as F
from collections import deque
from torch.utils import data
import matplotlib.pyplot as plt
import time
class EncoderGRU(nn.Module):
def __init__(self, args):
super(EncoderGRU, self).__init__()
self.args = args
self.enc = nn.GRUCell(input_size=self.args.input_embed_size, hidden_size=self.args.enc_hidden_size)
def forward(self, embedded_input, h_init):
"""
The encoding process
Params:
x: input feature, (batch_size, time, feature dims)
h_init: initial hidden state, (batch_size, enc_hidden_size)
Returns:
h: updated hidden state of the next time step, (batch.size, enc_hiddden_size)
"""
h = self.enc(embedded_input, h_init)
return h
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
class DecoderGRU(nn.Module):
def __init__(self, args):
super(DecoderGRU, self).__init__()
self.args = args
self.hidden_to_pred_input = nn.Sequential(nn.Linear(self.args.dec_hidden_size, self.args.predictor_input_size), nn.ReLU())
self.dec = nn.GRUCell(input_size=self.args.predictor_input_size, hidden_size=self.args.dec_hidden_size)
if self.args.non_linear_output:
self.hidden_to_pred = nn.Sequential(nn.Linear(self.args.dec_hidden_size, self.args.pred_dim), nn.Tanh())
else:
self.hidden_to_pred = nn.Linear(self.args.dec_hidden_size, self.args.pred_dim)
def forward(self, h, embedded_ego_pred=None):
"""
A RNN preditive model for future observation prediction
Params:
h: hidden state tensor from the encoder, (batch_size, enc_hidden_size)
embedded_ego_pred: (batch_size, pred_timesteps, input_embed_size)
"""
output = torch.zeros(h.shape[0], self.args.pred_timesteps, self.args.pred_dim)
all_pred_h = torch.zeros([h.shape[0], self.args.pred_timesteps, self.args.dec_hidden_size])
all_pred_inputs = torch.zeros([h.shape[0], self.args.pred_timesteps, self.args.predictor_input_size])
pred_inputs = torch.zeros(h.shape[0], self.args.predictor_input_size)
for i in range(self.args.pred_timesteps):
if self.args.with_ego:
pred_inputs = (embedded_ego_pred[:, i, :] + pred_inputs) / 2
all_pred_inputs[:, i, :] = pred_inputs
h = self.dec(pred_inputs, h)
pred_inputs = self.hidden_to_pred_input(h)
all_pred_h[:, i, :] = h
output[:, i, :] = self.hidden_to_pred(h)
return output, all_pred_h, all_pred_inputs
class FolRNNED(nn.Module):
"""Future object localization module"""
def __init__(self, args):
super(FolRNNED, self).__init__()
self.args = copy.deepcopy(args)
self.box_enc_args = copy.deepcopy(args)
self.flow_enc_args = copy.deepcopy(args)
if self.args.enc_concat_type == 'cat':
self.args.dec_hidden_size = self.args.box_enc_size + self.args.flow_enc_size
elif self.args.box_enc_size != self.args.flow_enc_size:
raise ValueError('Box encoder size %d != flow encoder size %d' % (self.args.box_enc_size, self.args.flow_enc_size))
else:
self.args.dec_hidden_size = self.args.box_enc_size
self.box_enc_args.enc_hidden_size = self.args.box_enc_size
self.flow_enc_args.enc_hidden_size = self.args.flow_enc_size
self.box_encoder = EncoderGRU(self.box_enc_args)
self.flow_encoder = EncoderGRU(self.flow_enc_args)
self.args.non_linear_output = True
self.predictor = DecoderGRU(self.args)
self.box_embed = nn.Sequential(nn.Linear(4, self.args.input_embed_size), nn.ReLU())
self.flow_embed = nn.Sequential(nn.Linear(50, self.args.input_embed_size), nn.ReLU())
self.ego_pred_embed = nn.Sequential(nn.Linear(3, self.args.input_embed_size), nn.ReLU())
def forward(self, box, flow, ego_pred):
"""
The RNN encoder decoder model rewritten from fvl2019icra-keras
Params:
box: (batch_size, segment_len, 4)
flow: (batch_size, segment_len, 5, 5, 2)
ego_pred: (batch_size, segment_len, pred_timesteps, 3) or None
for training and validation, segment_len is large, e.g. 10
for online testing, segment_len=1
return:
fol_predictions: predicted with shape (batch_size, segment_len, pred_timesteps, pred_dim)
"""
self.args.batch_size = box.shape[0]
if len(flow.shape) > 3:
flow = flow.view(self.args.batch_size, self.args.segment_len, -1)
embedded_box_input = self.box_embed(box)
embedded_flow_input = self.flow_embed(flow)
embedded_ego_input = self.ego_pred_embed(ego_pred)
box_h = torch.zeros(self.args.batch_size, self.args.box_enc_size)
flow_h = torch.zeros(self.args.batch_size, self.args.flow_enc_size)
fol_predictions = torch.zeros(self.args.batch_size, self.args.segment_len, self.args.pred_timesteps, self.args.pred_dim)
for i in range(self.args.segment_len):
box_h = self.box_encoder(embedded_box_input[:, i, :], box_h)
flow_h = self.flow_encoder(embedded_flow_input[:, i, :], flow_h)
if self.args.enc_concat_type == 'cat':
hidden_state = torch.cat((box_h, flow_h), dims=1)
elif self.args.enc_concat_type in ['sum', 'avg', 'average']:
hidden_state = (box_h + flow_h) / 2
else:
raise NameError(self.args.enc_concat_type, ' is unknown!!')
if self.args.with_ego:
output, _, _ = self.predictor(hidden_state, embedded_ego_input[:, i, :, :])
else:
output, _, _ = self.predictor(hidden_state, None)
fol_predictions[:, i, :, :] = output
return fol_predictions
def predict(self, box, flow, box_h, flow_h, ego_pred):
"""
predictor function, run forward inference to predict the future bboxes
Params:
box: (1, 4)
flow: (1, 1, 5, 5, 2)
ego_pred: (1, pred_timesteps, 3)
return:
box_changes:()
box_h,
flow_h
"""
if len(flow.shape) > 3:
flow = flow.view(1, -1)
embedded_box_input = self.box_embed(box)
embedded_flow_input = self.flow_embed(flow)
embedded_ego_input = None
if self.args.with_ego:
embedded_ego_input = self.ego_pred_embed(ego_pred)
box_h = self.box_encoder(embedded_box_input, box_h)
flow_h = self.flow_encoder(embedded_flow_input, flow_h)
if self.args.enc_concat_type == 'cat':
hidden_state = torch.cat((box_h, flow_h), dims=1)
elif self.args.enc_concat_type in ['sum', 'avg', 'average']:
hidden_state = (box_h + flow_h) / 2
else:
raise NameError(self.args.enc_concat_type, ' is unknown!!')
box_changes, _, _ = self.predictor(hidden_state, embedded_ego_input)
return box_changes, box_h, flow_h
class EgoRNNED(nn.Module):
def __init__(self, args):
super(EgoRNNED, self).__init__()
self.args = copy.deepcopy(args)
self.args.input_embed_size = self.args.ego_embed_size
self.args.enc_hidden_size = self.args.ego_enc_size
self.args.dec_hidden_size = self.args.ego_dec_size
self.args.pred_dim = self.args.ego_dim
self.args.predictor_input_size = self.args.ego_pred_input_size
self.args.with_ego = False
self.ego_encoder = EncoderGRU(self.args)
self.ego_embed = nn.Sequential(nn.Linear(3, self.args.ego_embed_size), nn.ReLU())
self.args.non_linear_output = False
self.predictor = DecoderGRU(self.args)
def forward(self, ego_x, image=None):
"""
The RNN encoder decoder model for ego motion prediction
Params:
ego_x: (batch_size, segment_len, ego_dim)
image: (batch_size, segment_len, feature_dim) e.g. feature_dim = 1024
for training and validation, segment_len is large, e.g. 10
for online testing, segment_len=1
return:
predictions: predicted ego motion with shape (batch_size, segment_len, pred_timesteps, ego_dim)
"""
self.args.batch_size = ego_x.shape[0]
embedded_ego_input = self.ego_embed(ego_x)
ego_h = torch.zeros(self.args.batch_size, self.args.enc_hidden_size)
predictions = torch.zeros(self.args.batch_size, self.args.segment_len, self.args.pred_timesteps, self.args.pred_dim)
for i in range(self.args.segment_len):
ego_h = self.ego_encoder(embedded_ego_input[:, i, :], ego_h)
output, _, _ = self.predictor(ego_h)
predictions[:, i, :, :] = output
return predictions
def predict(self, ego_x, ego_h, image=None):
"""
Params:
ego_x: (1, 3)
ego_h: (1, 64)
#image: (1, 1, 1024) e.g. feature_dim = 1024
returns:
ego_changes: (pred_timesteps, 3)
ego_h: (1, ego_enc_size)
"""
embedded_ego_input = self.ego_embed(ego_x)
ego_h = self.ego_encoder(embedded_ego_input, ego_h)
ego_changes, _, _ = self.predictor(ego_h)
return ego_changes, ego_h
import torch
from torch.nn import MSELoss, ReLU
from _paritybench_helpers import _mock_config, _mock_layer, _paritybench_base, _fails_compile
TESTCASES = [
# (nn.Module, init_args, forward_args, jit_compiles)
(EncoderGRU,
lambda: ([], {'args': _mock_config(input_embed_size=4, enc_hidden_size=4)}),
lambda: ([torch.rand([4, 4]), torch.rand([4, 4])], {}),
True),
]
class Test_MoonBlvd_tad_IROS2019(_paritybench_base):
def test_000(self):
self._check(*TESTCASES[0])
| [
"[email protected]"
] | |
442e19fea6f5eefca17300bcd373e28f2cf4252b | f23cb520fc28df4cc00549836b0419cb04a3ea12 | /homeassistant/components/xiaomi_miio/binary_sensor.py | ca421486a353f7042f2c96d115fd230400b0398e | [
"Apache-2.0"
] | permissive | cgtobi/home-assistant | 0273adee3899ab0a4f3239c06619ed69ffa84a99 | b13e14b80cd0667b62228f3121cfe28ab5dfcd92 | refs/heads/dev | 2023-01-23T05:38:02.805066 | 2022-03-24T17:58:58 | 2022-03-24T17:58:58 | 91,916,194 | 1 | 0 | Apache-2.0 | 2020-08-27T12:52:10 | 2017-05-20T21:03:39 | Python | UTF-8 | Python | false | false | 8,683 | py | """Support for Xiaomi Miio binary sensors."""
from __future__ import annotations
from collections.abc import Callable
from dataclasses import dataclass
import logging
from homeassistant.components.binary_sensor import (
BinarySensorDeviceClass,
BinarySensorEntity,
BinarySensorEntityDescription,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.entity import EntityCategory
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from . import VacuumCoordinatorDataAttributes
from .const import (
CONF_DEVICE,
CONF_FLOW_TYPE,
CONF_MODEL,
DOMAIN,
KEY_COORDINATOR,
KEY_DEVICE,
MODEL_AIRFRESH_A1,
MODEL_AIRFRESH_T2017,
MODEL_FAN_ZA5,
MODELS_HUMIDIFIER_MIIO,
MODELS_HUMIDIFIER_MIOT,
MODELS_HUMIDIFIER_MJJSQ,
MODELS_VACUUM,
MODELS_VACUUM_WITH_MOP,
MODELS_VACUUM_WITH_SEPARATE_MOP,
)
from .device import XiaomiCoordinatedMiioEntity
_LOGGER = logging.getLogger(__name__)
ATTR_NO_WATER = "no_water"
ATTR_PTC_STATUS = "ptc_status"
ATTR_POWERSUPPLY_ATTACHED = "powersupply_attached"
ATTR_WATER_TANK_DETACHED = "water_tank_detached"
ATTR_MOP_ATTACHED = "is_water_box_carriage_attached"
ATTR_WATER_BOX_ATTACHED = "is_water_box_attached"
ATTR_WATER_SHORTAGE = "is_water_shortage"
@dataclass
class XiaomiMiioBinarySensorDescription(BinarySensorEntityDescription):
"""A class that describes binary sensor entities."""
value: Callable | None = None
parent_key: str | None = None
BINARY_SENSOR_TYPES = (
XiaomiMiioBinarySensorDescription(
key=ATTR_NO_WATER,
name="Water Tank Empty",
icon="mdi:water-off-outline",
entity_category=EntityCategory.DIAGNOSTIC,
),
XiaomiMiioBinarySensorDescription(
key=ATTR_WATER_TANK_DETACHED,
name="Water Tank",
icon="mdi:car-coolant-level",
device_class=BinarySensorDeviceClass.CONNECTIVITY,
value=lambda value: not value,
entity_category=EntityCategory.DIAGNOSTIC,
),
XiaomiMiioBinarySensorDescription(
key=ATTR_PTC_STATUS,
name="Auxiliary Heat Status",
device_class=BinarySensorDeviceClass.POWER,
entity_category=EntityCategory.DIAGNOSTIC,
),
XiaomiMiioBinarySensorDescription(
key=ATTR_POWERSUPPLY_ATTACHED,
name="Power Supply",
device_class=BinarySensorDeviceClass.PLUG,
entity_category=EntityCategory.DIAGNOSTIC,
),
)
AIRFRESH_A1_BINARY_SENSORS = (ATTR_PTC_STATUS,)
FAN_ZA5_BINARY_SENSORS = (ATTR_POWERSUPPLY_ATTACHED,)
VACUUM_SENSORS = {
ATTR_MOP_ATTACHED: XiaomiMiioBinarySensorDescription(
key=ATTR_WATER_BOX_ATTACHED,
name="Mop Attached",
icon="mdi:square-rounded",
parent_key=VacuumCoordinatorDataAttributes.status,
entity_registry_enabled_default=True,
device_class=BinarySensorDeviceClass.CONNECTIVITY,
entity_category=EntityCategory.DIAGNOSTIC,
),
ATTR_WATER_BOX_ATTACHED: XiaomiMiioBinarySensorDescription(
key=ATTR_WATER_BOX_ATTACHED,
name="Water Box Attached",
icon="mdi:water",
parent_key=VacuumCoordinatorDataAttributes.status,
entity_registry_enabled_default=True,
device_class=BinarySensorDeviceClass.CONNECTIVITY,
entity_category=EntityCategory.DIAGNOSTIC,
),
ATTR_WATER_SHORTAGE: XiaomiMiioBinarySensorDescription(
key=ATTR_WATER_SHORTAGE,
name="Water Shortage",
icon="mdi:water",
parent_key=VacuumCoordinatorDataAttributes.status,
entity_registry_enabled_default=True,
device_class=BinarySensorDeviceClass.PROBLEM,
entity_category=EntityCategory.DIAGNOSTIC,
),
}
VACUUM_SENSORS_SEPARATE_MOP = {
**VACUUM_SENSORS,
ATTR_MOP_ATTACHED: XiaomiMiioBinarySensorDescription(
key=ATTR_MOP_ATTACHED,
name="Mop Attached",
icon="mdi:square-rounded",
parent_key=VacuumCoordinatorDataAttributes.status,
entity_registry_enabled_default=True,
device_class=BinarySensorDeviceClass.CONNECTIVITY,
entity_category=EntityCategory.DIAGNOSTIC,
),
}
HUMIDIFIER_MIIO_BINARY_SENSORS = (ATTR_WATER_TANK_DETACHED,)
HUMIDIFIER_MIOT_BINARY_SENSORS = (ATTR_WATER_TANK_DETACHED,)
HUMIDIFIER_MJJSQ_BINARY_SENSORS = (ATTR_NO_WATER, ATTR_WATER_TANK_DETACHED)
def _setup_vacuum_sensors(hass, config_entry, async_add_entities):
"""Only vacuums with mop should have binary sensor registered."""
if config_entry.data[CONF_MODEL] not in MODELS_VACUUM_WITH_MOP:
return
device = hass.data[DOMAIN][config_entry.entry_id].get(KEY_DEVICE)
coordinator = hass.data[DOMAIN][config_entry.entry_id][KEY_COORDINATOR]
entities = []
sensors = VACUUM_SENSORS
if config_entry.data[CONF_MODEL] in MODELS_VACUUM_WITH_SEPARATE_MOP:
sensors = VACUUM_SENSORS_SEPARATE_MOP
for sensor, description in sensors.items():
parent_key_data = getattr(coordinator.data, description.parent_key)
if getattr(parent_key_data, description.key, None) is None:
_LOGGER.debug(
"It seems the %s does not support the %s as the initial value is None",
config_entry.data[CONF_MODEL],
description.key,
)
continue
entities.append(
XiaomiGenericBinarySensor(
f"{config_entry.title} {description.name}",
device,
config_entry,
f"{sensor}_{config_entry.unique_id}",
coordinator,
description,
)
)
async_add_entities(entities)
async def async_setup_entry(
hass: HomeAssistant,
config_entry: ConfigEntry,
async_add_entities: AddEntitiesCallback,
) -> None:
"""Set up the Xiaomi sensor from a config entry."""
entities = []
if config_entry.data[CONF_FLOW_TYPE] == CONF_DEVICE:
model = config_entry.data[CONF_MODEL]
sensors = []
if model in MODEL_AIRFRESH_A1 or model in MODEL_AIRFRESH_T2017:
sensors = AIRFRESH_A1_BINARY_SENSORS
elif model in MODEL_FAN_ZA5:
sensors = FAN_ZA5_BINARY_SENSORS
elif model in MODELS_HUMIDIFIER_MIIO:
sensors = HUMIDIFIER_MIIO_BINARY_SENSORS
elif model in MODELS_HUMIDIFIER_MIOT:
sensors = HUMIDIFIER_MIOT_BINARY_SENSORS
elif model in MODELS_HUMIDIFIER_MJJSQ:
sensors = HUMIDIFIER_MJJSQ_BINARY_SENSORS
elif model in MODELS_VACUUM:
return _setup_vacuum_sensors(hass, config_entry, async_add_entities)
for description in BINARY_SENSOR_TYPES:
if description.key not in sensors:
continue
entities.append(
XiaomiGenericBinarySensor(
f"{config_entry.title} {description.name}",
hass.data[DOMAIN][config_entry.entry_id][KEY_DEVICE],
config_entry,
f"{description.key}_{config_entry.unique_id}",
hass.data[DOMAIN][config_entry.entry_id][KEY_COORDINATOR],
description,
)
)
async_add_entities(entities)
class XiaomiGenericBinarySensor(XiaomiCoordinatedMiioEntity, BinarySensorEntity):
"""Representation of a Xiaomi Humidifier binary sensor."""
entity_description: XiaomiMiioBinarySensorDescription
def __init__(self, name, device, entry, unique_id, coordinator, description):
"""Initialize the entity."""
super().__init__(name, device, entry, unique_id, coordinator)
self.entity_description = description
self._attr_entity_registry_enabled_default = (
description.entity_registry_enabled_default
)
self._attr_is_on = self._determine_native_value()
@callback
def _handle_coordinator_update(self) -> None:
self._attr_is_on = self._determine_native_value()
super()._handle_coordinator_update()
def _determine_native_value(self):
"""Determine native value."""
if self.entity_description.parent_key is not None:
return self._extract_value_from_attribute(
getattr(self.coordinator.data, self.entity_description.parent_key),
self.entity_description.key,
)
state = self._extract_value_from_attribute(
self.coordinator.data, self.entity_description.key
)
if self.entity_description.value is not None and state is not None:
return self.entity_description.value(state)
return state
| [
"[email protected]"
] | |
6c1b68b9d40da4fc90059b3ddcde709deba188a0 | c0f86b926fc82baa633862896096c149dd9913cf | /Python/Numpy/Concatenate/Pypy3/solution.py | de28d2f999a0276902fe41444343428ac5f95099 | [] | no_license | qxzsilver1/HackerRank | 8df74dd0cd4a9dedd778cdecea395f4234eda767 | bcb1b74711a625d8ad329a3f9fdd9f49b1bebc54 | refs/heads/master | 2021-09-09T15:45:35.681284 | 2021-09-07T00:11:16 | 2021-09-07T00:11:16 | 75,671,896 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 528 | py | # Enter your code here. Read input from STDIN. Print output to STDOUT
def matrix_printer(arr,n,m):
for i in range(n):
if i == 0:
print('[[' + ' '.join(map(str, arr[0][0:m])) + ']')
elif i == n-1:
print(' [' + ' '.join(map(str, arr[n-1][0:m])) + ']]')
else:
print(' [' + ' '.join(map(str, arr[i][0:m])) + ']')
n,m,p = map(int, input().split())
lst=[]
for _ in range(n+m):
lst.append(list(map(int,input().split())))
matrix_printer(lst,(n+m),p)
| [
"[email protected]"
] | |
e841be16c600c39b5a87a129e088eaac21922d22 | 5cc204e2ecb9a756127e7c71633a1edcdb3e989b | /pylmp/InKim/BGF_generateRigidScan.py | 4582dd6a832f4c8a5fea3760c6e6fcd038c80431 | [] | no_license | hopefulp/sandbox | 1a1d518cf7b5e6bca2b2776be1cac3d27fc4bcf8 | 4d26767f287be6abc88dc74374003b04d509bebf | refs/heads/master | 2023-06-27T17:50:16.637851 | 2023-06-15T03:53:39 | 2023-06-15T03:53:39 | 218,209,112 | 1 | 0 | null | 2022-09-13T13:22:34 | 2019-10-29T05:14:02 | C++ | UTF-8 | Python | false | false | 4,346 | py | #!/home/noische/python
import sys
import getopt
import copy
import numpy as np
import tqdm
import bgf
import bgftools
import nutils as nu
usage = """
Generates BGF file with changed distances between two molecules.
This is useful to generate input structures for Rigid Coordinate Scan.
Usage: %s -b bgf_file -1 atom1 -2 atom2 -o out_file -d "distances"
-b bgf_file: self-descriptive.
-1 atom1: atom number to fix.
-2 atom2: atom number to change distance. should be in another atom to atom1.
-o out_file: self-descriptive.
-d distances: self-descriptive. optional.
"-1.0 1.0 2.0" will generate three structures with those distances changed.
defaults: "-1.0 0.0 1.0 2.0 ... 10.0"
Please report any bugs to [email protected]
""" % sys.argv[0]
def generate_rcs(bgf_file, atom1, atom2, out_file, dist=[], silent=False):
# init
if not dist:
dist = np.arange(-1.0, 10.0, 1.0)
# open
if isinstance(bgf_file, bgf.BgfFile):
myBGF = bgf_file
else:
if not silent: print("reading " + bgf_file + " ..")
myBGF = bgf.BgfFile(bgf_file)
a1 = myBGF.a[myBGF.a2i[atom1]];
a2 = myBGF.a[myBGF.a2i[atom2]];
# check whether a1 and a2 are in a same molecule // the script cannot continue if yes
mol1 = []; mol2 = []
dummy = bgftools.getmolecule(myBGF, a1, mol1)
dummy = bgftools.getmolecule(myBGF, a2, mol2)
if mol1 == mol2:
nu.die("atom1 and atom2 are in a same molecule: cannot perform a rigid body scan within a same molecule.")
mybgf2 = copy.deepcopy(myBGF)
# translate the coordinate: atom1 to origin
v1 = (a1.x, a1.y, a1.z) # position of atom1
for atom in mybgf2.a:
atom.x -= v1[0]
atom.y -= v1[1]
atom.z -= v1[2]
# find the rotation matrix: v21 to x axis
v21 = [ (a2.x - a1.x), (a2.y - a1.y), (a2.z - a1.z) ]
u1 = v21 / np.linalg.norm(v21) ##
v2 = [u1[1], -u1[0], 0]; u2 = v2 / np.linalg.norm(v2) ##
v3 = np.cross(u1, u2); u3 = v3 / np.linalg.norm(v3) ##
U = np.array([[u1[0], u1[1], u1[2]], [u2[0], u2[1], u2[2]], [u3[0], u3[1], u3[2]]])
Uinv = np.linalg.inv(U)
for d in tqdm.tqdm(dist, ncols=120, desc="Creating RCS structures"):
mybgf2 = copy.deepcopy(myBGF)
# translate the coordinate: atom1 to origin
v1 = (a1.x, a1.y, a1.z) # position of atom1
for atom in mybgf2.a:
atom.x -= v1[0]
atom.y -= v1[1]
atom.z -= v1[2]
# rotate all atoms
for atom in mybgf2.a:
a = np.matrix([atom.x, atom.y, atom.z]).T
b = U*a
atom.x = float(b[0])
atom.y = float(b[1])
atom.z = float(b[2])
# move mol2 by d
for ano in mol2:
atom = mybgf2.getAtom(ano)
atom.x += d
# re-rotate all atoms
for atom in mybgf2.a:
a = np.matrix([atom.x, atom.y, atom.z]).T
b = Uinv*a
atom.x = float(b[0])
atom.y = float(b[1])
atom.z = float(b[2])
## save
fname = out_file.split(".bgf")[0] + "." + str("{0:.2f}".format(d)).replace(".", "p") + ".bgf"
mybgf2.saveBGF(fname)
### end of function
if __name__ == "__main__":
bgf_file = ""; trj_file = ""; atom1 = 0; atom2 = 0; out_file = ""; distance = ""
options, args = getopt.getopt(sys.argv[1:], 'hb:1:2:o:d:', ['help', 'bgf=', 'atom1=', 'atom2=', 'out=', 'distance='])
if len(sys.argv) < 2:
print(usage)
sys.exit(0)
print("Requested options: " + str(options))
for option, value in options:
if option in ('-h', '--help'):
print(usage)
sys.exit(0)
elif option in ('-b', '--bgf'):
bgf_file = value
elif option in ('-1', '--atom1'):
atom1 = int(value)
elif option in ('-2', '--atom2'):
atom2 = int(value)
elif option in ('-o', '--out'):
out_file = value
elif option in ('-d', '--distance'):
distance = str(value)
elif option == NULL:
print(usage)
sys.exit(0)
# scan distances:
dist = [float(i) for i in distance.split(' ')]
# main call
generate_rcs(bgf_file, atom1, atom2, out_file, dist=dist)
| [
"[email protected]"
] | |
2d8538f7bb2c08b6fd538d18d3dcbc1bfaeb3f2f | e8d4fe2361d71aef6519f666152f14137156159c | /impacket-0.9.11/build/lib.linux-i686-2.6/impacket/dcerpc/srvsvcserver.py | d80df6fc0ff0ff5fa473971bb1c06980322611fc | [
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0",
"Apache-1.1",
"BSD-2-Clause"
] | permissive | kenzshi/DDoSProject | 11d7e676a150964a9f78f1b7e1df4468dd9d973f | 9587a2be7f4773d19a96a35d1128f5041f0472da | refs/heads/master | 2021-01-10T19:48:21.355849 | 2015-03-16T09:52:22 | 2015-03-16T09:52:22 | 30,205,639 | 42 | 32 | null | null | null | null | UTF-8 | Python | false | false | 14,619 | py | # Copyright (c) 2003-2012 CORE Security Technologies
#
# This software is provided under under a slightly modified version
# of the Apache Software License. See the accompanying LICENSE file
# for more information.
#
# $Id: srvsvcserver.py 910 2013-11-08 19:13:10Z bethus $
#
# Author: Alberto Solino
#
# Description:
# A minimalist DCE RPC Server, just for the purpose (for now)
# of making smbserver to work better with Windows 7, when being asked
# for shares
#
import array
from impacket.dcerpc import dcerpc
from impacket.dcerpc.dcerpc import SEC_TRAILER
from impacket import ntlm
from impacket import uuid
from impacket.uuid import uuidtup_to_bin, generate, stringver_to_bin, bin_to_uuidtup
from impacket import structure
from impacket.structure import Structure
import socket
import struct
class DCERPCServer():
def __init__(self):
self._listenPort = 4343
self._listenAddress = '0.0.0.0'
self._listenUUIDS = []
self._callbacks = {}
self._boundUUID = ''
self._sock = None
self._clientSock = None
self._callid = 1
self._max_frag = None
self._max_xmit_size = 4280
def addCallbacks(self, UUID, callbacks):
# Format is [opnum] = callback
self._callbacks[uuidtup_to_bin(UUID)] = callbacks
self._listenUUIDS.append(uuidtup_to_bin(UUID))
print "Callback added for UUID %s V:%s" % UUID
def setListenPort(self, portNum):
self._listenPort = portNum
def recv(self):
finished = False
forceRecv = 0
retAnswer = ''
while not finished:
# At least give me the MSRPCRespHeader, especially important for TCP/UDP Transports
self.response_data = self._clientSock.recv(dcerpc.MSRPCRespHeader._SIZE)
# No data?, connection might have closed
if self.response_data == '':
return None
self.response_header = dcerpc.MSRPCRespHeader(self.response_data)
# Ok, there might be situation, especially with large packets, that the transport layer didn't send us the full packet's contents
# So we gotta check we received it all
while ( len(self.response_data) < self.response_header['frag_len'] ):
self.response_data += self._clientSock.recv(self.response_header['frag_len']-len(self.response_data))
self.response_header = dcerpc.MSRPCRespHeader(self.response_data)
if self.response_header['flags'] & dcerpc.MSRPC_LASTFRAG:
# No need to reassembly DCERPC
finished = True
else:
# Forcing Read Recv, we need more packets!
forceRecv = 1
answer = self.response_header['pduData']
auth_len = self.response_header['auth_len']
if auth_len:
auth_len += 8
auth_data = answer[-auth_len:]
sec_trailer = SEC_TRAILER(data = auth_data)
answer = answer[:-auth_len]
if sec_trailer['auth_pad_len']:
answer = answer[:-sec_trailer['auth_pad_len']]
retAnswer += answer
return self.response_data
def run(self):
self._sock = socket.socket()
self._sock.bind((self._listenAddress,self._listenPort))
self._sock.listen(10)
while True:
self._clientSock, address = self._sock.accept()
print "Connected from ", address
try:
while True:
data = self.recv()
if data is None:
# No data.. connection closed
break
answer = self.processRequest(data)
if answer != None:
self.send(answer)
except Exception, e:
#print e
print "Connection Finished!"
self._clientSock.close()
def send(self, data):
max_frag = self._max_frag
if len(data['pduData']) > self._max_xmit_size - 32:
max_frag = self._max_xmit_size - 32 # XXX: 32 is a safe margin for auth data
if self._max_frag:
max_frag = min(max_frag, self._max_frag)
if max_frag and len(data['pduData']) > 0:
packet = data['pduData']
offset = 0
while 1:
toSend = packet[offset:offset+max_frag]
if not toSend:
break
flags = 0
if offset == 0:
flags |= dcerpc.MSRPC_FIRSTFRAG
offset += len(toSend)
if offset == len(packet):
flags |= dcerpc.MSRPC_LASTFRAG
data['flags'] = flags
data['pduData'] = toSend
self._clientSock.send(data.get_packet())
else:
self._clientSock.send(data.get_packet())
self._callid += 1
def bind(self,packet, bind):
# Standard NDR Representation
NDRSyntax = ('8a885d04-1ceb-11c9-9fe8-08002b104860', '2.0')
resp = dcerpc.MSRPCBindAck()
resp['type'] = dcerpc.MSRPC_BINDACK
resp['flags'] = packet['flags']
resp['frag_len'] = 0
resp['auth_len'] = 0
resp['auth_data'] = ''
resp['call_id'] = packet['call_id']
resp['max_tfrag'] = bind['max_tfrag']
resp['max_rfrag'] = bind['max_rfrag']
resp['assoc_group'] = 0x1234
resp['SecondaryAddrLen'] = 4
resp['SecondaryAddr'] = '135'
resp['Pad'] ='A'*((4-((resp["SecondaryAddrLen"]+dcerpc.MSRPCBindAck._SIZE) % 4))%4)
resp['ctx_num'] = 0
data = bind['ctx_items']
ctx_items = ''
for i in range(bind['ctx_num']):
result = dcerpc.MSRPC_CONT_RESULT_USER_REJECT
item = dcerpc.CtxItem(data)
data = data[len(item):]
# First we check the Transfer Syntax is NDR32, what we support
#print "Trying to bind to: %s %s / %s %s" % (bin_to_uuidtup(item['AbstractSyntax']) + bin_to_uuidtup(item['TransferSyntax'])),
if item['TransferSyntax'] == uuidtup_to_bin(NDRSyntax):
# Now Check if the interface is what we listen
reason = 1 # Default, Abstract Syntax not supported
for i in self._listenUUIDS:
if item['AbstractSyntax'] == i:
# Match, we accept the bind request
reason = 0
self._boundUUID = i
else:
# Fail the bind request for this context
reason = 2 # Transfer Syntax not supported
if reason == 0:
result = dcerpc.MSRPC_CONT_RESULT_ACCEPT
#print "... OK!"
#else:
# print "... ERROR!"
resp['ctx_num'] += 1
itemResult = dcerpc.CtxItemResult()
itemResult['Result'] = result
itemResult['Reason'] = reason
itemResult['TransferSyntax'] = uuidtup_to_bin(NDRSyntax)
ctx_items += str(itemResult)
resp['ctx_items'] = ctx_items
resp['frag_len'] = len(str(resp))
self._clientSock.send(str(resp))
return None
def processRequest(self,data):
packet = dcerpc.MSRPCHeader(data)
if packet['type'] == dcerpc.MSRPC_BIND:
bind = dcerpc.MSRPCBind(packet['pduData'])
packet = self.bind(packet, bind)
elif packet['type'] == dcerpc.MSRPC_REQUEST:
request = dcerpc.MSRPCRequestHeader(data)
response = dcerpc.MSRPCRespHeader(data)
response['type'] = dcerpc.MSRPC_RESPONSE
# Serve the opnum requested, if not, fails
if self._callbacks[self._boundUUID].has_key(request['op_num']):
# Call the function
returnData = self._callbacks[self._boundUUID][request['op_num']](request['pduData'])
response['pduData'] = returnData
else:
response['type'] = dcerpc.MSRPC_FAULT
response['pduData'] = struct.pack('<L',0x000006E4L)
response['frag_len'] = len(response)
return response
else:
# Defaults to a fault
packet = dcerpc.MSRPCRespHeader(data)
packet['type'] = dcerpc.MSRPC_FAULT
return packet
from impacket.dcerpc import srvsvc
from impacket import smbserver
import ConfigParser
import struct
class SRVSVCShareInfo1(Structure):
alignment = 4
structure = (
('pNetName','<L'),
('Type','<L'),
('pRemark','<L'),
)
class SRVSVCShareGetInfo(Structure):
opnum = 16
alignment = 4
structure = (
('RefID','<L&ServerName'),
('ServerName','w'),
('NetName','w'),
('Level','<L=2'),
)
class SRVSVCShareInfo2(Structure):
alignment = 4
structure = (
('pNetName','<L&NetName'),
('Type','<L'),
('pRemark','<L&Remark'),
('Permissions','<L'),
('Max_Uses','<L'),
('Current_Uses','<L'),
('pPath','<L&Path'),
('pPassword','<L&Password'),
('NetName','w'),
('Remark','w'),
('Path','w'),
('Password','w'),
)
class SRVSVCSwitchpShareInfo2(Structure):
alignment = 4
structure = (
('Level','<L'),
('pInfo','<L&InfoStruct'),
('InfoStruct',':',SRVSVCShareInfo2),
)
class SRVSVCServerGetInfo(Structure):
opnum = 21
alignment = 4
structure = (
('RefID','<L&ServerName'),
('ServerName','w'),
('Level','<L=102'),
)
class SRVSVCServerInfo101(Structure):
alignment = 4
structure = (
('PlatFormID','<L=500'),
('pName','<L&Name'),
('VersionMajor','<L=5'),
('VersionMinor','<L=0'),
('Type','<L=1'),
('pComment','<L&Comment'),
('Name','w'),
('Comment','w'),
)
class SRVSVCServerpInfo101(Structure):
alignment = 4
structure = (
('Level','<L=101'),
('pInfo','<L&ServerInfo'),
('ServerInfo',':',SRVSVCServerInfo101),
)
class SRVSVCNetrShareEnum(Structure):
opnum = 15
alignment = 4
structure = (
('RefID','<L&ServerName'),
('ServerName','w'),
('Level','<L=0x1'),
('pShareEnum','<L=0x1'),
('p2','<L=0x5678'),
('count','<L=0'),
('NullP','<L=0'),
('PreferedMaximumLength','<L=0xffffffff'),
('pResumeHandler',':'),
)
def getData(self):
self['pResumeHandler'] = '\xbc\x9a\x00\x00\x00\x00\x00\x00'
return Structure.getData(self)
class SRVSVCShareEnumStruct(Structure):
alignment = 4
structure = (
('Level','<L'),
('pCount','<L=1'),
('Count','<L'),
('pMaxCount','<L&MaxCount'),
('MaxCount','<L'),
)
class SRVSVCNetrShareEnum1_answer(Structure):
alignment = 4
structure = (
('pLevel','<L=1'),
('Info',':',SRVSVCShareEnumStruct),
# Not catched by the unpacker - just for doc purposed.
# ('pTotalEntries','<L=&TotalEntries'),
# ('TotalEntries','<L'),
# ('pResumeHandler','<L=&ResumeHandler'),
# ('ResumeHandler','<L'),
)
class SRVSVCServer(DCERPCServer):
def __init__(self):
DCERPCServer.__init__(self)
self._shares = {}
self.srvsvcCallBacks = {
15: self.NetShareEnumAll,
16: self.NetrGetShareInfo,
21: self.NetrServerGetInfo,
}
self.addCallbacks(('4B324FC8-1670-01D3-1278-5A47BF6EE188', '3.0'), self.srvsvcCallBacks)
def processConfigFile(self, configFile):
serverConfig = ConfigParser.ConfigParser()
serverConfig.read(configFile)
sections = serverConfig.sections()
# Remove the global one
del(sections[sections.index('global')])
for i in sections:
self._shares[i] = dict(serverConfig.items(i))
def NetrGetShareInfo(self,data):
request = SRVSVCShareGetInfo(data)
print "NetrGetShareInfo Level: %d" % request['Level']
s = request['NetName'].decode('utf-16le')[:-1].upper().strip()
share = self._shares[s]
answer = SRVSVCSwitchpShareInfo2()
answer['Level'] = 1
answer['InfoStruct'] = SRVSVCShareInfo1()
answer['InfoStruct']['pNetName'] = id(share) & 0xffffffff
answer['InfoStruct']['Type'] = int(share['share type'])
answer['InfoStruct']['pRemark'] = (id(share) & 0xffffffff) + 1
answer = str(answer)
netName = srvsvc.NDRString()
remark = srvsvc.NDRString()
netName['sName'] = request['NetName']
remark['sName'] = (share['comment']+'\x00').encode('utf-16le')
answer += str(netName) + str(remark)
answer += struct.pack('<L',0)
return answer
def NetrServerGetInfo(self,data):
request = SRVSVCServerGetInfo(data)
print "NetrServerGetInfo Level: %d" % request['Level']
answer = SRVSVCServerpInfo101()
answer['ServerInfo'] = SRVSVCServerInfo101()
answer['ServerInfo']['Name'] = request['ServerName']
answer['ServerInfo']['Comment'] = '\x00\x00'
answer = str(answer) + '\x00'*4
return answer
def NetShareEnumAll(self, data):
request = SRVSVCNetrShareEnum(data)
print "NetrShareEnumAll Level: %d" % request['Level']
shareEnum = SRVSVCNetrShareEnum1_answer()
shareEnum['Info'] = SRVSVCShareEnumStruct()
shareEnum['Info']['Level'] = 1
shareEnum['Info']['Count'] = len(self._shares)
shareEnum['Info']['MaxCount'] = len(self._shares)
answer = str(shareEnum)
for i in self._shares:
shareInfo = SRVSVCShareInfo1()
shareInfo['pNetName'] = id(i) & 0xffffffff
shareInfo['Type'] = int(self._shares[i]['share type'])
shareInfo['pRemark'] = (id(i) & 0xffffffff)+1
answer += str(shareInfo)
for i in self._shares:
netName = srvsvc.NDRString()
remark = srvsvc.NDRString()
netName['sName'] = (i+'\x00').encode('utf-16le')
remark['sName'] = (self._shares[i]['comment']+'\x00').encode('utf-16le')
answer += str(netName) + str(remark)
# and the answer
answer += struct.pack('<LLL',len(self._shares),0,0)
return answer
| [
"[email protected]"
] | |
1121516406cec1116b90ef7fc536a6cd5afdd7c4 | e4e4c60ffa509f257afc915d4c6cd32c0cb7098c | /.history/app_20200919192647.py | b152935c7de29fa5e6e7fe1e9d5d974fae893d03 | [] | no_license | QianyueMa/Google-Health-Search-Project | 01dbd597780158f50eebfba2a228b505f8169726 | 6ef6b270dc7ab0826ad4f0338c9cd95d3571e19a | refs/heads/master | 2022-12-19T03:55:10.328167 | 2020-10-02T12:54:27 | 2020-10-02T12:54:27 | 296,495,736 | 0 | 0 | null | 2020-09-18T02:44:12 | 2020-09-18T02:44:11 | null | UTF-8 | Python | false | false | 4,557 | py | import numpy as np
import os
import json
import requests
import sqlalchemy
from sqlalchemy.ext.automap import automap_base
from sqlalchemy.orm import Session
from sqlalchemy import create_engine
import pandas.io.sql as pdsql
from config import pg_user, pg_password, db_name
from flask import Flask, jsonify, render_template, abort, redirect
#################################################
# Database Setup
##################################################
connection_string = f"{pg_user}:{pg_password}@localhost:5432/{db_name}"
engine = create_engine(f'postgresql://{connection_string}')
# checking the table names
engine.table_names()
#################################################
# Flask Setup
#################################################
app = Flask(__name__)
#################################################
# Flask Routes
#################################################
@app.route("/")
def home():
return render_template("index.html")
@app.route("/comparison")
def comparison():
return render_template("comparison.html")
@app.route('/searchbyyear')
def searchbyyear():
sqlStatement = """
SELECT year, SUM ("Cancer" + "cardiovascular" + "stroke" + "depression" + "rehab" + "vaccine" + "diarrhea" + "obesity" + "diabetes") AS Searches
FROM search_condition
GROUP BY year
ORDER BY year;
"""
df = pdsql.read_sql(sqlStatement, engine)
df.set_index('year', inplace=True)
df = df.to_json(orient='table')
result = json.loads(df)
return jsonify(result)
@app.route('/searchyearandcondition')
def searchyearandcondition():
sqlStatement = """
SELECT year, SUM ("Cancer") AS Cancer,SUM ("cardiovascular") As Cardiovascular,SUM ("stroke") As Stroke,SUM ("depression") As Depression,SUM ("rehab") AS Rehab,SUM ("vaccine") AS Vaccine, SUM ("diarrhea") AS Diarrhea, SUM("obesity") AS Obesity, SUM ("diabetes") AS Diabetes
FROM search_condition
GROUP BY year
ORDER BY year;
"""
df = pdsql.read_sql(sqlStatement, engine)
df.set_index('year', inplace=True)
df = df.to_json(orient='table')
result = json.loads(df)
return jsonify(result)
@app.route('/searchbystate')
def searchbystate():
sqlStatement = """
SELECT l.location, l.latitude, l.longitude, SUM (s."Cancer" + s."cardiovascular" + s."stroke" + s."depression" + s."rehab" + s."vaccine" + s."diarrhea" + s."obesity" + s."diabetes") AS Searches
FROM location l
INNER JOIN search_condition s on s.location_id = l.location_id
GROUP BY l.location, l.latitude, l.longitude
ORDER BY location;
"""
df = pdsql.read_sql(sqlStatement, engine)
df.set_index('location', inplace=True)
df = df.to_json(orient='table')
result = json.loads(df)
return jsonify(result)
@app.route('/bylocationandyear')
def bylocationandyear():
sqlStatement = """
SELECT l.location, l.latitude, l.longitude,s.year, SUM (s."Cancer" + s."cardiovascular" + s."stroke" + s."depression" + s."rehab" + s."vaccine" + s."diarrhea" + s."obesity" + s."diabetes") AS Searches
FROM location l
INNER JOIN search_condition s on s.location_id = l.location_id
GROUP BY l.location, l.latitude, l.longitude,s.year
ORDER BY year;
"""
df = pdsql.read_sql(sqlStatement, engine)
df.set_index('year', inplace=True)
df = df.to_json(orient='table')
result = json.loads(df)
return jsonify(result)
@app.route('/casesleadingdeath')
def casesleadingdeath():
sqlStatement = """
SELECT * FROM leading_causes_of_death;
"""
df = pdsql.read_sql(sqlStatement, engine)
df.set_index('year', inplace=True)
df = df.to_json(orient='table')
result = json.loads(df)
return jsonify(result)
@app.route('/allsearchrecord')
def allsearchrecord():
sqlStatement = """
SELECT *
FROM location l
INNER JOIN search_condition s on s.location_id = l.location_id
ORDER BY year;
"""
df = pdsql.read_sql(sqlStatement, engine)
df.set_index('year', inplace=True)
df = df.to_json(orient='table')
result = json.loads(df)
return jsonify(result)
@app.route('/location')
def location():
sqlStatement = """
SELECT * FROM location;
"""
df = pdsql.read_sql(sqlStatement, engine)
df.set_index('location', inplace=True)
df = df.to_json(orient='table')
result = json.loads(df)
return jsonify(result)
if __name__ == '__main__':
app.run(debug=True)
| [
"[email protected]"
] | |
aa6ee40b7126092195646dfd0576d6b0b5268e5e | 40392ca261eccaa02029f346eb95d518a6e11dbf | /tests/components/remote/test_device_trigger.py | dea93b4f20ccba08ba957bc99c75db7b466373e2 | [
"Apache-2.0"
] | permissive | sh00t2kill/home-assistant | d18ab78414e79aced57bc76b63ec1c9b338ab53c | 80bf632e2d713add17ab00a72510039de7d9bc78 | refs/heads/dev | 2023-02-20T22:05:30.496454 | 2023-02-09T01:15:29 | 2023-02-09T01:15:29 | 231,849,824 | 0 | 0 | Apache-2.0 | 2023-02-09T05:40:45 | 2020-01-05T00:57:52 | null | UTF-8 | Python | false | false | 10,890 | py | """The test for remote device automation."""
from datetime import timedelta
import pytest
import homeassistant.components.automation as automation
from homeassistant.components.device_automation import DeviceAutomationType
from homeassistant.components.remote import DOMAIN
from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON
from homeassistant.helpers import device_registry as dr
from homeassistant.helpers.entity import EntityCategory
from homeassistant.helpers.entity_registry import RegistryEntryHider
from homeassistant.setup import async_setup_component
import homeassistant.util.dt as dt_util
from tests.common import (
MockConfigEntry,
assert_lists_same,
async_fire_time_changed,
async_get_device_automation_capabilities,
async_get_device_automations,
async_mock_service,
)
from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401
@pytest.fixture
def calls(hass):
"""Track calls to a mock service."""
return async_mock_service(hass, "test", "automation")
async def test_get_triggers(hass, device_registry, entity_registry):
"""Test we get the expected triggers from a remote."""
config_entry = MockConfigEntry(domain="test", data={})
config_entry.add_to_hass(hass)
device_entry = device_registry.async_get_or_create(
config_entry_id=config_entry.entry_id,
connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
)
entity_registry.async_get_or_create(
DOMAIN, "test", "5678", device_id=device_entry.id
)
expected_triggers = [
{
"platform": "device",
"domain": DOMAIN,
"type": trigger,
"device_id": device_entry.id,
"entity_id": f"{DOMAIN}.test_5678",
"metadata": {"secondary": False},
}
for trigger in ["changed_states", "turned_off", "turned_on"]
]
triggers = await async_get_device_automations(
hass, DeviceAutomationType.TRIGGER, device_entry.id
)
assert_lists_same(triggers, expected_triggers)
@pytest.mark.parametrize(
"hidden_by,entity_category",
(
(RegistryEntryHider.INTEGRATION, None),
(RegistryEntryHider.USER, None),
(None, EntityCategory.CONFIG),
(None, EntityCategory.DIAGNOSTIC),
),
)
async def test_get_triggers_hidden_auxiliary(
hass,
device_registry,
entity_registry,
hidden_by,
entity_category,
):
"""Test we get the expected triggers from a hidden or auxiliary entity."""
config_entry = MockConfigEntry(domain="test", data={})
config_entry.add_to_hass(hass)
device_entry = device_registry.async_get_or_create(
config_entry_id=config_entry.entry_id,
connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
)
entity_registry.async_get_or_create(
DOMAIN,
"test",
"5678",
device_id=device_entry.id,
entity_category=entity_category,
hidden_by=hidden_by,
)
expected_triggers = [
{
"platform": "device",
"domain": DOMAIN,
"type": trigger,
"device_id": device_entry.id,
"entity_id": f"{DOMAIN}.test_5678",
"metadata": {"secondary": True},
}
for trigger in ["changed_states", "turned_off", "turned_on"]
]
triggers = await async_get_device_automations(
hass, DeviceAutomationType.TRIGGER, device_entry.id
)
assert_lists_same(triggers, expected_triggers)
async def test_get_trigger_capabilities(hass, device_registry, entity_registry):
"""Test we get the expected capabilities from a remote trigger."""
config_entry = MockConfigEntry(domain="test", data={})
config_entry.add_to_hass(hass)
device_entry = device_registry.async_get_or_create(
config_entry_id=config_entry.entry_id,
connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
)
entity_registry.async_get_or_create(
DOMAIN, "test", "5678", device_id=device_entry.id
)
expected_capabilities = {
"extra_fields": [
{"name": "for", "optional": True, "type": "positive_time_period_dict"}
]
}
triggers = await async_get_device_automations(
hass, DeviceAutomationType.TRIGGER, device_entry.id
)
for trigger in triggers:
capabilities = await async_get_device_automation_capabilities(
hass, DeviceAutomationType.TRIGGER, trigger
)
assert capabilities == expected_capabilities
async def test_if_fires_on_state_change(hass, calls, enable_custom_integrations):
"""Test for turn_on and turn_off triggers firing."""
platform = getattr(hass.components, f"test.{DOMAIN}")
platform.init()
assert await async_setup_component(hass, DOMAIN, {DOMAIN: {CONF_PLATFORM: "test"}})
await hass.async_block_till_done()
ent1, ent2, ent3 = platform.ENTITIES
assert await async_setup_component(
hass,
automation.DOMAIN,
{
automation.DOMAIN: [
{
"trigger": {
"platform": "device",
"domain": DOMAIN,
"device_id": "",
"entity_id": ent1.entity_id,
"type": "turned_on",
},
"action": {
"service": "test.automation",
"data_template": {
"some": "turn_on {{ trigger.%s }}"
% "}} - {{ trigger.".join(
(
"platform",
"entity_id",
"from_state.state",
"to_state.state",
"for",
)
)
},
},
},
{
"trigger": {
"platform": "device",
"domain": DOMAIN,
"device_id": "",
"entity_id": ent1.entity_id,
"type": "turned_off",
},
"action": {
"service": "test.automation",
"data_template": {
"some": "turn_off {{ trigger.%s }}"
% "}} - {{ trigger.".join(
(
"platform",
"entity_id",
"from_state.state",
"to_state.state",
"for",
)
)
},
},
},
{
"trigger": {
"platform": "device",
"domain": DOMAIN,
"device_id": "",
"entity_id": ent1.entity_id,
"type": "changed_states",
},
"action": {
"service": "test.automation",
"data_template": {
"some": "turn_on_or_off {{ trigger.%s }}"
% "}} - {{ trigger.".join(
(
"platform",
"entity_id",
"from_state.state",
"to_state.state",
"for",
)
)
},
},
},
]
},
)
await hass.async_block_till_done()
assert hass.states.get(ent1.entity_id).state == STATE_ON
assert len(calls) == 0
hass.states.async_set(ent1.entity_id, STATE_OFF)
await hass.async_block_till_done()
assert len(calls) == 2
assert {calls[0].data["some"], calls[1].data["some"]} == {
f"turn_off device - {ent1.entity_id} - on - off - None",
f"turn_on_or_off device - {ent1.entity_id} - on - off - None",
}
hass.states.async_set(ent1.entity_id, STATE_ON)
await hass.async_block_till_done()
assert len(calls) == 4
assert {calls[2].data["some"], calls[3].data["some"]} == {
f"turn_on device - {ent1.entity_id} - off - on - None",
f"turn_on_or_off device - {ent1.entity_id} - off - on - None",
}
async def test_if_fires_on_state_change_with_for(
hass, calls, enable_custom_integrations
):
"""Test for triggers firing with delay."""
platform = getattr(hass.components, f"test.{DOMAIN}")
platform.init()
assert await async_setup_component(hass, DOMAIN, {DOMAIN: {CONF_PLATFORM: "test"}})
await hass.async_block_till_done()
ent1, ent2, ent3 = platform.ENTITIES
assert await async_setup_component(
hass,
automation.DOMAIN,
{
automation.DOMAIN: [
{
"trigger": {
"platform": "device",
"domain": DOMAIN,
"device_id": "",
"entity_id": ent1.entity_id,
"type": "turned_off",
"for": {"seconds": 5},
},
"action": {
"service": "test.automation",
"data_template": {
"some": "turn_off {{ trigger.%s }}"
% "}} - {{ trigger.".join(
(
"platform",
"entity_id",
"from_state.state",
"to_state.state",
"for",
)
)
},
},
}
]
},
)
await hass.async_block_till_done()
assert hass.states.get(ent1.entity_id).state == STATE_ON
assert len(calls) == 0
hass.states.async_set(ent1.entity_id, STATE_OFF)
await hass.async_block_till_done()
assert len(calls) == 0
async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=10))
await hass.async_block_till_done()
assert len(calls) == 1
await hass.async_block_till_done()
assert calls[0].data["some"] == "turn_off device - {} - on - off - 0:00:05".format(
ent1.entity_id
)
| [
"[email protected]"
] | |
ffab33f48afaa21acceac9a221d3a938167e30a7 | 1e3cf9c1341083675fa9b716f11c2834e2d18374 | /src/pyphoplacecellanalysis/GUI/Qt/Widgets/FigureFormatConfigControls/Uic_AUTOGEN_FigureFormatConfigControls.py | 1471ab3498cd9a74783e9e909c6996ce59f70161 | [
"MIT"
] | permissive | CommanderPho/pyPhoPlaceCellAnalysis | a60313c98b3ad2834c2bf101f3463714df092cf5 | 212399d826284b394fce8894ff1a93133aef783f | refs/heads/master | 2023-09-01T20:27:43.792099 | 2023-09-01T03:24:19 | 2023-09-01T03:24:19 | 444,885,155 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 12,253 | py | # -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'c:\Users\pho\repos\pyPhoPlaceCellAnalysis\src\pyphoplacecellanalysis\GUI\Qt\Widgets\FigureFormatConfigControls\FigureFormatConfigControls.ui'
#
# Created by: PyQt5 UI code generator 5.15.4
#
# WARNING: Any manual changes made to this file will be lost when pyuic5 is
# run again. Do not edit this file unless you know what you are doing.
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_Form(object):
def setupUi(self, Form):
Form.setObjectName("Form")
Form.resize(448, 753)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(":/light/file_dialog_detailed.svg"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
Form.setWindowIcon(icon)
self.verticalLayout = QtWidgets.QVBoxLayout(Form)
self.verticalLayout.setObjectName("verticalLayout")
self.tupleCtrl_0 = SingleGroupOptionalMembersCtrl(Form)
self.tupleCtrl_0.setObjectName("tupleCtrl_0")
self.verticalLayout.addWidget(self.tupleCtrl_0)
self.tupleCtrl_1 = SingleGroupOptionalMembersCtrl(Form)
self.tupleCtrl_1.setObjectName("tupleCtrl_1")
self.verticalLayout.addWidget(self.tupleCtrl_1)
self.tupleCtrl_2 = SingleGroupOptionalMembersCtrl(Form)
self.tupleCtrl_2.setObjectName("tupleCtrl_2")
self.verticalLayout.addWidget(self.tupleCtrl_2)
self.line = QtWidgets.QFrame(Form)
self.line.setFrameShape(QtWidgets.QFrame.HLine)
self.line.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line.setObjectName("line")
self.verticalLayout.addWidget(self.line)
self.horizontalFrame_2 = QtWidgets.QFrame(Form)
self.horizontalFrame_2.setObjectName("horizontalFrame_2")
self.horizontalLayout_3 = QtWidgets.QHBoxLayout(self.horizontalFrame_2)
self.horizontalLayout_3.setObjectName("horizontalLayout_3")
self.horizontalWidget = QtWidgets.QWidget(self.horizontalFrame_2)
self.horizontalWidget.setObjectName("horizontalWidget")
self.verticalLayout_2 = QtWidgets.QVBoxLayout(self.horizontalWidget)
self.verticalLayout_2.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_2.setSpacing(2)
self.verticalLayout_2.setObjectName("verticalLayout_2")
self.chkEnableSpikeOverlay = QtWidgets.QCheckBox(self.horizontalWidget)
self.chkEnableSpikeOverlay.setObjectName("chkEnableSpikeOverlay")
self.verticalLayout_2.addWidget(self.chkEnableSpikeOverlay)
self.chkDebugPrint = QtWidgets.QCheckBox(self.horizontalWidget)
self.chkDebugPrint.setObjectName("chkDebugPrint")
self.verticalLayout_2.addWidget(self.chkDebugPrint)
self.chkEnableSavingToDisk = QtWidgets.QCheckBox(self.horizontalWidget)
self.chkEnableSavingToDisk.setChecked(True)
self.chkEnableSavingToDisk.setObjectName("chkEnableSavingToDisk")
self.verticalLayout_2.addWidget(self.chkEnableSavingToDisk)
self.horizontalLayout_3.addWidget(self.horizontalWidget, 0, QtCore.Qt.AlignTop)
self.frame = QtWidgets.QFrame(self.horizontalFrame_2)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.frame.sizePolicy().hasHeightForWidth())
self.frame.setSizePolicy(sizePolicy)
self.frame.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.frame.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame.setObjectName("frame")
self.gridLayout_2 = QtWidgets.QGridLayout(self.frame)
self.gridLayout_2.setObjectName("gridLayout_2")
self.scrollArea = QtWidgets.QScrollArea(self.frame)
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setObjectName("scrollArea")
self.scrollAreaWidgetContents = QtWidgets.QWidget()
self.scrollAreaWidgetContents.setGeometry(QtCore.QRect(0, 0, 248, 210))
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.scrollAreaWidgetContents.sizePolicy().hasHeightForWidth())
self.scrollAreaWidgetContents.setSizePolicy(sizePolicy)
self.scrollAreaWidgetContents.setObjectName("scrollAreaWidgetContents")
self.gridLayout_3 = QtWidgets.QGridLayout(self.scrollAreaWidgetContents)
self.gridLayout_3.setObjectName("gridLayout_3")
self.txtEditExtraArguments = PyCodeEdit(self.scrollAreaWidgetContents)
self.txtEditExtraArguments.setObjectName("txtEditExtraArguments")
self.gridLayout_3.addWidget(self.txtEditExtraArguments, 0, 0, 1, 1)
self.scrollArea.setWidget(self.scrollAreaWidgetContents)
self.gridLayout_2.addWidget(self.scrollArea, 1, 0, 1, 1)
self.horizontalLayout_3.addWidget(self.frame)
self.verticalLayout.addWidget(self.horizontalFrame_2)
spacerItem = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.verticalLayout.addItem(spacerItem)
self.toolBox = QtWidgets.QToolBox(Form)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(1)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.toolBox.sizePolicy().hasHeightForWidth())
self.toolBox.setSizePolicy(sizePolicy)
self.toolBox.setBaseSize(QtCore.QSize(400, 200))
self.toolBox.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.toolBox.setFrameShadow(QtWidgets.QFrame.Sunken)
self.toolBox.setLineWidth(2)
self.toolBox.setMidLineWidth(1)
self.toolBox.setObjectName("toolBox")
self.page_figExport = QtWidgets.QWidget()
self.page_figExport.setGeometry(QtCore.QRect(0, 0, 428, 126))
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(1)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.page_figExport.sizePolicy().hasHeightForWidth())
self.page_figExport.setSizePolicy(sizePolicy)
self.page_figExport.setObjectName("page_figExport")
self.horizontalLayout = QtWidgets.QHBoxLayout(self.page_figExport)
self.horizontalLayout.setContentsMargins(4, 0, 4, 0)
self.horizontalLayout.setObjectName("horizontalLayout")
self.verticalLayout_3 = QtWidgets.QVBoxLayout()
self.verticalLayout_3.setObjectName("verticalLayout_3")
self.filepkr_FigureOutputPath = InlineFilesystemPathSelectWidget(self.page_figExport)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(1)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.filepkr_FigureOutputPath.sizePolicy().hasHeightForWidth())
self.filepkr_FigureOutputPath.setSizePolicy(sizePolicy)
self.filepkr_FigureOutputPath.setObjectName("filepkr_FigureOutputPath")
self.verticalLayout_3.addWidget(self.filepkr_FigureOutputPath)
self.filepkr_ProgrammaticDisplayFcnOutputPath = InlineFilesystemPathSelectWidget(self.page_figExport)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(1)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.filepkr_ProgrammaticDisplayFcnOutputPath.sizePolicy().hasHeightForWidth())
self.filepkr_ProgrammaticDisplayFcnOutputPath.setSizePolicy(sizePolicy)
self.filepkr_ProgrammaticDisplayFcnOutputPath.setObjectName("filepkr_ProgrammaticDisplayFcnOutputPath")
self.verticalLayout_3.addWidget(self.filepkr_ProgrammaticDisplayFcnOutputPath)
self.horizontalLayout.addLayout(self.verticalLayout_3)
icon1 = QtGui.QIcon()
icon1.addPixmap(QtGui.QPixmap(":/light/desktop.svg"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.toolBox.addItem(self.page_figExport, icon1, "")
self.page_debugging = QtWidgets.QWidget()
self.page_debugging.setGeometry(QtCore.QRect(0, 0, 100, 130))
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(1)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.page_debugging.sizePolicy().hasHeightForWidth())
self.page_debugging.setSizePolicy(sizePolicy)
self.page_debugging.setObjectName("page_debugging")
self.horizontalLayout_2 = QtWidgets.QHBoxLayout(self.page_debugging)
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
self.gridLayout = QtWidgets.QGridLayout()
self.gridLayout.setObjectName("gridLayout")
self.textBrowser = QtWidgets.QTextBrowser(self.page_debugging)
self.textBrowser.setObjectName("textBrowser")
self.gridLayout.addWidget(self.textBrowser, 1, 0, 1, 1)
self.pushButton_2 = QtWidgets.QPushButton(self.page_debugging)
self.pushButton_2.setObjectName("pushButton_2")
self.gridLayout.addWidget(self.pushButton_2, 2, 0, 1, 1)
self.lineEdit = FilesystemPathLineEdit(self.page_debugging)
self.lineEdit.setClearButtonEnabled(True)
self.lineEdit.setObjectName("lineEdit")
self.gridLayout.addWidget(self.lineEdit, 0, 0, 1, 1)
self.horizontalLayout_2.addLayout(self.gridLayout)
icon2 = QtGui.QIcon()
icon2.addPixmap(QtGui.QPixmap(":/light/file_dialog_list.svg"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.toolBox.addItem(self.page_debugging, icon2, "")
self.verticalLayout.addWidget(self.toolBox)
self.line_2 = QtWidgets.QFrame(Form)
self.line_2.setFrameShape(QtWidgets.QFrame.HLine)
self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line_2.setObjectName("line_2")
self.verticalLayout.addWidget(self.line_2)
self.buttonBox = QtWidgets.QDialogButtonBox(Form)
self.buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Apply|QtWidgets.QDialogButtonBox.Cancel|QtWidgets.QDialogButtonBox.RestoreDefaults)
self.buttonBox.setObjectName("buttonBox")
self.verticalLayout.addWidget(self.buttonBox)
self.retranslateUi(Form)
self.toolBox.setCurrentIndex(0)
QtCore.QMetaObject.connectSlotsByName(Form)
def retranslateUi(self, Form):
_translate = QtCore.QCoreApplication.translate
Form.setWindowTitle(_translate("Form", "Figure Format Configuration"))
self.chkEnableSpikeOverlay.setText(_translate("Form", "enable_spike_overlay"))
self.chkDebugPrint.setText(_translate("Form", "debug_print"))
self.chkEnableSavingToDisk.setText(_translate("Form", "enable_saving_to_disk"))
self.txtEditExtraArguments.setToolTip(_translate("Form", "Extra Arguments"))
self.txtEditExtraArguments.setStatusTip(_translate("Form", "Extra Arguments"))
self.toolBox.setItemText(self.toolBox.indexOf(self.page_figExport), _translate("Form", "Figure Output/Export"))
self.pushButton_2.setText(_translate("Form", "PushButton"))
self.lineEdit.setText(_translate("Form", "C:\\Users\\pho\\repos\\PhoPy3DPositionAnalysis2021\\EXTERNAL\\Screenshots\\ProgrammaticDisplayFunctionTesting"))
self.toolBox.setItemText(self.toolBox.indexOf(self.page_debugging), _translate("Form", "Extra/Debugging"))
from pyphocorehelpers.gui.Qt.InlineFilesystemPathSelectWidget.FilesystemPathLineEdit import FilesystemPathLineEdit
from pyphocorehelpers.gui.Qt.InlineFilesystemPathSelectWidget.InlineFilesystemPathSelectWidget import InlineFilesystemPathSelectWidget
from pyphoplacecellanalysis.GUI.Qt.Widgets.SingleGroupOptionalMembersCtrl.SingleGroupOptionalMembersCtrl import SingleGroupOptionalMembersCtrl
from pyqode.python.widgets.code_edit import PyCodeEdit
from pyphoplacecellanalysis.Resources import breeze
| [
"[email protected]"
] | |
6bf5d212d3f9e78a66b872cca4a156a02e57ff90 | 2f98aa7e5bfc2fc5ef25e4d5cfa1d7802e3a7fae | /python/python_28126.py | df691b0e9135089fcfe0a9d13739e85615964559 | [] | no_license | AK-1121/code_extraction | cc812b6832b112e3ffcc2bb7eb4237fd85c88c01 | 5297a4a3aab3bb37efa24a89636935da04a1f8b6 | refs/heads/master | 2020-05-23T08:04:11.789141 | 2015-10-22T19:19:40 | 2015-10-22T19:19:40 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 118 | py | # How to capture only part of regex
>>> re.search(r';Video=([A-Z]{2})', 'nt;Video=SD-H.264;D').group(1)
'SD'
| [
"[email protected]"
] | |
6878a567d42d9e1757938e0bb0df53b84b7c730a | 65b9a63e8c132f32aeb56961968f5e363bd9a087 | /20191104_归一化层Normalization/layernorm_keras.py | a605fbdc0613d5284fffcc85ef6fd7daea5d15e2 | [] | no_license | 346644054/examples2019 | e70f13cfb56c3478fc6e335c730e0e70e70a6226 | 5f9777e7a887e635971156354f56ce065fa3f41e | refs/heads/master | 2022-04-09T03:52:52.973414 | 2020-02-28T03:05:02 | 2020-02-28T03:05:02 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 598 | py | # -*- coding: utf-8 -*-
from __future__ import print_function
"""
haikou layernorm
fun:
save csv
env:
Win7 64bit;anaconda 1.7.2;python 3.5;tensorflow1.10.1;Keras2.2.4
pip3,matplotlib2.2.3,seaborn0.9.0
"""
__author__ = 'elesun'
import keras
from keras_layer_normalization import LayerNormalization
print("test layer_norm")
input_layer = keras.layers.Input(shape=(2, 3),name="in")
norm_layer = LayerNormalization(name="norm")(input_layer)
model = keras.models.Model(inputs=input_layer, outputs=norm_layer)
model.compile(optimizer='adam', loss='mse', metrics={})
model.summary() | [
"[email protected]"
] | |
c27b9621db997cd404dc63ed5f55c13eb70acff6 | a462a24ff937e151e8151f3a1bdc9c3714b12c0e | /predictTime_8_341.py | a121fab73e52627b40d1d129c3dd16e4a194d2ce | [] | no_license | noeliarico/kemeny | b4cbcac57203237769252de2c50ce959aa4ca50e | 50819f8bf0d19fb29a0b5c6d2ee031e8a811497d | refs/heads/main | 2023-03-29T14:36:37.931286 | 2023-03-16T09:04:12 | 2023-03-16T09:04:12 | 330,797,494 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,620,512 | py |
import numpy as np
import pandas as pd
import time
import kemeny.azzinimunda.azzinimunda3 as am3
rep = 3
results = np.zeros(0).reshape(0,7+rep)
##############################################################
om = np.array([
[0,176,176,158,187,160,191,181],
[165,0,170,143,185,137,171,176],
[165,171,0,171,210,180,190,179],
[183,198,170,0,220,187,207,200],
[154,156,131,121,0,143,168,163],
[181,204,161,154,198,0,198,185],
[150,170,151,134,173,143,0,172],
[160,165,162,141,178,156,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,143,173,161,170,174,179,156],
[198,0,182,188,179,170,192,189],
[168,159,0,167,155,162,174,161],
[180,153,174,0,172,173,183,170],
[171,162,186,169,0,171,183,155],
[167,171,179,168,170,0,176,171],
[162,149,167,158,158,165,0,162],
[185,152,180,171,186,170,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 2, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,170,166,179,161,171,166],
[175,0,178,178,167,167,175,172],
[171,163,0,172,166,147,166,164],
[175,163,169,0,160,166,165,166],
[162,174,175,181,0,171,173,176],
[180,174,194,175,170,0,181,176],
[170,166,175,176,168,160,0,170],
[175,169,177,175,165,165,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 3, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,160,167,164,171,170,176],
[165,0,176,165,162,162,170,179],
[181,165,0,178,171,170,164,169],
[174,176,163,0,177,184,165,162],
[177,179,170,164,0,170,173,159],
[170,179,171,157,171,0,170,180],
[171,171,177,176,168,171,0,176],
[165,162,172,179,182,161,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 4, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,186,162,178,171,161,163],
[169,0,191,170,179,179,180,177],
[155,150,0,153,175,162,167,152],
[179,171,188,0,168,183,189,161],
[163,162,166,173,0,171,157,170],
[170,162,179,158,170,0,154,159],
[180,161,174,152,184,187,0,179],
[178,164,189,180,171,182,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 5, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,181,184,168,197,177,184],
[153,0,168,154,160,160,157,167],
[160,173,0,162,177,166,151,189],
[157,187,179,0,177,177,181,185],
[173,181,164,164,0,167,161,166],
[144,181,175,164,174,0,148,175],
[164,184,190,160,180,193,0,183],
[157,174,152,156,175,166,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 6, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,188,184,187,176,159,161],
[159,0,164,152,176,158,167,156],
[153,177,0,161,172,166,165,147],
[157,189,180,0,170,170,161,161],
[154,165,169,171,0,167,164,150],
[165,183,175,171,174,0,170,171],
[182,174,176,180,177,171,0,164],
[180,185,194,180,191,170,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 7, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,169,171,179,171,164,184],
[184,0,179,174,187,188,170,190],
[172,162,0,162,165,165,159,169],
[170,167,179,0,163,176,182,190],
[162,154,176,178,0,174,180,181],
[170,153,176,165,167,0,165,181],
[177,171,182,159,161,176,0,191],
[157,151,172,151,160,160,150,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 8, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,206,196,170,196,195,187,189],
[135,0,161,130,157,142,147,157],
[145,180,0,168,168,171,167,162],
[171,211,173,0,186,169,195,176],
[145,184,173,155,0,155,158,183],
[146,199,170,172,186,0,178,183],
[154,194,174,146,183,163,0,177],
[152,184,179,165,158,158,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 9, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,182,162,180,191,182,188],
[177,0,198,174,194,178,169,197],
[159,143,0,138,173,167,162,168],
[179,167,203,0,190,194,183,182],
[161,147,168,151,0,173,165,175],
[150,163,174,147,168,0,162,168],
[159,172,179,158,176,179,0,182],
[153,144,173,159,166,173,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 10, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,193,198,169,172,123,156],
[170,0,200,199,210,201,156,184],
[148,141,0,193,165,132,141,159],
[143,142,148,0,193,145,142,157],
[172,131,176,148,0,178,150,127],
[169,140,209,196,163,0,149,145],
[218,185,200,199,191,192,0,169],
[185,157,182,184,214,196,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 11, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,170,158,168,169,165,160],
[178,0,178,178,186,167,181,168],
[171,163,0,175,174,170,169,162],
[183,163,166,0,162,162,178,177],
[173,155,167,179,0,162,184,168],
[172,174,171,179,179,0,175,168],
[176,160,172,163,157,166,0,155],
[181,173,179,164,173,173,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 12, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,163,162,177,175,166,168],
[166,0,169,162,182,167,173,167],
[178,172,0,171,173,182,175,170],
[179,179,170,0,175,184,186,171],
[164,159,168,166,0,169,162,166],
[166,174,159,157,172,0,171,160],
[175,168,166,155,179,170,0,162],
[173,174,171,170,175,181,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 13, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,167,159,153,139,160,155],
[168,0,170,164,164,166,183,182],
[174,171,0,170,171,167,179,186],
[182,177,171,0,171,174,165,187],
[188,177,170,170,0,185,192,181],
[202,175,174,167,156,0,168,170],
[181,158,162,176,149,173,0,175],
[186,159,155,154,160,171,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 14, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,176,195,162,182,209,175],
[161,0,178,179,179,193,207,177],
[165,163,0,155,187,188,201,175],
[146,162,186,0,163,165,201,156],
[179,162,154,178,0,178,182,150],
[159,148,153,176,163,0,172,156],
[132,134,140,140,159,169,0,139],
[166,164,166,185,191,185,202,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 15, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,162,171,158,134,162,154],
[180,0,173,177,164,170,179,165],
[179,168,0,165,150,151,162,176],
[170,164,176,0,160,142,182,164],
[183,177,191,181,0,183,176,169],
[207,171,190,199,158,0,188,183],
[179,162,179,159,165,153,0,169],
[187,176,165,177,172,158,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 16, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,167,169,179,171,191,187],
[167,0,177,175,162,157,179,182],
[174,164,0,160,178,159,176,172],
[172,166,181,0,171,171,181,174],
[162,179,163,170,0,163,188,186],
[170,184,182,170,178,0,188,184],
[150,162,165,160,153,153,0,161],
[154,159,169,167,155,157,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 17, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,170,183,185,182,160,191],
[167,0,148,145,144,158,158,161],
[171,193,0,183,172,167,172,175],
[158,196,158,0,173,170,162,171],
[156,197,169,168,0,167,150,181],
[159,183,174,171,174,0,163,179],
[181,183,169,179,191,178,0,184],
[150,180,166,170,160,162,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 18, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,185,181,205,202,168,161],
[177,0,195,170,183,196,174,175],
[156,146,0,195,169,170,151,148],
[160,171,146,0,182,189,128,163],
[136,158,172,159,0,165,139,128],
[139,145,171,152,176,0,132,160],
[173,167,190,213,202,209,0,209],
[180,166,193,178,213,181,132,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 19, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,178,180,185,167,194,161],
[166,0,156,169,174,165,186,175],
[163,185,0,169,176,180,179,161],
[161,172,172,0,178,166,168,160],
[156,167,165,163,0,178,177,169],
[174,176,161,175,163,0,176,168],
[147,155,162,173,164,165,0,151],
[180,166,180,181,172,173,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 20, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,192,190,189,172,162,194],
[174,0,154,135,198,144,178,195],
[149,187,0,193,192,171,178,184],
[151,206,148,0,185,181,155,176],
[152,143,149,156,0,166,132,162],
[169,197,170,160,175,0,167,199],
[179,163,163,186,209,174,0,178],
[147,146,157,165,179,142,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 21, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,195,166,180,204,158,187],
[150,0,136,147,151,174,168,173],
[146,205,0,176,181,187,187,183],
[175,194,165,0,149,181,169,180],
[161,190,160,192,0,193,181,155],
[137,167,154,160,148,0,159,174],
[183,173,154,172,160,182,0,156],
[154,168,158,161,186,167,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 22, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,176,171,163,167,176,183],
[168,0,173,167,164,172,177,182],
[165,168,0,168,170,173,171,188],
[170,174,173,0,161,170,165,166],
[178,177,171,180,0,181,166,185],
[174,169,168,171,160,0,171,174],
[165,164,170,176,175,170,0,166],
[158,159,153,175,156,167,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 23, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,191,168,159,193,192,175],
[164,0,192,206,195,208,198,186],
[150,149,0,150,169,165,165,179],
[173,135,191,0,157,177,183,180],
[182,146,172,184,0,196,182,176],
[148,133,176,164,145,0,168,160],
[149,143,176,158,159,173,0,154],
[166,155,162,161,165,181,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 24, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,181,182,178,175,172,191],
[171,0,175,184,163,179,171,186],
[160,166,0,176,154,171,163,179],
[159,157,165,0,159,177,159,172],
[163,178,187,182,0,184,160,183],
[166,162,170,164,157,0,160,183],
[169,170,178,182,181,181,0,192],
[150,155,162,169,158,158,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 25, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,201,171,210,197,191,187],
[183,0,183,191,177,161,169,167],
[140,158,0,147,166,160,147,204],
[170,150,194,0,185,167,151,191],
[131,164,175,156,0,141,109,171],
[144,180,181,174,200,0,164,203],
[150,172,194,190,232,177,0,243],
[154,174,137,150,170,138,98,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 26, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,174,167,173,175,170,174],
[167,0,162,186,187,190,177,199],
[167,179,0,182,163,181,192,180],
[174,155,159,0,155,170,171,162],
[168,154,178,186,0,172,164,167],
[166,151,160,171,169,0,181,166],
[171,164,149,170,177,160,0,163],
[167,142,161,179,174,175,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 27, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,174,179,160,171,191,181],
[166,0,166,179,152,183,167,149],
[167,175,0,187,170,177,176,164],
[162,162,154,0,172,156,178,169],
[181,189,171,169,0,174,176,166],
[170,158,164,185,167,0,180,151],
[150,174,165,163,165,161,0,167],
[160,192,177,172,175,190,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 28, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,180,159,182,163,172,167],
[168,0,166,164,169,157,160,164],
[161,175,0,160,164,161,167,157],
[182,177,181,0,181,178,167,176],
[159,172,177,160,0,157,160,152],
[178,184,180,163,184,0,168,168],
[169,181,174,174,181,173,0,171],
[174,177,184,165,189,173,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 29, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,143,150,172,168,150,145],
[186,0,172,146,182,181,165,155],
[198,169,0,173,184,186,193,181],
[191,195,168,0,190,185,185,181],
[169,159,157,151,0,166,155,161],
[173,160,155,156,175,0,167,165],
[191,176,148,156,186,174,0,155],
[196,186,160,160,180,176,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 30, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,149,176,178,157,147,163],
[171,0,168,169,172,173,166,164],
[192,173,0,174,188,186,173,169],
[165,172,167,0,172,164,164,161],
[163,169,153,169,0,172,145,162],
[184,168,155,177,169,0,166,167],
[194,175,168,177,196,175,0,173],
[178,177,172,180,179,174,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 31, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,166,184,164,177,160,169],
[166,0,166,172,159,160,167,164],
[175,175,0,189,166,172,177,176],
[157,169,152,0,161,148,165,160],
[177,182,175,180,0,176,170,172],
[164,181,169,193,165,0,170,166],
[181,174,164,176,171,171,0,175],
[172,177,165,181,169,175,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 32, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,153,158,157,141,147,158],
[169,0,167,175,170,177,152,163],
[188,174,0,176,152,165,179,157],
[183,166,165,0,167,172,187,172],
[184,171,189,174,0,148,167,171],
[200,164,176,169,193,0,182,169],
[194,189,162,154,174,159,0,169],
[183,178,184,169,170,172,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 33, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,174,187,175,153,123,143],
[178,0,184,198,182,157,176,160],
[167,157,0,143,154,170,154,176],
[154,143,198,0,157,164,175,150],
[166,159,187,184,0,175,132,167],
[188,184,171,177,166,0,167,156],
[218,165,187,166,209,174,0,170],
[198,181,165,191,174,185,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 34, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,154,139,169,187,151,159],
[185,0,146,176,171,181,173,166],
[187,195,0,163,200,197,179,199],
[202,165,178,0,181,185,185,170],
[172,170,141,160,0,171,149,159],
[154,160,144,156,170,0,175,160],
[190,168,162,156,192,166,0,165],
[182,175,142,171,182,181,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 35, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,180,166,178,183,196,178],
[165,0,179,181,185,173,187,195],
[161,162,0,176,172,173,182,174],
[175,160,165,0,170,168,181,183],
[163,156,169,171,0,182,182,164],
[158,168,168,173,159,0,172,182],
[145,154,159,160,159,169,0,167],
[163,146,167,158,177,159,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 36, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,174,159,192,169,177,172],
[156,0,166,158,173,146,165,165],
[167,175,0,167,188,169,169,179],
[182,183,174,0,200,165,164,201],
[149,168,153,141,0,146,161,167],
[172,195,172,176,195,0,170,194],
[164,176,172,177,180,171,0,174],
[169,176,162,140,174,147,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 37, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,126,139,242,177,122,195,219],
[215,0,168,307,231,221,271,284],
[202,173,0,236,189,139,242,213],
[99,34,105,0,35,117,151,117],
[164,110,152,306,0,169,174,250],
[219,120,202,224,172,0,126,167],
[146,70,99,190,167,215,0,151],
[122,57,128,224,91,174,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 38, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,183,174,157,174,152,166],
[165,0,166,164,164,168,177,155],
[158,175,0,153,158,175,174,153],
[167,177,188,0,169,159,181,168],
[184,177,183,172,0,178,183,157],
[167,173,166,182,163,0,172,160],
[189,164,167,160,158,169,0,176],
[175,186,188,173,184,181,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 39, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,171,167,186,176,165,174],
[152,0,175,169,163,169,171,164],
[170,166,0,172,159,173,156,163],
[174,172,169,0,177,175,167,167],
[155,178,182,164,0,171,163,152],
[165,172,168,166,170,0,167,170],
[176,170,185,174,178,174,0,166],
[167,177,178,174,189,171,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 40, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,170,163,171,175,166,172],
[181,0,159,183,174,175,174,175],
[171,182,0,167,180,182,174,186],
[178,158,174,0,184,186,158,187],
[170,167,161,157,0,178,156,175],
[166,166,159,155,163,0,167,179],
[175,167,167,183,185,174,0,176],
[169,166,155,154,166,162,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 41, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,165,169,178,177,167,168],
[160,0,166,183,185,173,182,179],
[176,175,0,180,177,196,184,161],
[172,158,161,0,159,175,171,165],
[163,156,164,182,0,169,180,173],
[164,168,145,166,172,0,174,153],
[174,159,157,170,161,167,0,161],
[173,162,180,176,168,188,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 42, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,135,152,150,149,146,161,163],
[206,0,170,184,171,189,181,184],
[189,171,0,164,188,169,171,189],
[191,157,177,0,177,178,187,167],
[192,170,153,164,0,178,164,181],
[195,152,172,163,163,0,184,183],
[180,160,170,154,177,157,0,182],
[178,157,152,174,160,158,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 43, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,174,160,176,141,171,187],
[172,0,150,195,142,159,146,173],
[167,191,0,197,163,162,140,165],
[181,146,144,0,148,146,139,178],
[165,199,178,193,0,202,161,200],
[200,182,179,195,139,0,193,227],
[170,195,201,202,180,148,0,184],
[154,168,176,163,141,114,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 44, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,190,163,176,166,159,166,180],
[151,0,152,166,139,145,131,164],
[178,189,0,186,173,170,167,184],
[165,175,155,0,160,140,150,166],
[175,202,168,181,0,167,170,178],
[182,196,171,201,174,0,168,198],
[175,210,174,191,171,173,0,168],
[161,177,157,175,163,143,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 45, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,172,162,169,174,172,166],
[169,0,164,173,160,157,157,154],
[169,177,0,157,177,151,163,166],
[179,168,184,0,167,171,182,174],
[172,181,164,174,0,165,172,167],
[167,184,190,170,176,0,179,181],
[169,184,178,159,169,162,0,173],
[175,187,175,167,174,160,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 46, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,155,165,171,168,171,181],
[174,0,177,164,170,162,169,159],
[186,164,0,171,189,171,186,170],
[176,177,170,0,167,167,175,174],
[170,171,152,174,0,162,176,173],
[173,179,170,174,179,0,175,172],
[170,172,155,166,165,166,0,161],
[160,182,171,167,168,169,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 47, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,161,191,174,163,164,186],
[176,0,170,187,178,164,157,181],
[180,171,0,177,169,157,161,178],
[150,154,164,0,170,149,156,180],
[167,163,172,171,0,155,173,187],
[178,177,184,192,186,0,165,181],
[177,184,180,185,168,176,0,179],
[155,160,163,161,154,160,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 48, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,130,155,154,138,156,132,163],
[211,0,198,193,170,164,167,173],
[186,143,0,138,137,160,157,187],
[187,148,203,0,168,191,165,204],
[203,171,204,173,0,165,166,179],
[185,177,181,150,176,0,172,185],
[209,174,184,176,175,169,0,196],
[178,168,154,137,162,156,145,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 49, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,186,180,213,180,174,177],
[177,0,174,158,192,167,178,177],
[155,167,0,138,183,158,179,148],
[161,183,203,0,198,189,172,192],
[128,149,158,143,0,157,153,165],
[161,174,183,152,184,0,183,173],
[167,163,162,169,188,158,0,173],
[164,164,193,149,176,168,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 50, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,174,155,157,155,144,157],
[184,0,177,164,177,158,142,149],
[167,164,0,181,176,162,156,168],
[186,177,160,0,175,164,172,161],
[184,164,165,166,0,166,159,158],
[186,183,179,177,175,0,148,167],
[197,199,185,169,182,193,0,187],
[184,192,173,180,183,174,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 51, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,170,186,176,182,170,187],
[165,0,186,168,185,196,181,182],
[171,155,0,162,160,174,163,177],
[155,173,179,0,173,206,191,163],
[165,156,181,168,0,155,173,173],
[159,145,167,135,186,0,158,169],
[171,160,178,150,168,183,0,187],
[154,159,164,178,168,172,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 52, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,162,179,180,165,161,161],
[168,0,156,173,163,158,171,156],
[179,185,0,194,194,177,176,167],
[162,168,147,0,182,175,175,171],
[161,178,147,159,0,160,175,157],
[176,183,164,166,181,0,175,170],
[180,170,165,166,166,166,0,170],
[180,185,174,170,184,171,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 53, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,165,203,163,164,122,191],
[170,0,185,238,182,214,214,260],
[176,156,0,188,133,124,181,192],
[138,103,153,0,144,139,162,201],
[178,159,208,197,0,226,214,221],
[177,127,217,202,115,0,179,238],
[219,127,160,179,127,162,0,205],
[150,81,149,140,120,103,136,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 54, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,180,165,173,163,178,169],
[174,0,183,155,162,175,178,171],
[161,158,0,147,155,162,164,147],
[176,186,194,0,171,165,181,178],
[168,179,186,170,0,158,192,184],
[178,166,179,176,183,0,192,169],
[163,163,177,160,149,149,0,158],
[172,170,194,163,157,172,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 55, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,172,182,170,175,174,172],
[170,0,169,172,167,185,171,171],
[169,172,0,195,173,172,166,178],
[159,169,146,0,155,158,157,163],
[171,174,168,186,0,170,170,181],
[166,156,169,183,171,0,160,171],
[167,170,175,184,171,181,0,174],
[169,170,163,178,160,170,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 56, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,194,175,168,161,163,164,194],
[147,0,154,146,149,181,139,168],
[166,187,0,178,174,178,172,179],
[173,195,163,0,182,173,170,181],
[180,192,167,159,0,169,192,201],
[178,160,163,168,172,0,163,180],
[177,202,169,171,149,178,0,191],
[147,173,162,160,140,161,150,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 57, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,196,160,171,178,179,181],
[160,0,155,156,162,150,155,151],
[145,186,0,158,143,163,163,171],
[181,185,183,0,170,162,172,185],
[170,179,198,171,0,180,166,210],
[163,191,178,179,161,0,144,182],
[162,186,178,169,175,197,0,195],
[160,190,170,156,131,159,146,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 58, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,137,154,158,156,145,159,162],
[204,0,168,157,166,176,177,176],
[187,173,0,171,163,171,177,162],
[183,184,170,0,189,163,184,161],
[185,175,178,152,0,185,183,164],
[196,165,170,178,156,0,197,183],
[182,164,164,157,158,144,0,154],
[179,165,179,180,177,158,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 59, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,170,158,166,175,168,176],
[163,0,175,163,165,171,168,177],
[171,166,0,168,173,176,174,167],
[183,178,173,0,170,176,177,179],
[175,176,168,171,0,174,168,182],
[166,170,165,165,167,0,172,176],
[173,173,167,164,173,169,0,180],
[165,164,174,162,159,165,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 60, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,157,165,190,148,117,152],
[174,0,133,148,140,173,149,151],
[184,208,0,155,154,152,210,225],
[176,193,186,0,185,199,147,195],
[151,201,187,156,0,210,189,186],
[193,168,189,142,131,0,211,150],
[224,192,131,194,152,130,0,116],
[189,190,116,146,155,191,225,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 61, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,162,174,168,158,183,170],
[171,0,162,159,163,161,174,177],
[179,179,0,159,180,162,165,182],
[167,182,182,0,179,171,180,184],
[173,178,161,162,0,162,154,180],
[183,180,179,170,179,0,186,192],
[158,167,176,161,187,155,0,179],
[171,164,159,157,161,149,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 62, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,190,178,178,171,184,161,160],
[151,0,149,169,147,163,162,151],
[163,192,0,181,170,182,165,163],
[163,172,160,0,137,179,168,162],
[170,194,171,204,0,189,182,176],
[157,178,159,162,152,0,148,158],
[180,179,176,173,159,193,0,185],
[181,190,178,179,165,183,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 63, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,162,165,162,171,160,141],
[186,0,184,174,175,169,179,178],
[179,157,0,166,180,173,168,153],
[176,167,175,0,162,178,187,170],
[179,166,161,179,0,178,171,173],
[170,172,168,163,163,0,162,154],
[181,162,173,154,170,179,0,160],
[200,163,188,171,168,187,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 64, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,176,188,167,164,189,162],
[172,0,182,185,169,166,177,164],
[165,159,0,192,175,173,172,170],
[153,156,149,0,160,162,170,143],
[174,172,166,181,0,161,180,173],
[177,175,168,179,180,0,185,164],
[152,164,169,171,161,156,0,162],
[179,177,171,198,168,177,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 65, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,188,141,150,125,169,164],
[165,0,174,170,187,159,126,162],
[153,167,0,156,142,178,130,147],
[200,171,185,0,167,146,156,173],
[191,154,199,174,0,159,173,179],
[216,182,163,195,182,0,162,182],
[172,215,211,185,168,179,0,175],
[177,179,194,168,162,159,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 66, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,233,185,179,184,133,156],
[169,0,212,171,221,214,129,184],
[108,129,0,137,171,159,111,140],
[156,170,204,0,198,188,173,169],
[162,120,170,143,0,181,148,179],
[157,127,182,153,160,0,128,144],
[208,212,230,168,193,213,0,159],
[185,157,201,172,162,197,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 67, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,166,176,185,186,172,171],
[179,0,166,185,187,186,180,171],
[175,175,0,176,184,195,193,169],
[165,156,165,0,178,165,183,159],
[156,154,157,163,0,159,174,161],
[155,155,146,176,182,0,176,165],
[169,161,148,158,167,165,0,156],
[170,170,172,182,180,176,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 68, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,185,186,168,182,169,194],
[165,0,181,180,155,172,171,175],
[156,160,0,175,153,180,162,171],
[155,161,166,0,163,160,155,164],
[173,186,188,178,0,185,161,192],
[159,169,161,181,156,0,172,176],
[172,170,179,186,180,169,0,191],
[147,166,170,177,149,165,150,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 69, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,158,167,168,158,164,159],
[184,0,178,188,177,180,168,182],
[183,163,0,180,169,173,172,185],
[174,153,161,0,185,168,172,168],
[173,164,172,156,0,155,180,184],
[183,161,168,173,186,0,177,175],
[177,173,169,169,161,164,0,180],
[182,159,156,173,157,166,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 70, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,185,183,162,173,167,140],
[186,0,154,185,165,150,172,154],
[156,187,0,183,174,168,166,138],
[158,156,158,0,157,153,153,130],
[179,176,167,184,0,183,197,189],
[168,191,173,188,158,0,176,171],
[174,169,175,188,144,165,0,172],
[201,187,203,211,152,170,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 71, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,193,160,186,173,168,172],
[159,0,166,163,171,164,156,150],
[148,175,0,161,178,173,168,173],
[181,178,180,0,175,168,174,170],
[155,170,163,166,0,159,160,155],
[168,177,168,173,182,0,180,177],
[173,185,173,167,181,161,0,167],
[169,191,168,171,186,164,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 72, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,171,183,194,158,166,167],
[172,0,177,194,184,177,173,169],
[170,164,0,190,191,172,162,175],
[158,147,151,0,167,145,159,158],
[147,157,150,174,0,171,152,157],
[183,164,169,196,170,0,167,176],
[175,168,179,182,189,174,0,162],
[174,172,166,183,184,165,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 73, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,175,171,162,169,176,166],
[178,0,162,175,164,159,171,162],
[166,179,0,182,170,172,172,166],
[170,166,159,0,156,162,170,165],
[179,177,171,185,0,178,168,171],
[172,182,169,179,163,0,176,179],
[165,170,169,171,173,165,0,173],
[175,179,175,176,170,162,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 74, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,195,168,170,183,175,175],
[157,0,173,151,156,158,153,152],
[146,168,0,154,163,159,167,165],
[173,190,187,0,165,176,174,170],
[171,185,178,176,0,165,175,168],
[158,183,182,165,176,0,175,172],
[166,188,174,167,166,166,0,162],
[166,189,176,171,173,169,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 75, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,178,179,195,159,181,193],
[155,0,145,175,165,148,142,166],
[163,196,0,192,172,185,186,200],
[162,166,149,0,167,155,163,157],
[146,176,169,174,0,165,161,178],
[182,193,156,186,176,0,184,182],
[160,199,155,178,180,157,0,182],
[148,175,141,184,163,159,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 76, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,170,171,177,178,168,157],
[156,0,170,187,179,178,168,174],
[171,171,0,155,156,165,143,152],
[170,154,186,0,174,166,164,172],
[164,162,185,167,0,170,160,150],
[163,163,176,175,171,0,168,173],
[173,173,198,177,181,173,0,161],
[184,167,189,169,191,168,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 77, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,199,169,182,167,189,151,154],
[142,0,164,192,144,184,147,130],
[172,177,0,190,150,197,170,136],
[159,149,151,0,145,180,149,147],
[174,197,191,196,0,219,168,173],
[152,157,144,161,122,0,133,146],
[190,194,171,192,173,208,0,164],
[187,211,205,194,168,195,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 78, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,164,177,166,164,155,170],
[166,0,173,162,161,171,152,181],
[177,168,0,162,163,165,155,161],
[164,179,179,0,166,160,157,177],
[175,180,178,175,0,188,160,169],
[177,170,176,181,153,0,171,159],
[186,189,186,184,181,170,0,171],
[171,160,180,164,172,182,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 79, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,175,172,172,177,180,164],
[153,0,149,164,161,171,152,153],
[166,192,0,179,178,181,175,164],
[169,177,162,0,172,180,185,176],
[169,180,163,169,0,178,165,170],
[164,170,160,161,163,0,175,158],
[161,189,166,156,176,166,0,168],
[177,188,177,165,171,183,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 80, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,177,159,174,157,159,159],
[184,0,190,167,190,174,173,174],
[164,151,0,154,164,164,153,147],
[182,174,187,0,178,177,175,161],
[167,151,177,163,0,176,175,163],
[184,167,177,164,165,0,174,162],
[182,168,188,166,166,167,0,168],
[182,167,194,180,178,179,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 81, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,171,179,179,178,163,179],
[178,0,162,182,184,186,175,199],
[170,179,0,176,191,180,171,193],
[162,159,165,0,169,174,159,182],
[162,157,150,172,0,172,165,184],
[163,155,161,167,169,0,151,177],
[178,166,170,182,176,190,0,188],
[162,142,148,159,157,164,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 82, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,143,165,159,166,175,155,162],
[198,0,182,176,165,177,171,188],
[176,159,0,159,161,155,152,159],
[182,165,182,0,146,172,153,160],
[175,176,180,195,0,192,154,167],
[166,164,186,169,149,0,146,155],
[186,170,189,188,187,195,0,176],
[179,153,182,181,174,186,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 83, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,196,168,185,162,183,191],
[183,0,171,174,169,166,159,163],
[145,170,0,177,177,138,156,150],
[173,167,164,0,163,157,164,156],
[156,172,164,178,0,157,155,168],
[179,175,203,184,184,0,182,170],
[158,182,185,177,186,159,0,183],
[150,178,191,185,173,171,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 84, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,172,180,162,169,161,175],
[156,0,163,173,162,165,151,153],
[169,178,0,181,177,167,161,154],
[161,168,160,0,142,167,161,157],
[179,179,164,199,0,181,186,180],
[172,176,174,174,160,0,166,178],
[180,190,180,180,155,175,0,172],
[166,188,187,184,161,163,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 85, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,169,169,175,166,165,160],
[186,0,185,171,201,177,161,160],
[172,156,0,178,176,172,165,172],
[172,170,163,0,176,169,146,152],
[166,140,165,165,0,167,156,153],
[175,164,169,172,174,0,175,178],
[176,180,176,195,185,166,0,168],
[181,181,169,189,188,163,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 86, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,173,175,166,186,174,190],
[167,0,179,183,173,169,178,194],
[168,162,0,175,167,159,178,180],
[166,158,166,0,139,141,174,165],
[175,168,174,202,0,181,180,174],
[155,172,182,200,160,0,185,194],
[167,163,163,167,161,156,0,168],
[151,147,161,176,167,147,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 87, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,183,168,185,165,171,176],
[154,0,165,155,174,149,158,158],
[158,176,0,169,193,167,175,162],
[173,186,172,0,190,164,178,165],
[156,167,148,151,0,144,152,154],
[176,192,174,177,197,0,183,170],
[170,183,166,163,189,158,0,168],
[165,183,179,176,187,171,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 88, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,147,158,141,155,155,177,154],
[194,0,168,176,170,186,182,184],
[183,173,0,170,171,159,182,157],
[200,165,171,0,174,165,183,179],
[186,171,170,167,0,167,184,176],
[186,155,182,176,174,0,180,164],
[164,159,159,158,157,161,0,161],
[187,157,184,162,165,177,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 89, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,157,169,160,186,187,160],
[175,0,184,169,180,163,194,184],
[184,157,0,160,205,164,183,164],
[172,172,181,0,185,152,154,152],
[181,161,136,156,0,131,161,128],
[155,178,177,189,210,0,174,163],
[154,147,158,187,180,167,0,186],
[181,157,177,189,213,178,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 90, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,169,158,181,180,168,174],
[169,0,175,187,168,180,172,178],
[172,166,0,181,176,168,157,175],
[183,154,160,0,175,176,165,173],
[160,173,165,166,0,176,167,156],
[161,161,173,165,165,0,155,173],
[173,169,184,176,174,186,0,193],
[167,163,166,168,185,168,148,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 91, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,166,173,166,152,175,155],
[180,0,168,189,180,167,173,170],
[175,173,0,173,176,184,188,165],
[168,152,168,0,167,156,166,156],
[175,161,165,174,0,150,174,168],
[189,174,157,185,191,0,187,177],
[166,168,153,175,167,154,0,179],
[186,171,176,185,173,164,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 92, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,157,168,158,174,168,172],
[185,0,176,159,178,197,190,181],
[184,165,0,177,169,190,201,194],
[173,182,164,0,169,180,178,183],
[183,163,172,172,0,179,188,201],
[167,144,151,161,162,0,173,174],
[173,151,140,163,153,168,0,172],
[169,160,147,158,140,167,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 93, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,140,157,162,137,165,158,168],
[201,0,173,178,194,168,192,192],
[184,168,0,163,176,176,193,178],
[179,163,178,0,174,177,183,192],
[204,147,165,167,0,161,162,172],
[176,173,165,164,180,0,177,183],
[183,149,148,158,179,164,0,158],
[173,149,163,149,169,158,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 94, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,175,164,155,170,180,164],
[159,0,158,176,167,161,160,183],
[166,183,0,171,171,174,171,179],
[177,165,170,0,169,175,182,179],
[186,174,170,172,0,173,170,183],
[171,180,167,166,168,0,174,175],
[161,181,170,159,171,167,0,164],
[177,158,162,162,158,166,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 95, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,103,160,106,132,178,162],
[169,0,137,178,125,164,170,167],
[238,204,0,180,175,213,200,165],
[181,163,161,0,135,186,160,138],
[235,216,166,206,0,207,212,184],
[209,177,128,155,134,0,175,140],
[163,171,141,181,129,166,0,144],
[179,174,176,203,157,201,197,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 96, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,172,197,188,232,162,189],
[168,0,130,143,189,166,184,179],
[169,211,0,171,219,205,171,193],
[144,198,170,0,213,208,232,201],
[153,152,122,128,0,180,155,145],
[109,175,136,133,161,0,151,153],
[179,157,170,109,186,190,0,179],
[152,162,148,140,196,188,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 97, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,172,174,162,178,175,162],
[183,0,180,192,172,186,192,166],
[169,161,0,186,158,161,159,158],
[167,149,155,0,155,148,180,151],
[179,169,183,186,0,175,186,168],
[163,155,180,193,166,0,181,172],
[166,149,182,161,155,160,0,153],
[179,175,183,190,173,169,188,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 98, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,198,181,180,182,162,168,158],
[143,0,163,159,154,149,151,153],
[160,178,0,162,175,172,159,166],
[161,182,179,0,174,173,169,172],
[159,187,166,167,0,151,156,164],
[179,192,169,168,190,0,167,177],
[173,190,182,172,185,174,0,167],
[183,188,175,169,177,164,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 99, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,172,163,168,169,169,177],
[180,0,174,170,174,172,163,174],
[169,167,0,175,178,175,164,173],
[178,171,166,0,177,166,184,167],
[173,167,163,164,0,157,165,166],
[172,169,166,175,184,0,173,172],
[172,178,177,157,176,168,0,180],
[164,167,168,174,175,169,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 100, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,153,165,181,172,166,191],
[159,0,171,166,164,167,179,188],
[188,170,0,175,171,188,168,205],
[176,175,166,0,193,183,182,209],
[160,177,170,148,0,173,168,195],
[169,174,153,158,168,0,175,181],
[175,162,173,159,173,166,0,183],
[150,153,136,132,146,160,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 101, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,176,168,161,174,168,162],
[168,0,174,183,175,181,179,179],
[165,167,0,180,170,177,176,168],
[173,158,161,0,166,171,174,164],
[180,166,171,175,0,185,169,174],
[167,160,164,170,156,0,165,157],
[173,162,165,167,172,176,0,164],
[179,162,173,177,167,184,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 102, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,189,170,166,169,170,180],
[160,0,183,170,177,175,174,172],
[152,158,0,175,159,171,178,176],
[171,171,166,0,162,161,185,174],
[175,164,182,179,0,179,174,179],
[172,166,170,180,162,0,180,181],
[171,167,163,156,167,161,0,168],
[161,169,165,167,162,160,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 103, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,176,178,160,174,159,169],
[166,0,183,167,159,167,166,185],
[165,158,0,186,160,161,169,165],
[163,174,155,0,161,155,153,171],
[181,182,181,180,0,167,171,175],
[167,174,180,186,174,0,170,166],
[182,175,172,188,170,171,0,183],
[172,156,176,170,166,175,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 104, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,176,166,183,189,172,169],
[159,0,158,146,161,161,162,173],
[165,183,0,180,174,188,168,194],
[175,195,161,0,186,174,182,173],
[158,180,167,155,0,181,175,171],
[152,180,153,167,160,0,169,174],
[169,179,173,159,166,172,0,175],
[172,168,147,168,170,167,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 105, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,169,164,176,193,182,185],
[164,0,155,157,157,173,169,177],
[172,186,0,170,163,174,177,179],
[177,184,171,0,170,194,180,176],
[165,184,178,171,0,195,187,180],
[148,168,167,147,146,0,174,155],
[159,172,164,161,154,167,0,157],
[156,164,162,165,161,186,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 106, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,174,171,192,189,168,178],
[163,0,156,158,178,172,160,180],
[167,185,0,156,171,163,157,183],
[170,183,185,0,190,190,172,194],
[149,163,170,151,0,181,145,173],
[152,169,178,151,160,0,147,185],
[173,181,184,169,196,194,0,170],
[163,161,158,147,168,156,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 107, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,173,172,174,168,165,182],
[160,0,159,152,177,156,151,162],
[168,182,0,181,178,171,187,186],
[169,189,160,0,179,173,181,170],
[167,164,163,162,0,156,174,188],
[173,185,170,168,185,0,172,167],
[176,190,154,160,167,169,0,155],
[159,179,155,171,153,174,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 108, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,205,150,225,176,197,185],
[170,0,178,177,196,203,223,186],
[136,163,0,134,219,215,247,228],
[191,164,207,0,229,205,226,187],
[116,145,122,112,0,155,189,173],
[165,138,126,136,186,0,210,175],
[144,118,94,115,152,131,0,174],
[156,155,113,154,168,166,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 109, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,180,160,196,206,185,196],
[178,0,166,154,187,165,147,179],
[161,175,0,163,147,193,152,160],
[181,187,178,0,203,203,176,167],
[145,154,194,138,0,162,141,153],
[135,176,148,138,179,0,166,162],
[156,194,189,165,200,175,0,175],
[145,162,181,174,188,179,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 110, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,167,150,173,169,178,164],
[163,0,145,148,168,168,158,175],
[174,196,0,179,168,156,181,169],
[191,193,162,0,186,170,193,188],
[168,173,173,155,0,171,158,157],
[172,173,185,171,170,0,174,171],
[163,183,160,148,183,167,0,159],
[177,166,172,153,184,170,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 111, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,173,174,197,194,196,166],
[150,0,175,162,172,187,186,163],
[168,166,0,162,187,200,190,183],
[167,179,179,0,185,189,191,155],
[144,169,154,156,0,174,185,174],
[147,154,141,152,167,0,179,156],
[145,155,151,150,156,162,0,156],
[175,178,158,186,167,185,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 112, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,179,163,178,184,156,141],
[171,0,180,167,185,165,171,185],
[162,161,0,153,179,172,149,158],
[178,174,188,0,179,169,154,175],
[163,156,162,162,0,155,159,167],
[157,176,169,172,186,0,170,163],
[185,170,192,187,182,171,0,180],
[200,156,183,166,174,178,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 113, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,149,161,178,169,175,158,162],
[192,0,177,201,152,196,156,177],
[180,164,0,202,163,159,181,164],
[163,140,139,0,149,158,138,147],
[172,189,178,192,0,169,174,162],
[166,145,182,183,172,0,168,165],
[183,185,160,203,167,173,0,173],
[179,164,177,194,179,176,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 114, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,167,170,187,181,163,149],
[169,0,192,176,195,174,192,167],
[174,149,0,136,170,145,140,151],
[171,165,205,0,189,172,181,164],
[154,146,171,152,0,160,137,125],
[160,167,196,169,181,0,185,159],
[178,149,201,160,204,156,0,171],
[192,174,190,177,216,182,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 115, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,175,159,178,161,160,169],
[181,0,151,163,164,190,167,165],
[166,190,0,182,148,175,202,162],
[182,178,159,0,176,168,178,169],
[163,177,193,165,0,166,207,176],
[180,151,166,173,175,0,182,179],
[181,174,139,163,134,159,0,159],
[172,176,179,172,165,162,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 116, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,219,193,180,161,160,160],
[187,0,170,179,199,126,139,110],
[122,171,0,126,158,134,131,151],
[148,162,215,0,183,147,159,172],
[161,142,183,158,0,151,122,141],
[180,215,207,194,190,0,146,157],
[181,202,210,182,219,195,0,158],
[181,231,190,169,200,184,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 117, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,145,176,178,160,158,147,172],
[196,0,162,183,166,155,174,170],
[165,179,0,173,160,165,164,176],
[163,158,168,0,158,166,157,183],
[181,175,181,183,0,168,170,181],
[183,186,176,175,173,0,156,176],
[194,167,177,184,171,185,0,188],
[169,171,165,158,160,165,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 118, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,176,176,171,177,177,149],
[170,0,182,205,204,155,162,141],
[165,159,0,171,175,177,160,156],
[165,136,170,0,166,174,147,155],
[170,137,166,175,0,151,162,144],
[164,186,164,167,190,0,151,167],
[164,179,181,194,179,190,0,172],
[192,200,185,186,197,174,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 119, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,236,118,147,177,203,102,244],
[105,0,174,39,49,221,132,207],
[223,167,0,130,96,232,173,236],
[194,302,211,0,140,280,162,233],
[164,292,245,201,0,292,191,292],
[138,120,109,61,49,0,27,150],
[239,209,168,179,150,314,0,239],
[97,134,105,108,49,191,102,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 120, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,143,157,177,126,188,186,156],
[198,0,174,183,172,206,197,151],
[184,167,0,199,139,169,174,158],
[164,158,142,0,133,158,189,162],
[215,169,202,208,0,224,205,182],
[153,135,172,183,117,0,170,141],
[155,144,167,152,136,171,0,137],
[185,190,183,179,159,200,204,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 121, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,129,163,173,151,158,160],
[185,0,165,175,156,171,157,168],
[212,176,0,188,171,199,166,162],
[178,166,153,0,156,179,154,161],
[168,185,170,185,0,179,160,175],
[190,170,142,162,162,0,157,169],
[183,184,175,187,181,184,0,170],
[181,173,179,180,166,172,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 122, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,159,177,175,170,163,180],
[169,0,173,184,179,179,173,186],
[182,168,0,192,169,184,172,191],
[164,157,149,0,156,160,174,171],
[166,162,172,185,0,174,170,171],
[171,162,157,181,167,0,180,181],
[178,168,169,167,171,161,0,180],
[161,155,150,170,170,160,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 123, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,166,191,170,201,186,180],
[160,0,171,197,157,182,176,132],
[175,170,0,200,194,203,176,159],
[150,144,141,0,144,187,177,124],
[171,184,147,197,0,192,173,136],
[140,159,138,154,149,0,141,129],
[155,165,165,164,168,200,0,124],
[161,209,182,217,205,212,217,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 124, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,162,149,166,155,167,152],
[159,0,167,170,165,169,147,143],
[179,174,0,153,174,181,167,166],
[192,171,188,0,169,190,169,175],
[175,176,167,172,0,181,164,159],
[186,172,160,151,160,0,167,161],
[174,194,174,172,177,174,0,164],
[189,198,175,166,182,180,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 125, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,183,159,166,154,164,162],
[181,0,186,182,170,167,188,163],
[158,155,0,158,151,160,175,150],
[182,159,183,0,165,170,183,173],
[175,171,190,176,0,166,189,162],
[187,174,181,171,175,0,190,167],
[177,153,166,158,152,151,0,159],
[179,178,191,168,179,174,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 126, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,168,185,186,169,190,175],
[161,0,149,175,143,169,161,169],
[173,192,0,193,163,180,184,181],
[156,166,148,0,167,163,171,171],
[155,198,178,174,0,173,184,172],
[172,172,161,178,168,0,184,179],
[151,180,157,170,157,157,0,161],
[166,172,160,170,169,162,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 127, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,95,163,164,204,99,134,129],
[246,0,270,209,201,252,149,171],
[178,71,0,153,161,148,61,105],
[177,132,188,0,132,107,93,105],
[137,140,180,209,0,152,90,120],
[242,89,193,234,189,0,147,115],
[207,192,280,248,251,194,0,98],
[212,170,236,236,221,226,243,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 128, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,165,173,179,169,170,183],
[154,0,162,158,178,182,166,171],
[176,179,0,178,193,185,168,188],
[168,183,163,0,184,173,173,176],
[162,163,148,157,0,153,163,180],
[172,159,156,168,188,0,172,184],
[171,175,173,168,178,169,0,191],
[158,170,153,165,161,157,150,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 129, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,155,164,174,172,154,159],
[163,0,171,151,168,172,173,172],
[186,170,0,154,183,175,183,159],
[177,190,187,0,184,183,190,170],
[167,173,158,157,0,172,180,156],
[169,169,166,158,169,0,162,155],
[187,168,158,151,161,179,0,165],
[182,169,182,171,185,186,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 130, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,189,178,166,197,160,194],
[160,0,228,215,168,222,131,207],
[152,113,0,168,156,155,163,140],
[163,126,173,0,166,154,165,171],
[175,173,185,175,0,181,162,145],
[144,119,186,187,160,0,191,176],
[181,210,178,176,179,150,0,178],
[147,134,201,170,196,165,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 131, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,159,147,162,158,156,158],
[172,0,180,159,166,164,168,166],
[182,161,0,156,164,179,163,163],
[194,182,185,0,178,183,179,162],
[179,175,177,163,0,180,167,162],
[183,177,162,158,161,0,164,150],
[185,173,178,162,174,177,0,174],
[183,175,178,179,179,191,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 132, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,188,167,178,178,156,172],
[182,0,200,182,175,200,161,180],
[153,141,0,159,162,173,155,161],
[174,159,182,0,164,181,160,171],
[163,166,179,177,0,195,171,185],
[163,141,168,160,146,0,160,160],
[185,180,186,181,170,181,0,184],
[169,161,180,170,156,181,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 133, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,182,170,172,166,183,184],
[164,0,159,174,177,172,177,171],
[159,182,0,172,176,168,194,160],
[171,167,169,0,154,158,192,165],
[169,164,165,187,0,181,178,174],
[175,169,173,183,160,0,182,168],
[158,164,147,149,163,159,0,160],
[157,170,181,176,167,173,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 134, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,165,142,163,154,175,149],
[173,0,172,160,181,162,143,168],
[176,169,0,159,184,151,164,150],
[199,181,182,0,164,170,178,168],
[178,160,157,177,0,145,155,171],
[187,179,190,171,196,0,167,175],
[166,198,177,163,186,174,0,175],
[192,173,191,173,170,166,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 135, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,157,174,175,171,158,179],
[178,0,174,175,195,168,172,162],
[184,167,0,168,171,172,163,167],
[167,166,173,0,176,169,158,175],
[166,146,170,165,0,166,144,161],
[170,173,169,172,175,0,173,179],
[183,169,178,183,197,168,0,181],
[162,179,174,166,180,162,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 136, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,177,179,167,173,176,168],
[178,0,190,188,178,178,168,180],
[164,151,0,164,161,170,167,166],
[162,153,177,0,170,179,181,170],
[174,163,180,171,0,169,173,173],
[168,163,171,162,172,0,161,188],
[165,173,174,160,168,180,0,180],
[173,161,175,171,168,153,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 137, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,172,175,154,189,146,156],
[154,0,160,155,155,176,146,143],
[169,181,0,161,169,176,184,163],
[166,186,180,0,149,179,187,175],
[187,186,172,192,0,196,202,157],
[152,165,165,162,145,0,145,149],
[195,195,157,154,139,196,0,158],
[185,198,178,166,184,192,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 138, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,165,175,170,188,183,189],
[150,0,159,160,161,169,170,180],
[176,182,0,170,168,177,185,188],
[166,181,171,0,172,180,186,179],
[171,180,173,169,0,186,171,186],
[153,172,164,161,155,0,171,181],
[158,171,156,155,170,170,0,173],
[152,161,153,162,155,160,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 139, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,186,186,170,178,175,178],
[173,0,194,188,182,162,177,164],
[155,147,0,174,175,154,173,167],
[155,153,167,0,178,156,155,168],
[171,159,166,163,0,154,174,186],
[163,179,187,185,187,0,160,185],
[166,164,168,186,167,181,0,173],
[163,177,174,173,155,156,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 140, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,148,174,188,155,169,166],
[164,0,166,161,177,170,150,166],
[193,175,0,182,182,150,169,188],
[167,180,159,0,154,199,165,156],
[153,164,159,187,0,168,162,158],
[186,171,191,142,173,0,150,179],
[172,191,172,176,179,191,0,158],
[175,175,153,185,183,162,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 141, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,143,147,165,164,129,163,135],
[198,0,180,196,246,144,175,184],
[194,161,0,207,218,192,225,207],
[176,145,134,0,186,149,193,170],
[177,95,123,155,0,97,135,133],
[212,197,149,192,244,0,173,212],
[178,166,116,148,206,168,0,188],
[206,157,134,171,208,129,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 142, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,161,176,180,144,185,208],
[187,0,168,190,171,150,172,205],
[180,173,0,162,172,174,170,195],
[165,151,179,0,178,155,165,176],
[161,170,169,163,0,160,161,197],
[197,191,167,186,181,0,194,207],
[156,169,171,176,180,147,0,180],
[133,136,146,165,144,134,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 143, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,170,165,163,154,167,172],
[162,0,168,168,156,146,152,173],
[171,173,0,171,173,164,174,199],
[176,173,170,0,161,159,167,178],
[178,185,168,180,0,165,169,186],
[187,195,177,182,176,0,159,186],
[174,189,167,174,172,182,0,175],
[169,168,142,163,155,155,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 144, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,200,182,188,200,186,194,165],
[141,0,160,145,170,158,155,146],
[159,181,0,166,181,159,167,177],
[153,196,175,0,194,180,177,162],
[141,171,160,147,0,171,171,145],
[155,183,182,161,170,0,166,155],
[147,186,174,164,170,175,0,167],
[176,195,164,179,196,186,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 145, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,191,155,165,177,173,180],
[175,0,196,166,173,177,156,163],
[150,145,0,148,145,182,149,151],
[186,175,193,0,163,175,193,176],
[176,168,196,178,0,169,174,175],
[164,164,159,166,172,0,173,167],
[168,185,192,148,167,168,0,151],
[161,178,190,165,166,174,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 146, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,151,162,166,169,166,152],
[171,0,186,164,185,174,184,179],
[190,155,0,155,185,152,177,135],
[179,177,186,0,186,172,201,160],
[175,156,156,155,0,169,178,163],
[172,167,189,169,172,0,177,153],
[175,157,164,140,163,164,0,141],
[189,162,206,181,178,188,200,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 147, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,169,163,163,172,169,173],
[180,0,168,171,172,179,178,175],
[172,173,0,171,165,171,178,184],
[178,170,170,0,164,175,181,193],
[178,169,176,177,0,177,176,172],
[169,162,170,166,164,0,167,174],
[172,163,163,160,165,174,0,178],
[168,166,157,148,169,167,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 148, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,141,188,171,184,176,187],
[172,0,173,181,164,176,193,191],
[200,168,0,189,164,178,192,196],
[153,160,152,0,152,180,166,186],
[170,177,177,189,0,164,168,166],
[157,165,163,161,177,0,183,187],
[165,148,149,175,173,158,0,159],
[154,150,145,155,175,154,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 149, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,164,170,156,158,161,188],
[166,0,176,190,170,167,191,144],
[177,165,0,178,175,134,180,148],
[171,151,163,0,167,173,171,182],
[185,171,166,174,0,173,191,175],
[183,174,207,168,168,0,210,175],
[180,150,161,170,150,131,0,163],
[153,197,193,159,166,166,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 150, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,159,175,192,206,210,174],
[165,0,144,150,194,178,190,156],
[182,197,0,164,192,216,197,166],
[166,191,177,0,193,218,204,176],
[149,147,149,148,0,178,180,151],
[135,163,125,123,163,0,169,137],
[131,151,144,137,161,172,0,136],
[167,185,175,165,190,204,205,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 151, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,153,176,162,172,164,164],
[181,0,157,172,168,185,183,163],
[188,184,0,186,166,190,192,175],
[165,169,155,0,147,162,160,159],
[179,173,175,194,0,187,183,169],
[169,156,151,179,154,0,179,168],
[177,158,149,181,158,162,0,161],
[177,178,166,182,172,173,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 152, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,167,166,173,159,158,157],
[169,0,166,162,160,171,158,156],
[174,175,0,175,160,166,172,161],
[175,179,166,0,166,178,174,172],
[168,181,181,175,0,162,183,175],
[182,170,175,163,179,0,187,159],
[183,183,169,167,158,154,0,175],
[184,185,180,169,166,182,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 153, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,175,181,179,168,167,166],
[169,0,161,184,175,171,178,179],
[166,180,0,175,176,143,136,151],
[160,157,166,0,163,149,171,146],
[162,166,165,178,0,175,186,158],
[173,170,198,192,166,0,194,171],
[174,163,205,170,155,147,0,146],
[175,162,190,195,183,170,195,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 154, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,140,144,150,160,143,159,166],
[201,0,170,195,215,200,186,199],
[197,171,0,181,188,183,190,168],
[191,146,160,0,175,166,142,172],
[181,126,153,166,0,161,184,160],
[198,141,158,175,180,0,191,159],
[182,155,151,199,157,150,0,181],
[175,142,173,169,181,182,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 155, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,164,169,174,147,162,161],
[172,0,158,158,178,166,161,167],
[177,183,0,179,183,163,169,179],
[172,183,162,0,192,158,167,171],
[167,163,158,149,0,162,154,157],
[194,175,178,183,179,0,177,162],
[179,180,172,174,187,164,0,161],
[180,174,162,170,184,179,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 156, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,175,176,168,179,171,172],
[162,0,167,177,160,171,175,160],
[166,174,0,184,182,170,175,168],
[165,164,157,0,166,164,161,162],
[173,181,159,175,0,162,169,160],
[162,170,171,177,179,0,162,166],
[170,166,166,180,172,179,0,162],
[169,181,173,179,181,175,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 157, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,177,170,200,140,162,161],
[162,0,162,191,180,133,149,164],
[164,179,0,161,190,146,164,155],
[171,150,180,0,195,166,170,145],
[141,161,151,146,0,149,176,149],
[201,208,195,175,192,0,169,162],
[179,192,177,171,165,172,0,181],
[180,177,186,196,192,179,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 158, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,180,174,183,178,185,167],
[166,0,163,166,168,167,163,164],
[161,178,0,179,177,184,178,162],
[167,175,162,0,163,169,173,173],
[158,173,164,178,0,160,174,172],
[163,174,157,172,181,0,184,172],
[156,178,163,168,167,157,0,165],
[174,177,179,168,169,169,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 159, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,144,171,144,177,180,175,160],
[197,0,167,175,174,189,203,176],
[170,174,0,150,166,162,183,152],
[197,166,191,0,203,184,189,175],
[164,167,175,138,0,200,190,165],
[161,152,179,157,141,0,165,137],
[166,138,158,152,151,176,0,155],
[181,165,189,166,176,204,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 160, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,170,161,163,169,167,171],
[161,0,175,170,151,158,155,149],
[171,166,0,178,161,143,173,174],
[180,171,163,0,148,172,155,174],
[178,190,180,193,0,177,164,170],
[172,183,198,169,164,0,178,169],
[174,186,168,186,177,163,0,177],
[170,192,167,167,171,172,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 161, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,125,145,162,151,143,145,134],
[216,0,191,190,180,166,193,154],
[196,150,0,165,167,163,169,164],
[179,151,176,0,169,164,173,164],
[190,161,174,172,0,190,179,157],
[198,175,178,177,151,0,200,174],
[196,148,172,168,162,141,0,158],
[207,187,177,177,184,167,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 162, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,204,172,192,183,196,165,171],
[137,0,149,180,148,179,162,159],
[169,192,0,184,177,211,160,180],
[149,161,157,0,166,185,165,156],
[158,193,164,175,0,206,185,178],
[145,162,130,156,135,0,141,140],
[176,179,181,176,156,200,0,184],
[170,182,161,185,163,201,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 163, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,167,155,196,177,175,205],
[150,0,171,156,167,172,164,189],
[174,170,0,154,156,168,167,194],
[186,185,187,0,188,168,177,175],
[145,174,185,153,0,185,169,204],
[164,169,173,173,156,0,164,199],
[166,177,174,164,172,177,0,179],
[136,152,147,166,137,142,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 164, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,156,161,155,176,163,164],
[184,0,169,177,162,190,192,187],
[185,172,0,158,166,173,165,176],
[180,164,183,0,175,196,190,175],
[186,179,175,166,0,188,169,182],
[165,151,168,145,153,0,156,169],
[178,149,176,151,172,185,0,172],
[177,154,165,166,159,172,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 165, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,172,180,162,175,162,151],
[175,0,168,154,161,169,184,154],
[169,173,0,173,181,173,169,163],
[161,187,168,0,188,160,183,147],
[179,180,160,153,0,183,159,172],
[166,172,168,181,158,0,157,182],
[179,157,172,158,182,184,0,176],
[190,187,178,194,169,159,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 166, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,136,120,166,175,113,167],
[189,0,140,148,186,193,181,171],
[205,201,0,179,128,180,162,160],
[221,193,162,0,180,168,191,180],
[175,155,213,161,0,166,160,169],
[166,148,161,173,175,0,160,166],
[228,160,179,150,181,181,0,231],
[174,170,181,161,172,175,110,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 167, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,161,145,136,151,167,145],
[186,0,175,171,166,167,166,154],
[180,166,0,162,159,162,161,166],
[196,170,179,0,182,178,181,170],
[205,175,182,159,0,170,170,171],
[190,174,179,163,171,0,173,170],
[174,175,180,160,171,168,0,172],
[196,187,175,171,170,171,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 168, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,179,171,188,160,167,184],
[169,0,173,157,175,159,180,168],
[162,168,0,156,179,173,160,172],
[170,184,185,0,190,157,183,170],
[153,166,162,151,0,151,162,156],
[181,182,168,184,190,0,166,169],
[174,161,181,158,179,175,0,172],
[157,173,169,171,185,172,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 169, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,167,164,162,160,168,159],
[183,0,176,172,170,163,166,181],
[174,165,0,190,170,172,175,172],
[177,169,151,0,172,161,169,170],
[179,171,171,169,0,164,170,175],
[181,178,169,180,177,0,184,176],
[173,175,166,172,171,157,0,162],
[182,160,169,171,166,165,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 170, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,172,178,178,166,174,168],
[162,0,170,167,162,155,156,161],
[169,171,0,172,169,174,144,180],
[163,174,169,0,159,162,158,158],
[163,179,172,182,0,180,157,167],
[175,186,167,179,161,0,157,168],
[167,185,197,183,184,184,0,177],
[173,180,161,183,174,173,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 171, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,150,166,156,144,158,144,154],
[191,0,162,161,165,178,146,153],
[175,179,0,160,160,182,163,169],
[185,180,181,0,158,186,167,175],
[197,176,181,183,0,194,186,168],
[183,163,159,155,147,0,151,152],
[197,195,178,174,155,190,0,169],
[187,188,172,166,173,189,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 172, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,156,165,173,162,168,161],
[181,0,173,155,176,170,180,167],
[185,168,0,173,178,179,193,190],
[176,186,168,0,184,172,188,172],
[168,165,163,157,0,160,160,154],
[179,171,162,169,181,0,186,175],
[173,161,148,153,181,155,0,179],
[180,174,151,169,187,166,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 173, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,164,165,156,176,171,154],
[164,0,168,157,170,183,156,157],
[177,173,0,171,176,197,168,156],
[176,184,170,0,161,195,185,175],
[185,171,165,180,0,192,169,157],
[165,158,144,146,149,0,151,155],
[170,185,173,156,172,190,0,165],
[187,184,185,166,184,186,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 174, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,193,215,201,166,146,162],
[180,0,203,169,209,171,151,179],
[148,138,0,178,180,148,129,145],
[126,172,163,0,176,142,142,147],
[140,132,161,165,0,130,133,127],
[175,170,193,199,211,0,173,161],
[195,190,212,199,208,168,0,203],
[179,162,196,194,214,180,138,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 175, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,173,181,191,207,146,106],
[165,0,170,202,164,168,136,125],
[168,171,0,145,163,163,134,126],
[160,139,196,0,176,197,184,161],
[150,177,178,165,0,184,129,118],
[134,173,178,144,157,0,145,173],
[195,205,207,157,212,196,0,163],
[235,216,215,180,223,168,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 176, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,161,163,171,168,169,166],
[157,0,180,177,176,162,171,175],
[180,161,0,160,161,162,169,182],
[178,164,181,0,162,173,174,171],
[170,165,180,179,0,172,172,171],
[173,179,179,168,169,0,188,169],
[172,170,172,167,169,153,0,162],
[175,166,159,170,170,172,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 177, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,147,197,166,164,163,155,163],
[194,0,192,186,168,177,179,196],
[144,149,0,164,160,142,153,157],
[175,155,177,0,160,162,163,155],
[177,173,181,181,0,161,163,171],
[178,164,199,179,180,0,181,177],
[186,162,188,178,178,160,0,179],
[178,145,184,186,170,164,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 178, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,163,168,183,186,159,165],
[173,0,162,166,147,198,169,171],
[178,179,0,180,157,180,173,184],
[173,175,161,0,158,165,167,180],
[158,194,184,183,0,192,165,175],
[155,143,161,176,149,0,154,174],
[182,172,168,174,176,187,0,176],
[176,170,157,161,166,167,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 179, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,132,165,129,147,161,136],
[190,0,171,177,174,179,193,155],
[209,170,0,194,178,182,180,189],
[176,164,147,0,167,186,178,145],
[212,167,163,174,0,189,185,154],
[194,162,159,155,152,0,155,167],
[180,148,161,163,156,186,0,156],
[205,186,152,196,187,174,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 180, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,200,194,155,230,179,179],
[161,0,213,186,152,195,171,186],
[141,128,0,134,176,198,194,135],
[147,155,207,0,161,215,142,170],
[186,189,165,180,0,181,194,172],
[111,146,143,126,160,0,165,150],
[162,170,147,199,147,176,0,192],
[162,155,206,171,169,191,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 181, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,157,168,180,167,166,162],
[168,0,171,157,197,172,163,161],
[184,170,0,169,193,173,170,174],
[173,184,172,0,190,175,166,158],
[161,144,148,151,0,158,149,155],
[174,169,168,166,183,0,165,168],
[175,178,171,175,192,176,0,157],
[179,180,167,183,186,173,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 182, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,155,130,172,158,167,152],
[180,0,157,140,179,159,172,151],
[186,184,0,150,186,186,188,149],
[211,201,191,0,200,200,186,170],
[169,162,155,141,0,165,154,157],
[183,182,155,141,176,0,185,157],
[174,169,153,155,187,156,0,172],
[189,190,192,171,184,184,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 183, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,194,149,168,175,171,145,141],
[147,0,145,145,159,180,130,140],
[192,196,0,161,171,200,178,160],
[173,196,180,0,195,197,167,151],
[166,182,170,146,0,148,132,124],
[170,161,141,144,193,0,129,132],
[196,211,163,174,209,212,0,173],
[200,201,181,190,217,209,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 184, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,160,173,167,162,176,183],
[169,0,173,172,175,165,162,198],
[181,168,0,169,169,174,172,174],
[168,169,172,0,169,168,157,174],
[174,166,172,172,0,158,147,172],
[179,176,167,173,183,0,163,176],
[165,179,169,184,194,178,0,172],
[158,143,167,167,169,165,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 185, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,165,156,178,175,153,157],
[170,0,157,162,186,165,157,152],
[176,184,0,172,180,169,145,167],
[185,179,169,0,187,187,176,173],
[163,155,161,154,0,161,159,153],
[166,176,172,154,180,0,158,166],
[188,184,196,165,182,183,0,175],
[184,189,174,168,188,175,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 186, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,167,172,171,167,179,182],
[157,0,161,174,166,157,180,170],
[174,180,0,181,170,171,182,173],
[169,167,160,0,164,152,169,170],
[170,175,171,177,0,164,176,176],
[174,184,170,189,177,0,171,185],
[162,161,159,172,165,170,0,172],
[159,171,168,171,165,156,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 187, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,171,186,171,175,158,188],
[173,0,142,169,195,162,172,188],
[170,199,0,188,168,187,149,171],
[155,172,153,0,177,160,140,154],
[170,146,173,164,0,177,160,161],
[166,179,154,181,164,0,156,158],
[183,169,192,201,181,185,0,187],
[153,153,170,187,180,183,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 188, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,145,167,170,155,161,154],
[189,0,180,170,185,176,161,168],
[196,161,0,176,186,176,165,184],
[174,171,165,0,178,172,176,175],
[171,156,155,163,0,161,167,158],
[186,165,165,169,180,0,167,162],
[180,180,176,165,174,174,0,165],
[187,173,157,166,183,179,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 189, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,176,182,189,167,188,161],
[182,0,179,201,168,164,194,165],
[165,162,0,181,166,176,185,155],
[159,140,160,0,182,148,169,162],
[152,173,175,159,0,147,160,156],
[174,177,165,193,194,0,174,170],
[153,147,156,172,181,167,0,174],
[180,176,186,179,185,171,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 190, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,177,183,175,180,180,182],
[178,0,156,176,171,170,164,172],
[164,185,0,171,174,174,176,173],
[158,165,170,0,170,158,159,159],
[166,170,167,171,0,185,165,160],
[161,171,167,183,156,0,164,158],
[161,177,165,182,176,177,0,165],
[159,169,168,182,181,183,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 191, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,184,179,164,181,159,205],
[170,0,176,179,155,168,169,175],
[157,165,0,180,162,166,157,177],
[162,162,161,0,150,164,152,173],
[177,186,179,191,0,167,168,186],
[160,173,175,177,174,0,174,190],
[182,172,184,189,173,167,0,198],
[136,166,164,168,155,151,143,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 192, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,154,158,207,150,169,158],
[153,0,163,164,193,192,175,190],
[187,178,0,179,168,160,178,165],
[183,177,162,0,195,167,188,145],
[134,148,173,146,0,164,157,150],
[191,149,181,174,177,0,155,155],
[172,166,163,153,184,186,0,147],
[183,151,176,196,191,186,194,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 193, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,202,148,184,164,158,193],
[172,0,196,174,191,162,173,194],
[139,145,0,144,169,150,138,171],
[193,167,197,0,196,181,160,189],
[157,150,172,145,0,144,150,175],
[177,179,191,160,197,0,156,203],
[183,168,203,181,191,185,0,188],
[148,147,170,152,166,138,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 194, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,167,168,186,172,156,174],
[166,0,175,179,182,179,169,181],
[174,166,0,182,179,183,171,187],
[173,162,159,0,184,166,169,176],
[155,159,162,157,0,173,155,179],
[169,162,158,175,168,0,153,171],
[185,172,170,172,186,188,0,186],
[167,160,154,165,162,170,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 195, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,217,196,158,195,167,180,165],
[124,0,183,137,201,184,142,158],
[145,158,0,173,166,183,178,194],
[183,204,168,0,206,136,191,160],
[146,140,175,135,0,145,171,131],
[174,157,158,205,196,0,185,172],
[161,199,163,150,170,156,0,156],
[176,183,147,181,210,169,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 196, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,171,162,173,153,171,161],
[155,0,148,154,146,141,154,152],
[170,193,0,168,180,172,179,167],
[179,187,173,0,165,178,176,164],
[168,195,161,176,0,184,164,174],
[188,200,169,163,157,0,176,156],
[170,187,162,165,177,165,0,178],
[180,189,174,177,167,185,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 197, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,164,172,172,169,178,174],
[166,0,162,167,156,162,168,162],
[177,179,0,174,162,164,178,170],
[169,174,167,0,172,174,172,167],
[169,185,179,169,0,169,183,168],
[172,179,177,167,172,0,174,170],
[163,173,163,169,158,167,0,156],
[167,179,171,174,173,171,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 198, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,171,158,178,164,160,173],
[173,0,171,175,174,169,165,177],
[170,170,0,172,177,174,161,193],
[183,166,169,0,183,179,173,178],
[163,167,164,158,0,162,156,169],
[177,172,167,162,179,0,152,170],
[181,176,180,168,185,189,0,180],
[168,164,148,163,172,171,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 199, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,146,160,163,132,153,157],
[190,0,122,123,194,150,131,178],
[195,219,0,165,207,149,178,190],
[181,218,176,0,175,154,145,155],
[178,147,134,166,0,156,144,155],
[209,191,192,187,185,0,163,187],
[188,210,163,196,197,178,0,171],
[184,163,151,186,186,154,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 200, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,200,171,196,191,171,175,170],
[141,0,178,163,159,155,168,169],
[170,163,0,172,163,161,165,171],
[145,178,169,0,152,161,167,160],
[150,182,178,189,0,176,174,188],
[170,186,180,180,165,0,163,181],
[166,173,176,174,167,178,0,175],
[171,172,170,181,153,160,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 201, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,193,174,175,161,159,181],
[172,0,195,172,169,181,164,159],
[148,146,0,164,167,149,161,161],
[167,169,177,0,180,175,187,171],
[166,172,174,161,0,165,170,179],
[180,160,192,166,176,0,176,177],
[182,177,180,154,171,165,0,164],
[160,182,180,170,162,164,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 202, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,160,176,160,166,158,183],
[186,0,177,156,175,179,166,188],
[181,164,0,156,158,151,164,167],
[165,185,185,0,179,173,194,195],
[181,166,183,162,0,182,183,187],
[175,162,190,168,159,0,183,195],
[183,175,177,147,158,158,0,183],
[158,153,174,146,154,146,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 203, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,145,164,160,163,158,164],
[170,0,175,203,162,171,174,179],
[196,166,0,178,171,165,180,160],
[177,138,163,0,155,158,166,149],
[181,179,170,186,0,176,166,146],
[178,170,176,183,165,0,186,178],
[183,167,161,175,175,155,0,181],
[177,162,181,192,195,163,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 204, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,148,165,160,163,158,148],
[179,0,159,176,169,178,177,169],
[193,182,0,191,170,201,168,176],
[176,165,150,0,171,168,169,159],
[181,172,171,170,0,179,173,159],
[178,163,140,173,162,0,158,155],
[183,164,173,172,168,183,0,165],
[193,172,165,182,182,186,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 205, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,150,168,160,160,157,153,168],
[191,0,171,172,180,164,170,166],
[173,170,0,162,164,159,161,167],
[181,169,179,0,179,171,179,178],
[181,161,177,162,0,172,173,170],
[184,177,182,170,169,0,175,171],
[188,171,180,162,168,166,0,177],
[173,175,174,163,171,170,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 206, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,171,172,168,184,179,172],
[164,0,166,172,175,181,179,162],
[170,175,0,177,164,187,169,166],
[169,169,164,0,179,182,166,164],
[173,166,177,162,0,191,164,169],
[157,160,154,159,150,0,164,168],
[162,162,172,175,177,177,0,170],
[169,179,175,177,172,173,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 207, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,197,187,193,200,179,153],
[173,0,172,199,158,199,169,171],
[144,169,0,146,154,162,131,122],
[154,142,195,0,131,177,149,116],
[148,183,187,210,0,173,159,130],
[141,142,179,164,168,0,119,104],
[162,172,210,192,182,222,0,162],
[188,170,219,225,211,237,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 208, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,169,158,166,182,168,174],
[180,0,186,169,187,182,181,182],
[172,155,0,157,165,170,168,164],
[183,172,184,0,177,186,169,172],
[175,154,176,164,0,190,173,179],
[159,159,171,155,151,0,144,162],
[173,160,173,172,168,197,0,177],
[167,159,177,169,162,179,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 209, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,172,175,200,176,167,176],
[173,0,157,157,177,158,161,156],
[169,184,0,168,193,178,162,171],
[166,184,173,0,186,168,158,175],
[141,164,148,155,0,154,144,150],
[165,183,163,173,187,0,171,186],
[174,180,179,183,197,170,0,194],
[165,185,170,166,191,155,147,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 210, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,167,158,174,169,184,170],
[189,0,173,166,181,170,183,174],
[174,168,0,163,168,163,167,168],
[183,175,178,0,179,170,187,181],
[167,160,173,162,0,167,180,163],
[172,171,178,171,174,0,178,164],
[157,158,174,154,161,163,0,158],
[171,167,173,160,178,177,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 211, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,191,172,174,168,190,184],
[154,0,159,162,159,147,157,155],
[150,182,0,185,195,143,179,173],
[169,179,156,0,171,147,151,197],
[167,182,146,170,0,151,155,187],
[173,194,198,194,190,0,168,177],
[151,184,162,190,186,173,0,174],
[157,186,168,144,154,164,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 212, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,166,167,163,185,184,172],
[174,0,170,172,175,178,182,186],
[175,171,0,179,183,175,186,166],
[174,169,162,0,177,178,185,167],
[178,166,158,164,0,179,184,182],
[156,163,166,163,162,0,171,166],
[157,159,155,156,157,170,0,172],
[169,155,175,174,159,175,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 213, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,163,154,172,151,179,163],
[174,0,182,161,170,164,164,174],
[178,159,0,168,166,171,180,167],
[187,180,173,0,175,162,173,175],
[169,171,175,166,0,157,170,170],
[190,177,170,179,184,0,191,176],
[162,177,161,168,171,150,0,172],
[178,167,174,166,171,165,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 214, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,164,163,158,168,178,163],
[179,0,166,175,171,184,177,170],
[177,175,0,169,174,182,188,171],
[178,166,172,0,167,180,176,181],
[183,170,167,174,0,198,176,167],
[173,157,159,161,143,0,182,154],
[163,164,153,165,165,159,0,164],
[178,171,170,160,174,187,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 215, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,179,163,184,189,170,189],
[174,0,168,177,173,191,175,177],
[162,173,0,157,166,178,169,181],
[178,164,184,0,169,188,174,189],
[157,168,175,172,0,182,163,185],
[152,150,163,153,159,0,152,159],
[171,166,172,167,178,189,0,181],
[152,164,160,152,156,182,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 216, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,148,175,165,146,160,147],
[189,0,176,197,182,162,164,171],
[193,165,0,186,202,164,179,166],
[166,144,155,0,171,132,153,139],
[176,159,139,170,0,166,166,159],
[195,179,177,209,175,0,175,160],
[181,177,162,188,175,166,0,158],
[194,170,175,202,182,181,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 217, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,185,165,185,179,173,179],
[171,0,194,175,199,184,166,168],
[156,147,0,147,176,156,151,172],
[176,166,194,0,189,172,161,164],
[156,142,165,152,0,162,144,163],
[162,157,185,169,179,0,162,171],
[168,175,190,180,197,179,0,188],
[162,173,169,177,178,170,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 218, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,196,183,173,168,182,175,181],
[145,0,171,146,165,170,168,164],
[158,170,0,164,168,174,169,167],
[168,195,177,0,171,176,188,182],
[173,176,173,170,0,177,187,166],
[159,171,167,165,164,0,177,171],
[166,173,172,153,154,164,0,167],
[160,177,174,159,175,170,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 219, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,178,170,169,173,172,159],
[158,0,164,174,175,179,174,158],
[163,177,0,181,159,169,164,156],
[171,167,160,0,171,174,170,152],
[172,166,182,170,0,177,165,161],
[168,162,172,167,164,0,154,183],
[169,167,177,171,176,187,0,185],
[182,183,185,189,180,158,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 220, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,162,149,166,164,156,178],
[178,0,169,176,177,155,157,194],
[179,172,0,152,167,168,138,181],
[192,165,189,0,183,167,177,190],
[175,164,174,158,0,157,150,167],
[177,186,173,174,184,0,161,189],
[185,184,203,164,191,180,0,207],
[163,147,160,151,174,152,134,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 221, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,165,183,142,191,169,188],
[162,0,199,199,175,166,162,175],
[176,142,0,197,144,175,158,167],
[158,142,144,0,147,152,165,158],
[199,166,197,194,0,191,170,180],
[150,175,166,189,150,0,181,167],
[172,179,183,176,171,160,0,189],
[153,166,174,183,161,174,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 222, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,201,177,187,166,178,194,177],
[140,0,161,169,164,144,165,149],
[164,180,0,168,153,162,162,144],
[154,172,173,0,169,169,176,166],
[175,177,188,172,0,155,167,167],
[163,197,179,172,186,0,177,167],
[147,176,179,165,174,164,0,156],
[164,192,197,175,174,174,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 223, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,169,163,177,176,160,168],
[174,0,170,165,179,184,167,176],
[172,171,0,172,178,160,177,151],
[178,176,169,0,168,174,186,158],
[164,162,163,173,0,179,167,154],
[165,157,181,167,162,0,179,155],
[181,174,164,155,174,162,0,163],
[173,165,190,183,187,186,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 224, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,143,155,139,124,163,171,148],
[198,0,161,176,163,184,167,160],
[186,180,0,167,168,205,188,189],
[202,165,174,0,186,188,188,177],
[217,178,173,155,0,191,184,181],
[178,157,136,153,150,0,147,142],
[170,174,153,153,157,194,0,142],
[193,181,152,164,160,199,199,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 225, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,168,141,166,158,188,150],
[176,0,172,160,169,169,186,147],
[173,169,0,181,179,177,182,145],
[200,181,160,0,193,173,197,181],
[175,172,162,148,0,161,168,141],
[183,172,164,168,180,0,190,151],
[153,155,159,144,173,151,0,128],
[191,194,196,160,200,190,213,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 226, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,168,161,188,165,184,179],
[164,0,160,186,168,145,185,185],
[173,181,0,190,159,172,188,184],
[180,155,151,0,150,147,185,180],
[153,173,182,191,0,172,199,185],
[176,196,169,194,169,0,189,196],
[157,156,153,156,142,152,0,190],
[162,156,157,161,156,145,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 227, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,182,184,199,174,190,193],
[172,0,170,183,192,187,178,195],
[159,171,0,168,187,175,163,173],
[157,158,173,0,176,165,164,173],
[142,149,154,165,0,159,167,167],
[167,154,166,176,182,0,172,182],
[151,163,178,177,174,169,0,173],
[148,146,168,168,174,159,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 228, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,173,171,172,169,192,176],
[165,0,186,155,158,161,190,164],
[168,155,0,178,162,178,188,165],
[170,186,163,0,181,175,200,182],
[169,183,179,160,0,174,208,174],
[172,180,163,166,167,0,214,180],
[149,151,153,141,133,127,0,142],
[165,177,176,159,167,161,199,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 229, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,164,197,177,185,188,192],
[183,0,173,196,178,170,198,191],
[177,168,0,206,165,179,195,195],
[144,145,135,0,142,153,161,160],
[164,163,176,199,0,179,200,192],
[156,171,162,188,162,0,197,192],
[153,143,146,180,141,144,0,162],
[149,150,146,181,149,149,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 230, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,165,169,164,158,169,171],
[181,0,179,166,176,167,175,171],
[176,162,0,170,163,179,174,173],
[172,175,171,0,161,166,164,175],
[177,165,178,180,0,173,169,177],
[183,174,162,175,168,0,166,172],
[172,166,167,177,172,175,0,179],
[170,170,168,166,164,169,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 231, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,199,189,182,180,188,169,198],
[142,0,152,151,185,170,157,173],
[152,189,0,152,186,179,188,180],
[159,190,189,0,181,165,190,187],
[161,156,155,160,0,154,169,168],
[153,171,162,176,187,0,166,187],
[172,184,153,151,172,175,0,182],
[143,168,161,154,173,154,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 232, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,170,190,203,169,190,193],
[183,0,180,163,179,194,186,188],
[171,161,0,159,164,141,185,167],
[151,178,182,0,190,195,159,174],
[138,162,177,151,0,187,177,149],
[172,147,200,146,154,0,182,176],
[151,155,156,182,164,159,0,182],
[148,153,174,167,192,165,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 233, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,167,160,174,157,168,157],
[184,0,200,159,202,187,184,180],
[174,141,0,162,163,170,185,162],
[181,182,179,0,170,184,180,179],
[167,139,178,171,0,169,176,166],
[184,154,171,157,172,0,165,169],
[173,157,156,161,165,176,0,175],
[184,161,179,162,175,172,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 234, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,148,165,168,179,159,163,157],
[193,0,176,176,181,168,180,172],
[176,165,0,171,173,164,174,159],
[173,165,170,0,172,160,174,153],
[162,160,168,169,0,151,161,164],
[182,173,177,181,190,0,176,168],
[178,161,167,167,180,165,0,165],
[184,169,182,188,177,173,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 235, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,173,172,173,164,177,163],
[180,0,150,182,145,170,161,194],
[168,191,0,178,176,192,188,178],
[169,159,163,0,180,173,194,176],
[168,196,165,161,0,181,200,161],
[177,171,149,168,160,0,173,173],
[164,180,153,147,141,168,0,167],
[178,147,163,165,180,168,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 236, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,194,198,161,195,182,186],
[168,0,172,194,154,159,172,184],
[147,169,0,167,172,173,153,168],
[143,147,174,0,158,158,167,174],
[180,187,169,183,0,164,166,204],
[146,182,168,183,177,0,162,171],
[159,169,188,174,175,179,0,184],
[155,157,173,167,137,170,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 237, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,186,189,173,168,171,193],
[156,0,171,182,159,174,158,178],
[155,170,0,183,160,168,176,186],
[152,159,158,0,150,162,146,169],
[168,182,181,191,0,186,171,199],
[173,167,173,179,155,0,160,166],
[170,183,165,195,170,181,0,196],
[148,163,155,172,142,175,145,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 238, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,160,175,158,171,169,166],
[175,0,168,170,197,168,145,153],
[181,173,0,175,162,188,162,169],
[166,171,166,0,158,189,165,172],
[183,144,179,183,0,183,165,158],
[170,173,153,152,158,0,156,162],
[172,196,179,176,176,185,0,167],
[175,188,172,169,183,179,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 239, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,188,170,183,176,176,168],
[166,0,189,177,176,177,173,176],
[153,152,0,169,165,167,150,158],
[171,164,172,0,178,173,175,164],
[158,165,176,163,0,167,167,162],
[165,164,174,168,174,0,174,167],
[165,168,191,166,174,167,0,167],
[173,165,183,177,179,174,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 240, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,164,164,172,193,161,164],
[167,0,166,183,164,177,166,171],
[177,175,0,159,175,181,167,189],
[177,158,182,0,172,192,174,177],
[169,177,166,169,0,162,177,178],
[148,164,160,149,179,0,162,162],
[180,175,174,167,164,179,0,172],
[177,170,152,164,163,179,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 241, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,168,175,185,162,163,169],
[177,0,162,187,197,172,177,165],
[173,179,0,169,170,183,187,161],
[166,154,172,0,171,177,173,175],
[156,144,171,170,0,150,171,131],
[179,169,158,164,191,0,169,175],
[178,164,154,168,170,172,0,159],
[172,176,180,166,210,166,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 242, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,208,180,184,182,188,165],
[161,0,199,175,184,167,165,157],
[133,142,0,153,154,156,178,135],
[161,166,188,0,163,159,165,176],
[157,157,187,178,0,167,182,160],
[159,174,185,182,174,0,166,160],
[153,176,163,176,159,175,0,167],
[176,184,206,165,181,181,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 243, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,194,175,162,175,180,170,163],
[147,0,141,139,122,155,148,159],
[166,200,0,157,162,177,177,179],
[179,202,184,0,161,181,171,167],
[166,219,179,180,0,190,191,182],
[161,186,164,160,151,0,170,166],
[171,193,164,170,150,171,0,178],
[178,182,162,174,159,175,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 244, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,181,177,169,171,165,162],
[163,0,172,174,168,160,169,165],
[160,169,0,177,166,158,162,167],
[164,167,164,0,152,162,155,166],
[172,173,175,189,0,177,180,162],
[170,181,183,179,164,0,171,159],
[176,172,179,186,161,170,0,171],
[179,176,174,175,179,182,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 245, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,126,155,147,189,151,168,134],
[215,0,167,195,180,136,160,160],
[186,174,0,150,189,113,181,162],
[194,146,191,0,164,134,202,136],
[152,161,152,177,0,127,189,169],
[190,205,228,207,214,0,200,142],
[173,181,160,139,152,141,0,183],
[207,181,179,205,172,199,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 246, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,165,170,175,168,180,169],
[162,0,181,155,173,163,185,161],
[176,160,0,184,182,169,183,158],
[171,186,157,0,178,178,172,182],
[166,168,159,163,0,166,158,164],
[173,178,172,163,175,0,178,172],
[161,156,158,169,183,163,0,161],
[172,180,183,159,177,169,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 247, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,179,172,176,168,171,168],
[179,0,181,185,175,181,183,159],
[162,160,0,170,185,162,164,183],
[169,156,171,0,165,168,162,165],
[165,166,156,176,0,166,162,164],
[173,160,179,173,175,0,171,168],
[170,158,177,179,179,170,0,170],
[173,182,158,176,177,173,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 248, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,147,172,162,151,148,162],
[181,0,163,162,153,166,153,169],
[194,178,0,171,165,169,173,173],
[169,179,170,0,156,182,168,175],
[179,188,176,185,0,181,170,182],
[190,175,172,159,160,0,164,183],
[193,188,168,173,171,177,0,184],
[179,172,168,166,159,158,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 249, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,164,171,147,167,144,160],
[189,0,165,186,170,186,169,186],
[177,176,0,189,174,186,169,180],
[170,155,152,0,161,150,150,177],
[194,171,167,180,0,183,171,162],
[174,155,155,191,158,0,152,170],
[197,172,172,191,170,189,0,179],
[181,155,161,164,179,171,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 250, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,193,174,188,170,161,169,172],
[148,0,158,173,159,155,147,161],
[167,183,0,179,179,160,167,165],
[153,168,162,0,165,145,159,156],
[171,182,162,176,0,170,172,160],
[180,186,181,196,171,0,168,180],
[172,194,174,182,169,173,0,186],
[169,180,176,185,181,161,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 251, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,184,176,140,161,185,140],
[168,0,139,154,138,151,150,141],
[157,202,0,156,151,168,149,160],
[165,187,185,0,171,168,174,188],
[201,203,190,170,0,181,165,160],
[180,190,173,173,160,0,163,174],
[156,191,192,167,176,178,0,163],
[201,200,181,153,181,167,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 252, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,173,169,178,177,183,178],
[172,0,168,177,191,191,180,174],
[168,173,0,166,183,192,190,176],
[172,164,175,0,200,191,190,181],
[163,150,158,141,0,177,167,165],
[164,150,149,150,164,0,160,154],
[158,161,151,151,174,181,0,162],
[163,167,165,160,176,187,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 253, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,258,173,200,144,258,173,86],
[83,0,144,20,22,207,112,22],
[168,197,0,136,107,258,197,22],
[141,321,205,0,205,319,170,205],
[197,319,234,136,0,319,235,83],
[83,134,83,22,22,0,134,83],
[168,229,144,171,106,207,0,86],
[255,319,319,136,258,258,255,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 254, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,179,216,177,176,183,161],
[176,0,178,194,184,161,174,167],
[162,163,0,190,158,137,156,144],
[125,147,151,0,144,150,140,132],
[164,157,183,197,0,165,166,155],
[165,180,204,191,176,0,176,152],
[158,167,185,201,175,165,0,180],
[180,174,197,209,186,189,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 255, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,173,159,155,154,174,177],
[182,0,181,168,173,165,195,185],
[168,160,0,174,159,162,192,170],
[182,173,167,0,169,170,194,179],
[186,168,182,172,0,179,192,183],
[187,176,179,171,162,0,199,173],
[167,146,149,147,149,142,0,152],
[164,156,171,162,158,168,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 256, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,108,135,175,173,144,167,166],
[233,0,221,240,238,148,270,184],
[206,120,0,187,148,156,97,127],
[166,101,154,0,184,157,126,132],
[168,103,193,157,0,122,147,97],
[197,193,185,184,219,0,155,123],
[174,71,244,215,194,186,0,128],
[175,157,214,209,244,218,213,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 257, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,145,137,199,136,151,164,200],
[196,0,177,172,145,188,168,194],
[204,164,0,180,160,151,177,236],
[142,169,161,0,142,148,175,196],
[205,196,181,199,0,167,207,174],
[190,153,190,193,174,0,168,234],
[177,173,164,166,134,173,0,200],
[141,147,105,145,167,107,141,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 258, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,201,201,196,207,165,184,180],
[140,0,166,166,168,141,165,158],
[140,175,0,175,184,155,168,161],
[145,175,166,0,211,157,171,169],
[134,173,157,130,0,161,158,161],
[176,200,186,184,180,0,178,165],
[157,176,173,170,183,163,0,157],
[161,183,180,172,180,176,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 259, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,165,191,175,189,192,200],
[180,0,165,183,174,202,219,190],
[176,176,0,192,158,210,198,189],
[150,158,149,0,147,183,166,164],
[166,167,183,194,0,172,151,195],
[152,139,131,158,169,0,158,177],
[149,122,143,175,190,183,0,187],
[141,151,152,177,146,164,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 260, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,178,167,173,172,173,179],
[184,0,195,200,197,180,168,193],
[163,146,0,161,172,162,170,163],
[174,141,180,0,183,153,153,158],
[168,144,169,158,0,156,141,157],
[169,161,179,188,185,0,168,178],
[168,173,171,188,200,173,0,192],
[162,148,178,183,184,163,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 261, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,182,180,176,175,182,164],
[168,0,179,168,174,183,178,162],
[159,162,0,178,151,167,167,172],
[161,173,163,0,157,157,165,152],
[165,167,190,184,0,181,179,165],
[166,158,174,184,160,0,170,172],
[159,163,174,176,162,171,0,164],
[177,179,169,189,176,169,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 262, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,177,163,163,165,154,170],
[154,0,183,156,160,185,149,146],
[164,158,0,175,168,185,176,165],
[178,185,166,0,193,187,176,160],
[178,181,173,148,0,168,172,178],
[176,156,156,154,173,0,164,164],
[187,192,165,165,169,177,0,171],
[171,195,176,181,163,177,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 263, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,180,180,185,159,190,177],
[170,0,163,166,188,171,167,163],
[161,178,0,162,173,142,182,163],
[161,175,179,0,190,148,160,163],
[156,153,168,151,0,148,169,162],
[182,170,199,193,193,0,203,178],
[151,174,159,181,172,138,0,165],
[164,178,178,178,179,163,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 264, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,179,184,168,154,156,172],
[176,0,175,171,155,151,144,175],
[162,166,0,174,143,157,147,182],
[157,170,167,0,148,154,170,159],
[173,186,198,193,0,186,170,190],
[187,190,184,187,155,0,178,206],
[185,197,194,171,171,163,0,179],
[169,166,159,182,151,135,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 265, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,140,172,185,159,187,186],
[185,0,166,200,200,207,182,191],
[201,175,0,195,186,180,167,172],
[169,141,146,0,188,146,175,178],
[156,141,155,153,0,148,193,163],
[182,134,161,195,193,0,168,166],
[154,159,174,166,148,173,0,187],
[155,150,169,163,178,175,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 266, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,185,181,166,180,160,186],
[149,0,174,143,135,153,142,156],
[156,167,0,141,167,155,149,161],
[160,198,200,0,164,179,152,165],
[175,206,174,177,0,162,151,146],
[161,188,186,162,179,0,141,167],
[181,199,192,189,190,200,0,162],
[155,185,180,176,195,174,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 267, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,184,186,185,165,168,166],
[169,0,184,186,174,144,165,164],
[157,157,0,198,167,164,158,157],
[155,155,143,0,170,156,168,173],
[156,167,174,171,0,171,184,174],
[176,197,177,185,170,0,180,175],
[173,176,183,173,157,161,0,163],
[175,177,184,168,167,166,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 268, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,171,174,179,180,164,167],
[171,0,192,163,185,182,172,178],
[170,149,0,168,178,168,167,162],
[167,178,173,0,166,183,167,162],
[162,156,163,175,0,180,158,162],
[161,159,173,158,161,0,164,158],
[177,169,174,174,183,177,0,172],
[174,163,179,179,179,183,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 269, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,175,175,161,162,172,174],
[177,0,176,180,164,175,184,174],
[166,165,0,176,160,172,171,182],
[166,161,165,0,156,164,162,173],
[180,177,181,185,0,168,188,188],
[179,166,169,177,173,0,182,175],
[169,157,170,179,153,159,0,175],
[167,167,159,168,153,166,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 270, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,175,177,165,173,178,168],
[162,0,172,133,133,148,167,165],
[166,169,0,166,182,157,163,163],
[164,208,175,0,193,186,180,170],
[176,208,159,148,0,168,164,165],
[168,193,184,155,173,0,163,174],
[163,174,178,161,177,178,0,186],
[173,176,178,171,176,167,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 271, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,172,175,169,181,159,186],
[150,0,154,148,158,168,155,158],
[169,187,0,181,165,184,163,174],
[166,193,160,0,163,176,171,185],
[172,183,176,178,0,161,166,162],
[160,173,157,165,180,0,158,179],
[182,186,178,170,175,183,0,164],
[155,183,167,156,179,162,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 272, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,171,155,169,177,142,163],
[173,0,175,164,196,186,165,159],
[170,166,0,154,197,180,145,153],
[186,177,187,0,188,186,171,169],
[172,145,144,153,0,164,149,141],
[164,155,161,155,177,0,150,152],
[199,176,196,170,192,191,0,172],
[178,182,188,172,200,189,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 273, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,186,189,180,171,164,186],
[152,0,169,170,159,163,156,176],
[155,172,0,174,175,153,161,161],
[152,171,167,0,166,163,159,173],
[161,182,166,175,0,163,171,173],
[170,178,188,178,178,0,165,181],
[177,185,180,182,170,176,0,185],
[155,165,180,168,168,160,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 274, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,194,188,166,185,190,197,201],
[147,0,157,164,146,173,158,180],
[153,184,0,174,156,158,179,197],
[175,177,167,0,168,192,172,181],
[156,195,185,173,0,173,180,179],
[151,168,183,149,168,0,175,154],
[144,183,162,169,161,166,0,168],
[140,161,144,160,162,187,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 275, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,135,206,185,136,162,157],
[167,0,138,214,201,140,209,198],
[206,203,0,219,183,175,202,152],
[135,127,122,0,143,146,100,113],
[156,140,158,198,0,131,173,161],
[205,201,166,195,210,0,154,190],
[179,132,139,241,168,187,0,156],
[184,143,189,228,180,151,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 276, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,175,193,164,176,190,180],
[174,0,172,173,161,175,170,166],
[166,169,0,153,178,175,174,148],
[148,168,188,0,152,165,187,181],
[177,180,163,189,0,204,167,158],
[165,166,166,176,137,0,172,167],
[151,171,167,154,174,169,0,159],
[161,175,193,160,183,174,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 277, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,179,181,165,180,181,184],
[149,0,174,172,163,171,133,173],
[162,167,0,167,150,168,149,181],
[160,169,174,0,162,173,165,175],
[176,178,191,179,0,155,166,193],
[161,170,173,168,186,0,157,180],
[160,208,192,176,175,184,0,195],
[157,168,160,166,148,161,146,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 278, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,171,151,165,158,171,166],
[188,0,171,161,184,169,166,167],
[170,170,0,149,165,170,161,163],
[190,180,192,0,182,159,179,171],
[176,157,176,159,0,181,157,162],
[183,172,171,182,160,0,169,165],
[170,175,180,162,184,172,0,174],
[175,174,178,170,179,176,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 279, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,143,175,169,179,160,151,157],
[198,0,193,169,190,183,177,181],
[166,148,0,153,181,166,147,136],
[172,172,188,0,178,167,157,161],
[162,151,160,163,0,165,151,165],
[181,158,175,174,176,0,174,161],
[190,164,194,184,190,167,0,168],
[184,160,205,180,176,180,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 280, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,184,177,171,168,172,174],
[160,0,181,178,156,173,176,161],
[157,160,0,162,148,169,162,161],
[164,163,179,0,164,178,159,174],
[170,185,193,177,0,184,185,178],
[173,168,172,163,157,0,179,170],
[169,165,179,182,156,162,0,169],
[167,180,180,167,163,171,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 281, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,174,171,180,172,162,175],
[179,0,168,180,175,170,177,185],
[167,173,0,191,159,172,182,177],
[170,161,150,0,159,163,171,170],
[161,166,182,182,0,167,191,170],
[169,171,169,178,174,0,168,175],
[179,164,159,170,150,173,0,163],
[166,156,164,171,171,166,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 282, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,185,176,164,196,180,196],
[169,0,171,175,178,177,188,168],
[156,170,0,182,157,178,179,182],
[165,166,159,0,154,179,174,147],
[177,163,184,187,0,177,199,164],
[145,164,163,162,164,0,153,161],
[161,153,162,167,142,188,0,178],
[145,173,159,194,177,180,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 283, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,161,174,167,168,173,175],
[173,0,154,174,166,163,152,173],
[180,187,0,174,164,170,180,182],
[167,167,167,0,158,160,166,164],
[174,175,177,183,0,169,174,175],
[173,178,171,181,172,0,167,179],
[168,189,161,175,167,174,0,182],
[166,168,159,177,166,162,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 284, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,171,185,179,172,173,169],
[171,0,164,174,161,166,176,169],
[170,177,0,187,169,167,193,163],
[156,167,154,0,155,168,177,157],
[162,180,172,186,0,176,180,177],
[169,175,174,173,165,0,175,157],
[168,165,148,164,161,166,0,158],
[172,172,178,184,164,184,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 285, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,155,170,152,157,163,161],
[181,0,156,169,163,166,170,172],
[186,185,0,181,171,163,177,172],
[171,172,160,0,157,164,172,179],
[189,178,170,184,0,176,187,188],
[184,175,178,177,165,0,182,183],
[178,171,164,169,154,159,0,159],
[180,169,169,162,153,158,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 286, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,172,154,176,163,176,182],
[161,0,187,152,182,179,176,186],
[169,154,0,158,167,153,157,163],
[187,189,183,0,168,177,188,169],
[165,159,174,173,0,159,185,167],
[178,162,188,164,182,0,166,195],
[165,165,184,153,156,175,0,179],
[159,155,178,172,174,146,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 287, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,171,173,169,171,172,173],
[168,0,172,158,171,159,156,182],
[170,169,0,178,180,155,179,162],
[168,183,163,0,162,162,168,175],
[172,170,161,179,0,165,180,177],
[170,182,186,179,176,0,182,177],
[169,185,162,173,161,159,0,164],
[168,159,179,166,164,164,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 288, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,196,160,147,184,187,192,163],
[145,0,186,158,189,185,204,156],
[181,155,0,172,197,211,189,140],
[194,183,169,0,200,206,209,172],
[157,152,144,141,0,190,202,130],
[154,156,130,135,151,0,175,111],
[149,137,152,132,139,166,0,131],
[178,185,201,169,211,230,210,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 289, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,202,187,174,187,172,182],
[176,0,163,194,171,175,181,182],
[139,178,0,185,181,169,163,172],
[154,147,156,0,167,157,151,161],
[167,170,160,174,0,163,162,170],
[154,166,172,184,178,0,174,150],
[169,160,178,190,179,167,0,177],
[159,159,169,180,171,191,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 290, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,173,146,176,198,162,180],
[177,0,153,174,181,202,179,167],
[168,188,0,181,179,210,174,184],
[195,167,160,0,179,175,169,137],
[165,160,162,162,0,180,157,145],
[143,139,131,166,161,0,148,123],
[179,162,167,172,184,193,0,184],
[161,174,157,204,196,218,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 291, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,174,170,179,174,159,162],
[161,0,159,172,177,165,160,157],
[167,182,0,187,181,179,180,178],
[171,169,154,0,174,139,158,156],
[162,164,160,167,0,155,160,169],
[167,176,162,202,186,0,171,170],
[182,181,161,183,181,170,0,180],
[179,184,163,185,172,171,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 292, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,194,177,208,198,182,192,162],
[147,0,181,175,178,167,186,151],
[164,160,0,200,177,166,182,176],
[133,166,141,0,156,143,166,152],
[143,163,164,185,0,164,178,171],
[159,174,175,198,177,0,189,156],
[149,155,159,175,163,152,0,155],
[179,190,165,189,170,185,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 293, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,163,165,132,144,159,172],
[184,0,178,187,161,184,155,171],
[178,163,0,160,166,171,182,191],
[176,154,181,0,178,177,165,160],
[209,180,175,163,0,179,171,172],
[197,157,170,164,162,0,167,171],
[182,186,159,176,170,174,0,172],
[169,170,150,181,169,170,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 294, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,177,168,169,189,171,183],
[170,0,173,171,188,194,174,178],
[164,168,0,175,177,190,191,178],
[173,170,166,0,189,180,181,187],
[172,153,164,152,0,172,163,181],
[152,147,151,161,169,0,162,172],
[170,167,150,160,178,179,0,182],
[158,163,163,154,160,169,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 295, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,170,183,180,177,170,175],
[172,0,178,186,166,182,175,183],
[171,163,0,169,172,159,173,177],
[158,155,172,0,177,171,173,170],
[161,175,169,164,0,162,164,163],
[164,159,182,170,179,0,167,176],
[171,166,168,168,177,174,0,173],
[166,158,164,171,178,165,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 296, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,166,162,168,173,162,173],
[180,0,174,178,175,178,167,179],
[175,167,0,169,188,176,171,187],
[179,163,172,0,186,152,177,176],
[173,166,153,155,0,159,173,162],
[168,163,165,189,182,0,176,175],
[179,174,170,164,168,165,0,162],
[168,162,154,165,179,166,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 297, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,161,187,181,193,182,171],
[169,0,171,176,184,168,156,185],
[180,170,0,201,193,197,186,176],
[154,165,140,0,187,160,163,157],
[160,157,148,154,0,153,151,149],
[148,173,144,181,188,0,177,165],
[159,185,155,178,190,164,0,175],
[170,156,165,184,192,176,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 298, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,169,177,159,160,161,150],
[178,0,161,177,172,182,174,173],
[172,180,0,181,170,151,173,162],
[164,164,160,0,152,149,160,146],
[182,169,171,189,0,168,163,172],
[181,159,190,192,173,0,158,154],
[180,167,168,181,178,183,0,167],
[191,168,179,195,169,187,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 299, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,194,192,205,199,203,163,202],
[147,0,165,173,153,176,173,179],
[149,176,0,180,167,201,145,172],
[136,168,161,0,170,161,149,172],
[142,188,174,171,0,193,156,190],
[138,165,140,180,148,0,166,153],
[178,168,196,192,185,175,0,186],
[139,162,169,169,151,188,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 300, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,166,195,134,171,210,184],
[185,0,199,207,146,160,196,203],
[175,142,0,191,159,138,208,181],
[146,134,150,0,116,147,177,152],
[207,195,182,225,0,154,194,229],
[170,181,203,194,187,0,196,198],
[131,145,133,164,147,145,0,157],
[157,138,160,189,112,143,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 301, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,168,140,151,159,167,153],
[166,0,159,157,142,154,163,172],
[173,182,0,173,173,156,172,187],
[201,184,168,0,184,179,202,176],
[190,199,168,157,0,170,182,171],
[182,187,185,162,171,0,187,175],
[174,178,169,139,159,154,0,161],
[188,169,154,165,170,166,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 302, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,172,177,184,162,177,167],
[150,0,160,148,179,167,180,156],
[169,181,0,164,188,174,193,173],
[164,193,177,0,195,175,178,171],
[157,162,153,146,0,168,176,167],
[179,174,167,166,173,0,178,179],
[164,161,148,163,165,163,0,159],
[174,185,168,170,174,162,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 303, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,180,174,211,201,144,164],
[173,0,163,154,179,201,152,180],
[161,178,0,165,196,195,177,178],
[167,187,176,0,194,182,149,172],
[130,162,145,147,0,190,141,155],
[140,140,146,159,151,0,130,163],
[197,189,164,192,200,211,0,189],
[177,161,163,169,186,178,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 304, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,169,169,164,182,174,156],
[179,0,178,183,166,169,176,162],
[172,163,0,172,168,181,173,178],
[172,158,169,0,161,167,160,150],
[177,175,173,180,0,185,176,164],
[159,172,160,174,156,0,172,157],
[167,165,168,181,165,169,0,158],
[185,179,163,191,177,184,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 305, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,161,161,150,185,156,157],
[179,0,183,177,174,173,178,151],
[180,158,0,168,159,174,193,157],
[180,164,173,0,159,168,174,161],
[191,167,182,182,0,162,191,157],
[156,168,167,173,179,0,178,174],
[185,163,148,167,150,163,0,157],
[184,190,184,180,184,167,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 306, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,163,172,148,164,165,171],
[157,0,170,158,144,164,164,173],
[178,171,0,176,172,162,183,172],
[169,183,165,0,165,162,153,161],
[193,197,169,176,0,187,182,178],
[177,177,179,179,154,0,164,170],
[176,177,158,188,159,177,0,174],
[170,168,169,180,163,171,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 307, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,146,161,159,186,166,151],
[183,0,185,183,163,183,159,164],
[195,156,0,176,174,160,185,162],
[180,158,165,0,162,136,151,175],
[182,178,167,179,0,177,185,165],
[155,158,181,205,164,0,162,172],
[175,182,156,190,156,179,0,167],
[190,177,179,166,176,169,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 308, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,164,147,167,160,149,166],
[188,0,188,168,178,174,164,165],
[177,153,0,148,165,164,148,156],
[194,173,193,0,164,169,176,172],
[174,163,176,177,0,178,154,176],
[181,167,177,172,163,0,174,175],
[192,177,193,165,187,167,0,177],
[175,176,185,169,165,166,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 309, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,154,172,159,181,177,171],
[170,0,155,141,159,152,161,172],
[187,186,0,166,156,169,183,179],
[169,200,175,0,175,173,171,200],
[182,182,185,166,0,179,182,172],
[160,189,172,168,162,0,185,178],
[164,180,158,170,159,156,0,166],
[170,169,162,141,169,163,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 310, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,174,166,166,163,177,189],
[164,0,168,174,171,162,174,181],
[167,173,0,162,159,168,170,168],
[175,167,179,0,179,176,182,176],
[175,170,182,162,0,161,164,174],
[178,179,173,165,180,0,179,186],
[164,167,171,159,177,162,0,176],
[152,160,173,165,167,155,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 311, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,175,169,194,161,167,188],
[164,0,178,176,184,161,178,176],
[166,163,0,161,178,173,181,179],
[172,165,180,0,174,155,182,189],
[147,157,163,167,0,153,190,172],
[180,180,168,186,188,0,176,200],
[174,163,160,159,151,165,0,189],
[153,165,162,152,169,141,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 312, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,183,180,173,167,172,174],
[161,0,177,165,172,167,163,169],
[158,164,0,155,176,169,165,158],
[161,176,186,0,185,182,173,162],
[168,169,165,156,0,174,177,156],
[174,174,172,159,167,0,177,169],
[169,178,176,168,164,164,0,158],
[167,172,183,179,185,172,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 313, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,148,163,162,132,181,173,168],
[193,0,167,198,164,186,187,178],
[178,174,0,172,148,181,164,157],
[179,143,169,0,145,176,156,154],
[209,177,193,196,0,179,181,168],
[160,155,160,165,162,0,142,163],
[168,154,177,185,160,199,0,158],
[173,163,184,187,173,178,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 314, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,164,158,178,151,165,170],
[165,0,167,140,153,162,155,176],
[177,174,0,163,185,155,166,180],
[183,201,178,0,198,165,184,184],
[163,188,156,143,0,154,165,179],
[190,179,186,176,187,0,166,181],
[176,186,175,157,176,175,0,181],
[171,165,161,157,162,160,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 315, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,143,172,180,147,134,166,108],
[198,0,189,201,151,191,199,169],
[169,152,0,189,160,124,143,136],
[161,140,152,0,137,121,135,102],
[194,190,181,204,0,169,149,171],
[207,150,217,220,172,0,196,155],
[175,142,198,206,192,145,0,143],
[233,172,205,239,170,186,198,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 316, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,178,159,159,165,171,162],
[175,0,183,171,160,148,184,158],
[163,158,0,161,166,149,171,158],
[182,170,180,0,156,156,146,175],
[182,181,175,185,0,161,189,172],
[176,193,192,185,180,0,172,169],
[170,157,170,195,152,169,0,170],
[179,183,183,166,169,172,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 317, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,214,142,157,147,207,167,186],
[127,0,134,150,142,195,139,129],
[199,207,0,178,159,193,182,160],
[184,191,163,0,126,172,157,154],
[194,199,182,215,0,185,170,180],
[134,146,148,169,156,0,162,169],
[174,202,159,184,171,179,0,160],
[155,212,181,187,161,172,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 318, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,164,169,190,181,161,182],
[158,0,166,158,173,180,158,169],
[177,175,0,169,188,198,179,188],
[172,183,172,0,179,193,170,184],
[151,168,153,162,0,172,157,168],
[160,161,143,148,169,0,156,162],
[180,183,162,171,184,185,0,183],
[159,172,153,157,173,179,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 319, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,174,162,167,162,168,157],
[161,0,181,167,173,163,161,163],
[167,160,0,166,170,162,161,156],
[179,174,175,0,168,153,151,160],
[174,168,171,173,0,166,154,158],
[179,178,179,188,175,0,171,170],
[173,180,180,190,187,170,0,177],
[184,178,185,181,183,171,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 320, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,199,172,156,194,184,198],
[149,0,159,138,133,162,180,152],
[142,182,0,163,168,177,176,171],
[169,203,178,0,165,170,187,172],
[185,208,173,176,0,181,170,188],
[147,179,164,171,160,0,180,179],
[157,161,165,154,171,161,0,189],
[143,189,170,169,153,162,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 321, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,189,93,132,80,192,172],
[186,0,237,190,170,196,157,139],
[152,104,0,82,131,86,115,157],
[248,151,259,0,178,198,167,222],
[209,171,210,163,0,214,115,198],
[261,145,255,143,127,0,177,162],
[149,184,226,174,226,164,0,154],
[169,202,184,119,143,179,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 322, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,145,144,160,167,169,156,154],
[196,0,165,183,184,183,172,186],
[197,176,0,193,192,186,167,174],
[181,158,148,0,166,155,148,163],
[174,157,149,175,0,165,172,153],
[172,158,155,186,176,0,160,176],
[185,169,174,193,169,181,0,174],
[187,155,167,178,188,165,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 323, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,143,138,148,174,151,141],
[172,0,145,168,145,171,151,186],
[198,196,0,189,161,185,176,186],
[203,173,152,0,149,201,162,176],
[193,196,180,192,0,191,162,184],
[167,170,156,140,150,0,155,167],
[190,190,165,179,179,186,0,176],
[200,155,155,165,157,174,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 324, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,174,190,185,170,174,169],
[172,0,172,180,194,178,171,159],
[167,169,0,173,177,180,176,173],
[151,161,168,0,165,170,159,146],
[156,147,164,176,0,175,152,147],
[171,163,161,171,166,0,158,164],
[167,170,165,182,189,183,0,156],
[172,182,168,195,194,177,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 325, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,204,180,186,156,194,180,178],
[137,0,151,138,121,144,155,158],
[161,190,0,150,155,157,166,155],
[155,203,191,0,161,173,191,190],
[185,220,186,180,0,162,197,202],
[147,197,184,168,179,0,197,180],
[161,186,175,150,144,144,0,179],
[163,183,186,151,139,161,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 326, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,176,191,174,148,173,173],
[182,0,188,155,204,154,219,180],
[165,153,0,147,159,161,161,171],
[150,186,194,0,175,162,186,156],
[167,137,182,166,0,141,160,147],
[193,187,180,179,200,0,191,158],
[168,122,180,155,181,150,0,193],
[168,161,170,185,194,183,148,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 327, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,200,184,190,204,156,179],
[165,0,217,216,176,169,178,184],
[141,124,0,160,159,161,158,134],
[157,125,181,0,149,171,152,143],
[151,165,182,192,0,157,186,167],
[137,172,180,170,184,0,157,154],
[185,163,183,189,155,184,0,156],
[162,157,207,198,174,187,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 328, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,166,166,182,172,169,178],
[169,0,172,159,178,166,166,175],
[175,169,0,175,182,190,166,189],
[175,182,166,0,181,190,191,187],
[159,163,159,160,0,170,169,174],
[169,175,151,151,171,0,170,173],
[172,175,175,150,172,171,0,178],
[163,166,152,154,167,168,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 329, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,171,191,174,167,163,165],
[176,0,175,182,173,167,180,156],
[170,166,0,180,166,171,170,181],
[150,159,161,0,172,168,160,171],
[167,168,175,169,0,173,157,175],
[174,174,170,173,168,0,168,172],
[178,161,171,181,184,173,0,178],
[176,185,160,170,166,169,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 330, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,174,173,191,177,172,173],
[174,0,159,181,169,177,184,176],
[167,182,0,181,178,176,165,173],
[168,160,160,0,166,165,155,162],
[150,172,163,175,0,165,160,165],
[164,164,165,176,176,0,167,175],
[169,157,176,186,181,174,0,170],
[168,165,168,179,176,166,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 331, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,158,163,169,176,164,154],
[179,0,171,177,178,177,179,149],
[183,170,0,189,199,178,183,177],
[178,164,152,0,179,182,168,139],
[172,163,142,162,0,173,176,155],
[165,164,163,159,168,0,156,140],
[177,162,158,173,165,185,0,151],
[187,192,164,202,186,201,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 332, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,161,168,184,189,147,178],
[159,0,178,171,183,175,190,168],
[180,163,0,163,170,185,159,168],
[173,170,178,0,189,194,162,168],
[157,158,171,152,0,190,154,170],
[152,166,156,147,151,0,140,141],
[194,151,182,179,187,201,0,194],
[163,173,173,173,171,200,147,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 333, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,144,180,180,218,129,109],
[161,0,156,58,233,172,104,182],
[197,185,0,160,218,218,160,114],
[161,283,181,0,295,209,232,161],
[161,108,123,46,0,121,46,61],
[123,169,123,132,220,0,132,98],
[212,237,181,109,295,209,0,212],
[232,159,227,180,280,243,129,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 334, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,166,168,163,159,187,168],
[166,0,148,176,175,176,181,161],
[175,193,0,180,169,190,186,187],
[173,165,161,0,164,168,196,161],
[178,166,172,177,0,174,183,175],
[182,165,151,173,167,0,192,159],
[154,160,155,145,158,149,0,140],
[173,180,154,180,166,182,201,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 335, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,184,177,203,195,164,185],
[159,0,197,181,161,186,162,159],
[157,144,0,144,160,174,147,151],
[164,160,197,0,168,180,155,172],
[138,180,181,173,0,178,172,181],
[146,155,167,161,163,0,155,146],
[177,179,194,186,169,186,0,192],
[156,182,190,169,160,195,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 336, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,170,168,168,182,187,163],
[186,0,186,168,180,211,190,177],
[171,155,0,174,153,180,175,163],
[173,173,167,0,161,181,172,177],
[173,161,188,180,0,187,189,185],
[159,130,161,160,154,0,167,165],
[154,151,166,169,152,174,0,175],
[178,164,178,164,156,176,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 337, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,180,165,174,153,168,168],
[172,0,166,157,173,156,149,164],
[161,175,0,163,162,170,168,165],
[176,184,178,0,178,155,167,178],
[167,168,179,163,0,154,163,157],
[188,185,171,186,187,0,170,187],
[173,192,173,174,178,171,0,167],
[173,177,176,163,184,154,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 338, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,165,170,181,175,177,171],
[178,0,159,173,170,163,162,177],
[176,182,0,160,180,172,169,173],
[171,168,181,0,175,181,165,158],
[160,171,161,166,0,168,166,163],
[166,178,169,160,173,0,166,157],
[164,179,172,176,175,175,0,187],
[170,164,168,183,178,184,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 339, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,179,178,164,155,169,172],
[185,0,186,170,172,179,182,201],
[162,155,0,179,176,162,162,177],
[163,171,162,0,163,169,179,185],
[177,169,165,178,0,184,189,184],
[186,162,179,172,157,0,190,187],
[172,159,179,162,152,151,0,164],
[169,140,164,156,157,154,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 340, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,169,172,171,163,170,144],
[172,0,204,217,181,175,218,156],
[172,137,0,147,162,178,161,135],
[169,124,194,0,169,162,203,155],
[170,160,179,172,0,157,176,172],
[178,166,163,179,184,0,174,189],
[171,123,180,138,165,167,0,154],
[197,185,206,186,169,152,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 341, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,91,152,155,156,180,105,162],
[250,0,206,164,174,163,212,224],
[189,135,0,150,148,149,154,181],
[186,177,191,0,155,154,201,144],
[185,167,193,186,0,175,175,195],
[161,178,192,187,166,0,174,175],
[236,129,187,140,166,167,0,139],
[179,117,160,197,146,166,202,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 342, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,177,174,176,178,177,167],
[158,0,158,159,159,163,176,170],
[164,183,0,166,169,175,186,167],
[167,182,175,0,172,188,186,162],
[165,182,172,169,0,166,170,186],
[163,178,166,153,175,0,168,166],
[164,165,155,155,171,173,0,167],
[174,171,174,179,155,175,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 343, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,139,169,146,172,215,190,195],
[202,0,166,175,178,184,211,181],
[172,175,0,190,159,214,182,179],
[195,166,151,0,165,208,189,201],
[169,163,182,176,0,194,188,180],
[126,157,127,133,147,0,121,144],
[151,130,159,152,153,220,0,199],
[146,160,162,140,161,197,142,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 344, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,183,171,154,155,168,186],
[173,0,196,199,176,186,186,170],
[158,145,0,169,145,153,165,160],
[170,142,172,0,150,159,160,154],
[187,165,196,191,0,188,169,176],
[186,155,188,182,153,0,190,159],
[173,155,176,181,172,151,0,162],
[155,171,181,187,165,182,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 345, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,181,165,168,184,171,172],
[166,0,169,172,178,184,169,165],
[160,172,0,167,178,172,168,171],
[176,169,174,0,174,181,178,176],
[173,163,163,167,0,180,168,168],
[157,157,169,160,161,0,167,167],
[170,172,173,163,173,174,0,180],
[169,176,170,165,173,174,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 346, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,161,171,180,179,173,171],
[183,0,171,173,185,164,180,175],
[180,170,0,176,196,173,182,175],
[170,168,165,0,177,173,174,168],
[161,156,145,164,0,165,158,163],
[162,177,168,168,176,0,178,167],
[168,161,159,167,183,163,0,160],
[170,166,166,173,178,174,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 347, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,164,177,181,162,174,168],
[179,0,162,187,179,169,178,174],
[177,179,0,184,181,179,169,180],
[164,154,157,0,173,159,168,156],
[160,162,160,168,0,157,159,171],
[179,172,162,182,184,0,187,183],
[167,163,172,173,182,154,0,166],
[173,167,161,185,170,158,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 348, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,173,180,172,168,170,172],
[167,0,173,167,173,169,172,167],
[168,168,0,153,173,160,164,175],
[161,174,188,0,180,176,182,183],
[169,168,168,161,0,175,181,172],
[173,172,181,165,166,0,167,164],
[171,169,177,159,160,174,0,182],
[169,174,166,158,169,177,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 349, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,150,139,143,173,142,152],
[171,0,173,162,144,165,166,149],
[191,168,0,178,166,193,160,160],
[202,179,163,0,146,181,154,153],
[198,197,175,195,0,196,160,189],
[168,176,148,160,145,0,180,155],
[199,175,181,187,181,161,0,182],
[189,192,181,188,152,186,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 350, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,173,147,178,177,163,172],
[168,0,189,161,142,169,168,164],
[168,152,0,181,167,172,178,171],
[194,180,160,0,178,177,186,155],
[163,199,174,163,0,193,194,161],
[164,172,169,164,148,0,175,158],
[178,173,163,155,147,166,0,178],
[169,177,170,186,180,183,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 351, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,155,142,147,154,146,194],
[179,0,184,170,168,173,168,204],
[186,157,0,169,176,175,168,219],
[199,171,172,0,173,164,192,180],
[194,173,165,168,0,173,172,187],
[187,168,166,177,168,0,191,222],
[195,173,173,149,169,150,0,189],
[147,137,122,161,154,119,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 352, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,194,197,149,230,198,184],
[163,0,164,188,175,189,178,147],
[147,177,0,199,151,174,217,155],
[144,153,142,0,181,163,195,176],
[192,166,190,160,0,167,188,164],
[111,152,167,178,174,0,189,134],
[143,163,124,146,153,152,0,136],
[157,194,186,165,177,207,205,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 353, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,186,198,167,188,159,189],
[177,0,178,189,150,184,164,176],
[155,163,0,176,184,171,172,191],
[143,152,165,0,146,184,153,162],
[174,191,157,195,0,165,144,168],
[153,157,170,157,176,0,151,171],
[182,177,169,188,197,190,0,193],
[152,165,150,179,173,170,148,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 354, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,169,191,177,182,184,197],
[168,0,189,188,166,186,189,218],
[172,152,0,165,168,175,172,187],
[150,153,176,0,156,167,171,182],
[164,175,173,185,0,181,184,191],
[159,155,166,174,160,0,166,191],
[157,152,169,170,157,175,0,190],
[144,123,154,159,150,150,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 355, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,164,182,168,175,154,179],
[175,0,177,203,155,161,173,177],
[177,164,0,182,163,175,172,162],
[159,138,159,0,157,150,167,171],
[173,186,178,184,0,182,167,192],
[166,180,166,191,159,0,171,163],
[187,168,169,174,174,170,0,168],
[162,164,179,170,149,178,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 356, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,174,168,173,181,180,177],
[174,0,168,177,193,184,191,179],
[167,173,0,183,186,183,169,189],
[173,164,158,0,181,192,177,176],
[168,148,155,160,0,161,162,174],
[160,157,158,149,180,0,162,171],
[161,150,172,164,179,179,0,168],
[164,162,152,165,167,170,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 357, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,190,163,186,180,177,158,193],
[151,0,178,154,176,159,175,198],
[178,163,0,169,165,172,170,179],
[155,187,172,0,172,175,149,173],
[161,165,176,169,0,167,174,164],
[164,182,169,166,174,0,164,191],
[183,166,171,192,167,177,0,192],
[148,143,162,168,177,150,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 358, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,132,174,201,222,146,194],
[170,0,167,135,211,225,224,179],
[209,174,0,133,204,263,169,191],
[167,206,208,0,234,259,234,197],
[140,130,137,107,0,172,178,129],
[119,116,78,82,169,0,137,105],
[195,117,172,107,163,204,0,140],
[147,162,150,144,212,236,201,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 359, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,197,182,170,185,172,195,199],
[144,0,140,126,168,142,178,156],
[159,201,0,184,220,167,163,207],
[171,215,157,0,171,154,167,178],
[156,173,121,170,0,148,154,189],
[169,199,174,187,193,0,192,190],
[146,163,178,174,187,149,0,184],
[142,185,134,163,152,151,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 360, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,163,174,174,174,176,176],
[155,0,163,158,177,152,158,165],
[178,178,0,165,183,164,180,175],
[167,183,176,0,184,183,178,173],
[167,164,158,157,0,160,160,164],
[167,189,177,158,181,0,164,172],
[165,183,161,163,181,177,0,172],
[165,176,166,168,177,169,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 361, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,163,170,175,198,172,178],
[164,0,160,166,149,177,163,160],
[178,181,0,179,175,176,163,166],
[171,175,162,0,156,181,166,166],
[166,192,166,185,0,191,170,172],
[143,164,165,160,150,0,156,153],
[169,178,178,175,171,185,0,169],
[163,181,175,175,169,188,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 362, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,168,171,170,164,153,188],
[168,0,173,170,172,171,170,185],
[173,168,0,170,161,174,163,166],
[170,171,171,0,177,161,174,184],
[171,169,180,164,0,179,154,179],
[177,170,167,180,162,0,171,171],
[188,171,178,167,187,170,0,189],
[153,156,175,157,162,170,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 363, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,195,214,169,188,175,145,199],
[146,0,166,136,170,171,153,181],
[127,175,0,153,161,150,175,181],
[172,205,188,0,186,177,156,201],
[153,171,180,155,0,182,173,184],
[166,170,191,164,159,0,180,178],
[196,188,166,185,168,161,0,199],
[142,160,160,140,157,163,142,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 364, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,189,173,166,181,169,189],
[173,0,184,173,172,177,167,177],
[152,157,0,146,156,149,153,169],
[168,168,195,0,167,166,162,176],
[175,169,185,174,0,169,162,169],
[160,164,192,175,172,0,172,179],
[172,174,188,179,179,169,0,181],
[152,164,172,165,172,162,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 365, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,193,189,195,172,183,167,183],
[148,0,165,166,150,171,150,156],
[152,176,0,174,135,171,168,162],
[146,175,167,0,160,162,169,166],
[169,191,206,181,0,182,171,197],
[158,170,170,179,159,0,165,188],
[174,191,173,172,170,176,0,181],
[158,185,179,175,144,153,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 366, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,172,164,172,174,176,183],
[164,0,189,168,171,165,167,184],
[169,152,0,168,156,167,168,172],
[177,173,173,0,164,172,171,184],
[169,170,185,177,0,183,167,176],
[167,176,174,169,158,0,168,184],
[165,174,173,170,174,173,0,161],
[158,157,169,157,165,157,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 367, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,207,181,161,186,181,176],
[179,0,210,194,165,191,167,180],
[134,131,0,150,134,134,150,138],
[160,147,191,0,177,159,150,160],
[180,176,207,164,0,195,163,165],
[155,150,207,182,146,0,166,170],
[160,174,191,191,178,175,0,183],
[165,161,203,181,176,171,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 368, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,172,165,166,166,174,156],
[179,0,186,179,175,191,186,161],
[169,155,0,143,167,179,184,158],
[176,162,198,0,167,182,190,173],
[175,166,174,174,0,184,196,177],
[175,150,162,159,157,0,172,156],
[167,155,157,151,145,169,0,156],
[185,180,183,168,164,185,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 369, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,184,181,145,168,174,169],
[155,0,156,174,161,166,181,164],
[157,185,0,159,165,157,171,165],
[160,167,182,0,171,172,170,183],
[196,180,176,170,0,174,163,195],
[173,175,184,169,167,0,172,176],
[167,160,170,171,178,169,0,172],
[172,177,176,158,146,165,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 370, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,194,165,164,167,189,180,178],
[147,0,163,158,150,173,162,158],
[176,178,0,167,182,181,170,169],
[177,183,174,0,170,170,178,171],
[174,191,159,171,0,172,172,167],
[152,168,160,171,169,0,180,165],
[161,179,171,163,169,161,0,160],
[163,183,172,170,174,176,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 371, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,187,157,165,172,174,176],
[174,0,195,139,156,148,169,178],
[154,146,0,167,140,159,150,169],
[184,202,174,0,171,166,186,202],
[176,185,201,170,0,186,175,210],
[169,193,182,175,155,0,178,183],
[167,172,191,155,166,163,0,204],
[165,163,172,139,131,158,137,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 372, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,166,163,172,169,185,158],
[189,0,163,169,174,188,169,169],
[175,178,0,161,180,172,177,172],
[178,172,180,0,185,161,186,181],
[169,167,161,156,0,168,174,156],
[172,153,169,180,173,0,180,157],
[156,172,164,155,167,161,0,149],
[183,172,169,160,185,184,192,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 373, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,175,165,172,178,167,177],
[169,0,184,172,177,179,179,168],
[166,157,0,174,170,169,167,163],
[176,169,167,0,160,164,182,174],
[169,164,171,181,0,163,174,163],
[163,162,172,177,178,0,156,165],
[174,162,174,159,167,185,0,176],
[164,173,178,167,178,176,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 374, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,206,166,172,177,168,161],
[177,0,185,165,170,164,169,170],
[135,156,0,174,124,168,171,148],
[175,176,167,0,145,184,174,170],
[169,171,217,196,0,177,186,194],
[164,177,173,157,164,0,154,182],
[173,172,170,167,155,187,0,172],
[180,171,193,171,147,159,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 375, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,171,172,179,175,180,179],
[173,0,172,163,179,191,167,159],
[170,169,0,168,172,190,191,182],
[169,178,173,0,174,197,194,181],
[162,162,169,167,0,186,169,160],
[166,150,151,144,155,0,164,162],
[161,174,150,147,172,177,0,161],
[162,182,159,160,181,179,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 376, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,190,175,168,171,185,165],
[173,0,178,170,173,163,193,168],
[151,163,0,169,179,171,180,163],
[166,171,172,0,162,184,175,179],
[173,168,162,179,0,189,183,160],
[170,178,170,157,152,0,180,159],
[156,148,161,166,158,161,0,159],
[176,173,178,162,181,182,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 377, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,161,154,170,165,161,143],
[175,0,187,162,169,176,195,185],
[180,154,0,171,171,179,171,157],
[187,179,170,0,167,184,191,166],
[171,172,170,174,0,147,158,174],
[176,165,162,157,194,0,170,159],
[180,146,170,150,183,171,0,179],
[198,156,184,175,167,182,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 378, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,173,181,179,174,171,180],
[175,0,167,170,178,179,174,179],
[168,174,0,165,185,192,173,193],
[160,171,176,0,165,163,162,184],
[162,163,156,176,0,171,166,186],
[167,162,149,178,170,0,169,171],
[170,167,168,179,175,172,0,190],
[161,162,148,157,155,170,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 379, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,203,177,157,146,163,205],
[178,0,166,170,185,154,165,189],
[138,175,0,156,175,144,171,177],
[164,171,185,0,154,159,149,194],
[184,156,166,187,0,158,156,200],
[195,187,197,182,183,0,164,211],
[178,176,170,192,185,177,0,204],
[136,152,164,147,141,130,137,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 380, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,169,176,184,167,175,167],
[168,0,160,163,171,163,165,161],
[172,181,0,167,178,166,164,158],
[165,178,174,0,188,169,166,164],
[157,170,163,153,0,159,160,155],
[174,178,175,172,182,0,176,165],
[166,176,177,175,181,165,0,173],
[174,180,183,177,186,176,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 381, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,180,182,169,167,178,168],
[159,0,153,166,144,160,138,141],
[161,188,0,168,170,158,157,166],
[159,175,173,0,160,157,163,149],
[172,197,171,181,0,164,160,175],
[174,181,183,184,177,0,156,153],
[163,203,184,178,181,185,0,184],
[173,200,175,192,166,188,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 382, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,176,171,173,187,156,169],
[172,0,178,163,162,178,172,182],
[165,163,0,164,171,186,166,180],
[170,178,177,0,160,173,164,179],
[168,179,170,181,0,192,161,183],
[154,163,155,168,149,0,141,165],
[185,169,175,177,180,200,0,184],
[172,159,161,162,158,176,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 383, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,173,157,164,171,180,179],
[171,0,174,172,156,174,178,168],
[168,167,0,173,180,170,171,165],
[184,169,168,0,159,182,173,173],
[177,185,161,182,0,192,162,157],
[170,167,171,159,149,0,180,149],
[161,163,170,168,179,161,0,172],
[162,173,176,168,184,192,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 384, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,202,169,180,185,210,199,179],
[139,0,163,166,174,179,171,181],
[172,178,0,175,180,195,183,170],
[161,175,166,0,179,198,179,183],
[156,167,161,162,0,199,163,172],
[131,162,146,143,142,0,143,158],
[142,170,158,162,178,198,0,155],
[162,160,171,158,169,183,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 385, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,157,151,159,158,158,157],
[185,0,180,167,173,173,163,177],
[184,161,0,162,183,167,171,166],
[190,174,179,0,163,181,166,158],
[182,168,158,178,0,177,183,166],
[183,168,174,160,164,0,154,159],
[183,178,170,175,158,187,0,167],
[184,164,175,183,175,182,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 386, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,177,192,160,167,162,152],
[182,0,149,206,162,173,168,182],
[164,192,0,235,176,176,201,180],
[149,135,106,0,135,166,152,170],
[181,179,165,206,0,180,179,176],
[174,168,165,175,161,0,209,187],
[179,173,140,189,162,132,0,169],
[189,159,161,171,165,154,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 387, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,177,165,175,172,174,172],
[180,0,198,162,178,179,163,161],
[164,143,0,154,173,172,154,171],
[176,179,187,0,182,177,168,184],
[166,163,168,159,0,160,167,169],
[169,162,169,164,181,0,167,164],
[167,178,187,173,174,174,0,178],
[169,180,170,157,172,177,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 388, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,192,180,192,182,165,189],
[159,0,192,173,173,171,173,175],
[149,149,0,165,171,161,137,153],
[161,168,176,0,174,176,154,169],
[149,168,170,167,0,171,146,154],
[159,170,180,165,170,0,160,155],
[176,168,204,187,195,181,0,187],
[152,166,188,172,187,186,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 389, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,174,179,181,165,174,172],
[172,0,164,175,166,176,163,165],
[167,177,0,171,171,162,153,159],
[162,166,170,0,156,171,151,163],
[160,175,170,185,0,166,152,168],
[176,165,179,170,175,0,154,168],
[167,178,188,190,189,187,0,178],
[169,176,182,178,173,173,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 390, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,161,180,164,179,182,145],
[184,0,165,190,154,181,174,167],
[180,176,0,195,173,186,178,166],
[161,151,146,0,148,161,166,137],
[177,187,168,193,0,175,173,176],
[162,160,155,180,166,0,169,178],
[159,167,163,175,168,172,0,160],
[196,174,175,204,165,163,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 391, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,170,168,171,164,149,167],
[188,0,189,170,178,178,166,168],
[171,152,0,140,159,171,154,145],
[173,171,201,0,178,187,173,165],
[170,163,182,163,0,179,158,170],
[177,163,170,154,162,0,140,151],
[192,175,187,168,183,201,0,190],
[174,173,196,176,171,190,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 392, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,147,167,165,131,161,198,125],
[194,0,183,156,149,190,195,160],
[174,158,0,169,148,182,186,131],
[176,185,172,0,152,178,195,181],
[210,192,193,189,0,212,221,164],
[180,151,159,163,129,0,189,163],
[143,146,155,146,120,152,0,121],
[216,181,210,160,177,178,220,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 393, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,185,171,196,148,174,178],
[158,0,162,157,167,175,164,183],
[156,179,0,183,191,152,178,163],
[170,184,158,0,173,183,169,191],
[145,174,150,168,0,164,161,141],
[193,166,189,158,177,0,162,186],
[167,177,163,172,180,179,0,186],
[163,158,178,150,200,155,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 394, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,170,172,205,192,184,176],
[157,0,156,174,162,166,176,156],
[171,185,0,182,201,179,213,161],
[169,167,159,0,197,184,197,166],
[136,179,140,144,0,158,164,161],
[149,175,162,157,183,0,174,152],
[157,165,128,144,177,167,0,146],
[165,185,180,175,180,189,195,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 395, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,192,203,224,200,178,167],
[158,0,175,213,184,194,153,169],
[149,166,0,174,203,198,162,183],
[138,128,167,0,210,194,201,177],
[117,157,138,131,0,150,154,142],
[141,147,143,147,191,0,121,152],
[163,188,179,140,187,220,0,174],
[174,172,158,164,199,189,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 396, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,180,184,169,184,182,169],
[168,0,191,179,171,188,180,179],
[161,150,0,168,159,165,154,170],
[157,162,173,0,161,174,181,162],
[172,170,182,180,0,171,181,181],
[157,153,176,167,170,0,164,172],
[159,161,187,160,160,177,0,165],
[172,162,171,179,160,169,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 397, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,256,200,203,295,164,172,208],
[85,0,178,170,173,96,98,84],
[141,163,0,167,182,130,90,150],
[138,171,174,0,187,161,128,132],
[46,168,159,154,0,105,128,149],
[177,245,211,180,236,0,144,217],
[169,243,251,213,213,197,0,244],
[133,257,191,209,192,124,97,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 398, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,174,152,206,181,181,193],
[166,0,182,169,219,198,188,203],
[167,159,0,192,205,181,187,188],
[189,172,149,0,217,186,191,176],
[135,122,136,124,0,145,130,137],
[160,143,160,155,196,0,177,196],
[160,153,154,150,211,164,0,172],
[148,138,153,165,204,145,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 399, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,143,200,208,191,171,232],
[188,0,157,163,181,185,144,221],
[198,184,0,187,209,180,165,249],
[141,178,154,0,185,150,149,196],
[133,160,132,156,0,143,156,187],
[150,156,161,191,198,0,168,236],
[170,197,176,192,185,173,0,227],
[109,120,92,145,154,105,114,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 400, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,182,171,173,166,161,178],
[177,0,170,177,192,169,178,178],
[159,171,0,169,173,160,167,169],
[170,164,172,0,172,156,171,158],
[168,149,168,169,0,172,161,170],
[175,172,181,185,169,0,165,165],
[180,163,174,170,180,176,0,164],
[163,163,172,183,171,176,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 401, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,172,170,177,178,167,189],
[176,0,169,179,188,172,178,184],
[169,172,0,169,186,178,185,186],
[171,162,172,0,165,165,156,173],
[164,153,155,176,0,172,160,171],
[163,169,163,176,169,0,160,178],
[174,163,156,185,181,181,0,180],
[152,157,155,168,170,163,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 402, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,140,128,163,153,128,134,147],
[201,0,189,182,183,173,167,200],
[213,152,0,196,185,183,172,181],
[178,159,145,0,164,151,145,179],
[188,158,156,177,0,162,161,174],
[213,168,158,190,179,0,185,189],
[207,174,169,196,180,156,0,190],
[194,141,160,162,167,152,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 403, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,177,181,177,182,173,191],
[174,0,176,153,170,180,173,178],
[164,165,0,166,152,166,163,158],
[160,188,175,0,167,166,160,178],
[164,171,189,174,0,183,175,162],
[159,161,175,175,158,0,159,163],
[168,168,178,181,166,182,0,186],
[150,163,183,163,179,178,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 404, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,150,122,141,224,137,152],
[180,0,195,143,198,211,145,179],
[191,146,0,161,183,216,186,180],
[219,198,180,0,201,219,180,161],
[200,143,158,140,0,185,149,170],
[117,130,125,122,156,0,159,136],
[204,196,155,161,192,182,0,200],
[189,162,161,180,171,205,141,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 405, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,131,168,130,181,182,156,172],
[210,0,198,191,177,193,159,193],
[173,143,0,143,204,180,174,142],
[211,150,198,0,207,167,206,213],
[160,164,137,134,0,158,206,168],
[159,148,161,174,183,0,138,164],
[185,182,167,135,135,203,0,175],
[169,148,199,128,173,177,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 406, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,216,167,112,131,207,181,208],
[125,0,148,117,144,170,167,204],
[174,193,0,164,199,207,220,216],
[229,224,177,0,163,193,188,237],
[210,197,142,178,0,161,176,205],
[134,171,134,148,180,0,148,175],
[160,174,121,153,165,193,0,187],
[133,137,125,104,136,166,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 407, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,163,201,132,145,159,140],
[182,0,206,230,152,190,213,213],
[178,135,0,228,135,169,159,154],
[140,111,113,0,100,113,158,128],
[209,189,206,241,0,167,224,157],
[196,151,172,228,174,0,194,159],
[182,128,182,183,117,147,0,117],
[201,128,187,213,184,182,224,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 408, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,187,186,176,172,184,169],
[165,0,159,164,156,166,165,163],
[154,182,0,186,167,164,167,158],
[155,177,155,0,155,164,162,172],
[165,185,174,186,0,172,173,186],
[169,175,177,177,169,0,173,178],
[157,176,174,179,168,168,0,174],
[172,178,183,169,155,163,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 409, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,146,165,196,187,174,154,157],
[195,0,180,206,180,180,165,165],
[176,161,0,174,169,173,155,173],
[145,135,167,0,142,166,140,147],
[154,161,172,199,0,173,174,183],
[167,161,168,175,168,0,167,175],
[187,176,186,201,167,174,0,183],
[184,176,168,194,158,166,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 410, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,218,192,167,191,191,192,218],
[123,0,69,115,116,93,45,191],
[149,272,0,115,166,190,218,190],
[174,226,226,0,170,171,127,171],
[150,225,175,171,0,199,198,242],
[150,248,151,170,142,0,225,142],
[149,296,123,214,143,116,0,190],
[123,150,151,170,99,199,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 411, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,184,206,140,170,155,191],
[176,0,216,226,215,236,162,186],
[157,125,0,153,113,106,111,115],
[135,115,188,0,127,155,130,121],
[201,126,228,214,0,205,219,206],
[171,105,235,186,136,0,183,178],
[186,179,230,211,122,158,0,149],
[150,155,226,220,135,163,192,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 412, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,159,167,167,159,165,147],
[171,0,164,155,171,153,146,147],
[182,177,0,137,152,166,130,149],
[174,186,204,0,168,174,185,188],
[174,170,189,173,0,164,169,167],
[182,188,175,167,177,0,160,155],
[176,195,211,156,172,181,0,177],
[194,194,192,153,174,186,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 413, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,215,239,174,127,152,208,185],
[126,0,247,109,150,162,208,198],
[102,94,0,114,128,116,140,158],
[167,232,227,0,207,214,190,161],
[214,191,213,134,0,188,176,136],
[189,179,225,127,153,0,192,167],
[133,133,201,151,165,149,0,174],
[156,143,183,180,205,174,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 414, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,160,161,173,168,157,155],
[156,0,145,154,151,164,162,135],
[181,196,0,164,167,178,180,165],
[180,187,177,0,182,207,169,180],
[168,190,174,159,0,173,171,152],
[173,177,163,134,168,0,187,165],
[184,179,161,172,170,154,0,180],
[186,206,176,161,189,176,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 415, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,155,173,203,175,181,186],
[175,0,164,163,155,186,189,188],
[186,177,0,184,181,189,147,181],
[168,178,157,0,139,161,146,173],
[138,186,160,202,0,167,175,167],
[166,155,152,180,174,0,167,163],
[160,152,194,195,166,174,0,175],
[155,153,160,168,174,178,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 416, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,170,179,177,177,178,173],
[157,0,180,176,170,184,166,168],
[171,161,0,164,177,166,169,144],
[162,165,177,0,184,177,171,166],
[164,171,164,157,0,187,165,162],
[164,157,175,164,154,0,155,157],
[163,175,172,170,176,186,0,153],
[168,173,197,175,179,184,188,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 417, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,178,164,175,166,170,172],
[170,0,171,168,174,161,174,161],
[163,170,0,164,178,173,168,173],
[177,173,177,0,177,175,186,169],
[166,167,163,164,0,166,171,155],
[175,180,168,166,175,0,182,172],
[171,167,173,155,170,159,0,157],
[169,180,168,172,186,169,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 418, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,224,210,223,182,219,149],
[185,0,196,159,184,207,246,177],
[117,145,0,150,178,167,195,156],
[131,182,191,0,195,170,194,173],
[118,157,163,146,0,185,190,163],
[159,134,174,171,156,0,205,209],
[122,95,146,147,151,136,0,186],
[192,164,185,168,178,132,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 419, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,168,170,161,173,175,186],
[174,0,157,163,173,181,168,175],
[173,184,0,172,168,175,177,190],
[171,178,169,0,174,165,180,175],
[180,168,173,167,0,162,177,180],
[168,160,166,176,179,0,164,175],
[166,173,164,161,164,177,0,181],
[155,166,151,166,161,166,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 420, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,162,171,164,178,171,186],
[177,0,167,163,170,183,187,179],
[179,174,0,173,165,195,168,191],
[170,178,168,0,171,183,169,192],
[177,171,176,170,0,178,181,183],
[163,158,146,158,163,0,179,174],
[170,154,173,172,160,162,0,171],
[155,162,150,149,158,167,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 421, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,157,177,164,149,163,157],
[179,0,162,168,174,156,169,169],
[184,179,0,173,183,173,168,170],
[164,173,168,0,177,149,165,162],
[177,167,158,164,0,164,162,166],
[192,185,168,192,177,0,181,187],
[178,172,173,176,179,160,0,177],
[184,172,171,179,175,154,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 422, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,171,154,144,159,146,153],
[181,0,161,171,159,152,172,157],
[170,180,0,162,157,177,173,179],
[187,170,179,0,173,174,167,177],
[197,182,184,168,0,168,168,174],
[182,189,164,167,173,0,156,160],
[195,169,168,174,173,185,0,175],
[188,184,162,164,167,181,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 423, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,162,146,200,193,192,169],
[169,0,142,147,170,201,178,202],
[179,199,0,176,157,225,207,240],
[195,194,165,0,191,209,220,260],
[141,171,184,150,0,189,174,219],
[148,140,116,132,152,0,161,175],
[149,163,134,121,167,180,0,185],
[172,139,101,81,122,166,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 424, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,154,177,189,176,159,192],
[161,0,178,173,174,190,183,188],
[187,163,0,155,190,172,197,199],
[164,168,186,0,188,197,176,207],
[152,167,151,153,0,175,168,169],
[165,151,169,144,166,0,166,163],
[182,158,144,165,173,175,0,184],
[149,153,142,134,172,178,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 425, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,166,172,172,165,167,172],
[174,0,158,157,164,160,166,172],
[175,183,0,167,178,166,176,185],
[169,184,174,0,174,181,182,198],
[169,177,163,167,0,173,172,170],
[176,181,175,160,168,0,174,176],
[174,175,165,159,169,167,0,180],
[169,169,156,143,171,165,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 426, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,193,161,190,178,180,184,183],
[148,0,149,163,151,158,166,170],
[180,192,0,173,179,166,177,190],
[151,178,168,0,167,158,182,181],
[163,190,162,174,0,163,176,182],
[161,183,175,183,178,0,180,180],
[157,175,164,159,165,161,0,185],
[158,171,151,160,159,161,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 427, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,160,178,160,166,173,152],
[164,0,162,168,160,180,198,174],
[181,179,0,163,178,178,178,178],
[163,173,178,0,184,175,171,164],
[181,181,163,157,0,189,165,174],
[175,161,163,166,152,0,157,159],
[168,143,163,170,176,184,0,171],
[189,167,163,177,167,182,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 428, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,159,139,150,157,173,171],
[181,0,154,143,179,158,165,175],
[182,187,0,154,199,152,162,185],
[202,198,187,0,172,169,191,204],
[191,162,142,169,0,147,167,161],
[184,183,189,172,194,0,179,162],
[168,176,179,150,174,162,0,171],
[170,166,156,137,180,179,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 429, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,179,178,183,182,189,177],
[173,0,165,175,167,173,176,159],
[162,176,0,184,186,188,197,163],
[163,166,157,0,170,174,176,166],
[158,174,155,171,0,182,190,172],
[159,168,153,167,159,0,172,154],
[152,165,144,165,151,169,0,157],
[164,182,178,175,169,187,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 430, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,193,173,172,185,164,177,173],
[148,0,161,165,170,155,156,153],
[168,180,0,164,173,166,160,167],
[169,176,177,0,180,166,171,178],
[156,171,168,161,0,163,164,155],
[177,186,175,175,178,0,167,168],
[164,185,181,170,177,174,0,169],
[168,188,174,163,186,173,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 431, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,167,172,143,197,188,168],
[158,0,156,147,170,183,181,182],
[174,185,0,157,156,174,160,168],
[169,194,184,0,181,185,182,195],
[198,171,185,160,0,190,186,172],
[144,158,167,156,151,0,170,164],
[153,160,181,159,155,171,0,175],
[173,159,173,146,169,177,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 432, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,206,212,173,197,202,165],
[168,0,189,195,171,199,188,211],
[135,152,0,164,159,157,179,172],
[129,146,177,0,167,177,177,163],
[168,170,182,174,0,196,194,171],
[144,142,184,164,145,0,173,174],
[139,153,162,164,147,168,0,161],
[176,130,169,178,170,167,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 433, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,180,168,180,170,168,178],
[162,0,172,160,156,157,156,154],
[161,169,0,160,174,166,164,174],
[173,181,181,0,188,186,157,172],
[161,185,167,153,0,159,168,159],
[171,184,175,155,182,0,167,165],
[173,185,177,184,173,174,0,162],
[163,187,167,169,182,176,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 434, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,182,196,184,182,167,168],
[152,0,167,170,178,167,182,180],
[159,174,0,180,164,171,179,168],
[145,171,161,0,172,166,170,168],
[157,163,177,169,0,181,187,174],
[159,174,170,175,160,0,188,167],
[174,159,162,171,154,153,0,163],
[173,161,173,173,167,174,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 435, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,196,198,179,180,192,178],
[182,0,198,191,159,183,195,178],
[145,143,0,172,162,162,166,160],
[143,150,169,0,141,161,163,159],
[162,182,179,200,0,185,193,177],
[161,158,179,180,156,0,186,151],
[149,146,175,178,148,155,0,159],
[163,163,181,182,164,190,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 436, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,172,183,169,171,178,175],
[169,0,172,174,176,149,179,175],
[169,169,0,178,167,151,168,178],
[158,167,163,0,158,161,154,160],
[172,165,174,183,0,153,164,163],
[170,192,190,180,188,0,194,191],
[163,162,173,187,177,147,0,170],
[166,166,163,181,178,150,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 437, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,164,158,169,153,160,167],
[188,0,186,157,182,171,190,155],
[177,155,0,156,176,171,162,175],
[183,184,185,0,165,172,189,172],
[172,159,165,176,0,164,172,169],
[188,170,170,169,177,0,178,176],
[181,151,179,152,169,163,0,159],
[174,186,166,169,172,165,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 438, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,172,165,171,171,155,166],
[168,0,181,176,169,172,177,176],
[169,160,0,154,158,165,146,178],
[176,165,187,0,172,163,162,177],
[170,172,183,169,0,165,160,180],
[170,169,176,178,176,0,165,176],
[186,164,195,179,181,176,0,184],
[175,165,163,164,161,165,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 439, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,169,185,180,188,188,177],
[170,0,160,180,163,182,161,158],
[172,181,0,174,179,169,166,147],
[156,161,167,0,165,139,165,157],
[161,178,162,176,0,165,153,150],
[153,159,172,202,176,0,172,155],
[153,180,175,176,188,169,0,172],
[164,183,194,184,191,186,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 440, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,151,176,176,133,144,175],
[159,0,152,186,150,134,142,167],
[190,189,0,176,168,192,163,191],
[165,155,165,0,166,158,140,166],
[165,191,173,175,0,185,189,209],
[208,207,149,183,156,0,126,189],
[197,199,178,201,152,215,0,187],
[166,174,150,175,132,152,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 441, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,174,190,174,159,181,179],
[169,0,190,185,184,173,165,167],
[167,151,0,161,160,146,148,163],
[151,156,180,0,160,162,169,155],
[167,157,181,181,0,137,188,178],
[182,168,195,179,204,0,193,178],
[160,176,193,172,153,148,0,157],
[162,174,178,186,163,163,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 442, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,137,128,132,165,139,149,136],
[204,0,150,124,156,203,185,156],
[213,191,0,174,186,188,194,154],
[209,217,167,0,216,186,204,151],
[176,185,155,125,0,183,169,173],
[202,138,153,155,158,0,146,139],
[192,156,147,137,172,195,0,158],
[205,185,187,190,168,202,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 443, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,180,198,216,265,145,167],
[179,0,231,177,258,240,157,183],
[161,110,0,197,197,220,159,148],
[143,164,144,0,202,186,163,182],
[125,83,144,139,0,158,146,142],
[76,101,121,155,183,0,84,101],
[196,184,182,178,195,257,0,169],
[174,158,193,159,199,240,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 444, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,153,173,183,171,182,176],
[172,0,163,179,198,161,175,178],
[188,178,0,187,186,165,180,187],
[168,162,154,0,175,163,166,178],
[158,143,155,166,0,164,160,156],
[170,180,176,178,177,0,173,189],
[159,166,161,175,181,168,0,164],
[165,163,154,163,185,152,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 445, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,165,156,163,180,163,163],
[189,0,185,173,175,189,162,182],
[176,156,0,167,164,176,164,163],
[185,168,174,0,180,192,173,173],
[178,166,177,161,0,190,167,160],
[161,152,165,149,151,0,155,173],
[178,179,177,168,174,186,0,173],
[178,159,178,168,181,168,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 446, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,170,167,183,174,163,170],
[163,0,164,164,170,171,156,166],
[171,177,0,171,168,180,161,173],
[174,177,170,0,178,170,165,170],
[158,171,173,163,0,162,159,155],
[167,170,161,171,179,0,167,176],
[178,185,180,176,182,174,0,167],
[171,175,168,171,186,165,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 447, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,189,173,170,174,182,170],
[171,0,188,193,177,189,183,167],
[152,153,0,158,139,178,161,160],
[168,148,183,0,176,173,162,157],
[171,164,202,165,0,166,177,188],
[167,152,163,168,175,0,152,157],
[159,158,180,179,164,189,0,169],
[171,174,181,184,153,184,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 448, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,220,219,214,161,251,186,267],
[121,0,210,270,202,193,129,276],
[122,131,0,234,131,170,207,279],
[127,71,107,0,67,101,46,203],
[180,139,210,274,0,265,210,287],
[90,148,171,240,76,0,171,212],
[155,212,134,295,131,170,0,267],
[74,65,62,138,54,129,74,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 449, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,173,176,176,168,159,175],
[173,0,174,168,167,164,163,179],
[168,167,0,166,168,166,166,167],
[165,173,175,0,161,148,174,179],
[165,174,173,180,0,166,181,176],
[173,177,175,193,175,0,176,165],
[182,178,175,167,160,165,0,168],
[166,162,174,162,165,176,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 450, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,162,175,172,162,166,152],
[168,0,165,177,197,179,176,171],
[179,176,0,181,173,167,189,169],
[166,164,160,0,157,158,162,153],
[169,144,168,184,0,177,173,161],
[179,162,174,183,164,0,172,163],
[175,165,152,179,168,169,0,157],
[189,170,172,188,180,178,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 451, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,213,154,168,142,176,178],
[176,0,208,145,171,163,159,150],
[128,133,0,144,136,133,163,145],
[187,196,197,0,178,146,175,171],
[173,170,205,163,0,169,159,194],
[199,178,208,195,172,0,181,160],
[165,182,178,166,182,160,0,182],
[163,191,196,170,147,181,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 452, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,182,164,164,169,174,159],
[185,0,187,164,201,173,193,167],
[159,154,0,159,185,143,154,165],
[177,177,182,0,194,164,180,172],
[177,140,156,147,0,143,161,169],
[172,168,198,177,198,0,197,180],
[167,148,187,161,180,144,0,156],
[182,174,176,169,172,161,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 453, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,130,166,176,198,176,186],
[178,0,172,157,167,163,194,150],
[211,169,0,180,196,168,202,177],
[175,184,161,0,140,191,157,145],
[165,174,145,201,0,150,210,175],
[143,178,173,150,191,0,195,172],
[165,147,139,184,131,146,0,135],
[155,191,164,196,166,169,206,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 454, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,177,165,132,149,187,145],
[183,0,186,175,160,168,178,176],
[164,155,0,144,126,150,157,154],
[176,166,197,0,152,186,194,166],
[209,181,215,189,0,180,193,170],
[192,173,191,155,161,0,196,174],
[154,163,184,147,148,145,0,159],
[196,165,187,175,171,167,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 455, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,147,166,160,165,176,164,151],
[194,0,194,170,193,189,175,198],
[175,147,0,152,182,173,188,179],
[181,171,189,0,186,191,158,183],
[176,148,159,155,0,181,151,163],
[165,152,168,150,160,0,157,156],
[177,166,153,183,190,184,0,174],
[190,143,162,158,178,185,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 456, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,180,167,184,177,171,164],
[168,0,159,196,172,191,154,174],
[161,182,0,171,163,183,179,154],
[174,145,170,0,184,177,138,178],
[157,169,178,157,0,177,146,151],
[164,150,158,164,164,0,140,150],
[170,187,162,203,195,201,0,168],
[177,167,187,163,190,191,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 457, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,177,167,172,162,164,202],
[161,0,175,161,151,163,149,188],
[164,166,0,172,163,170,157,182],
[174,180,169,0,165,183,164,183],
[169,190,178,176,0,176,171,194],
[179,178,171,158,165,0,157,187],
[177,192,184,177,170,184,0,212],
[139,153,159,158,147,154,129,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 458, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,172,160,174,165,177,152],
[181,0,168,158,186,171,185,181],
[169,173,0,177,180,181,168,172],
[181,183,164,0,177,192,191,171],
[167,155,161,164,0,169,179,160],
[176,170,160,149,172,0,176,159],
[164,156,173,150,162,165,0,163],
[189,160,169,170,181,182,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 459, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,181,174,164,187,176,176],
[161,0,182,154,149,180,176,163],
[160,159,0,163,148,164,172,169],
[167,187,178,0,171,177,173,173],
[177,192,193,170,0,178,180,176],
[154,161,177,164,163,0,188,167],
[165,165,169,168,161,153,0,174],
[165,178,172,168,165,174,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 460, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,166,186,198,212,188,202],
[172,0,167,183,186,188,182,216],
[175,174,0,155,193,180,189,209],
[155,158,186,0,193,171,153,187],
[143,155,148,148,0,186,167,183],
[129,153,161,170,155,0,177,180],
[153,159,152,188,174,164,0,177],
[139,125,132,154,158,161,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 461, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,208,164,178,174,170,194,161],
[133,0,156,169,123,158,151,153],
[177,185,0,181,155,181,171,169],
[163,172,160,0,141,165,166,165],
[167,218,186,200,0,195,166,176],
[171,183,160,176,146,0,165,164],
[147,190,170,175,175,176,0,178],
[180,188,172,176,165,177,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 462, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,180,160,166,161,166,176],
[167,0,164,176,173,181,172,196],
[161,177,0,156,162,178,177,180],
[181,165,185,0,181,184,201,187],
[175,168,179,160,0,187,185,178],
[180,160,163,157,154,0,186,176],
[175,169,164,140,156,155,0,163],
[165,145,161,154,163,165,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 463, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,167,168,175,176,166,168],
[163,0,172,176,175,181,146,176],
[174,169,0,188,183,176,155,175],
[173,165,153,0,164,170,145,156],
[166,166,158,177,0,177,159,161],
[165,160,165,171,164,0,160,163],
[175,195,186,196,182,181,0,165],
[173,165,166,185,180,178,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 464, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,157,179,163,186,166,156],
[177,0,170,179,191,193,161,173],
[184,171,0,186,172,194,185,164],
[162,162,155,0,162,176,168,158],
[178,150,169,179,0,174,167,162],
[155,148,147,165,167,0,156,141],
[175,180,156,173,174,185,0,154],
[185,168,177,183,179,200,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 465, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,148,195,176,166,180,173],
[161,0,169,177,186,169,173,170],
[193,172,0,187,166,161,181,171],
[146,164,154,0,173,159,162,188],
[165,155,175,168,0,170,152,184],
[175,172,180,182,171,0,154,185],
[161,168,160,179,189,187,0,189],
[168,171,170,153,157,156,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 466, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,168,148,185,193,156,171],
[184,0,186,167,183,195,159,152],
[173,155,0,165,174,199,172,158],
[193,174,176,0,187,202,168,182],
[156,158,167,154,0,171,142,153],
[148,146,142,139,170,0,148,144],
[185,182,169,173,199,193,0,182],
[170,189,183,159,188,197,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 467, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,164,148,171,170,162,161],
[176,0,179,181,182,170,175,169],
[177,162,0,172,189,176,174,163],
[193,160,169,0,175,179,173,173],
[170,159,152,166,0,181,166,163],
[171,171,165,162,160,0,174,175],
[179,166,167,168,175,167,0,169],
[180,172,178,168,178,166,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 468, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,160,163,153,150,158,180],
[166,0,169,154,164,165,164,183],
[181,172,0,151,160,172,177,192],
[178,187,190,0,166,172,170,188],
[188,177,181,175,0,183,161,198],
[191,176,169,169,158,0,158,186],
[183,177,164,171,180,183,0,182],
[161,158,149,153,143,155,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 469, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,190,185,196,157,167,236,160],
[151,0,165,192,134,152,193,157],
[156,176,0,188,158,149,196,145],
[145,149,153,0,119,142,193,153],
[184,207,183,222,0,170,224,172],
[174,189,192,199,171,0,233,168],
[105,148,145,148,117,108,0,124],
[181,184,196,188,169,173,217,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 470, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,188,160,179,186,208,158],
[155,0,163,190,198,189,223,151],
[153,178,0,151,161,168,185,158],
[181,151,190,0,201,169,204,185],
[162,143,180,140,0,161,206,143],
[155,152,173,172,180,0,191,138],
[133,118,156,137,135,150,0,109],
[183,190,183,156,198,203,232,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 471, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,182,198,181,173,165,191],
[155,0,173,157,153,166,143,175],
[159,168,0,182,166,193,153,173],
[143,184,159,0,152,163,151,184],
[160,188,175,189,0,163,171,174],
[168,175,148,178,178,0,157,177],
[176,198,188,190,170,184,0,184],
[150,166,168,157,167,164,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 472, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,162,159,157,154,155,166],
[176,0,188,184,173,164,163,182],
[179,153,0,167,181,172,172,170],
[182,157,174,0,161,163,172,171],
[184,168,160,180,0,167,160,158],
[187,177,169,178,174,0,175,185],
[186,178,169,169,181,166,0,177],
[175,159,171,170,183,156,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 473, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,172,193,181,183,176,187],
[190,0,164,189,178,175,170,193],
[169,177,0,193,181,202,174,194],
[148,152,148,0,166,166,172,180],
[160,163,160,175,0,155,168,163],
[158,166,139,175,186,0,157,169],
[165,171,167,169,173,184,0,190],
[154,148,147,161,178,172,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 474, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,181,186,178,169,167,186],
[170,0,178,173,168,167,169,173],
[160,163,0,167,160,169,158,149],
[155,168,174,0,153,154,169,155],
[163,173,181,188,0,177,177,167],
[172,174,172,187,164,0,172,167],
[174,172,183,172,164,169,0,173],
[155,168,192,186,174,174,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 475, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,150,138,230,187,186,177],
[185,0,177,184,175,185,155,180],
[191,164,0,187,245,270,204,178],
[203,157,154,0,171,179,166,179],
[111,166,96,170,0,161,115,126],
[154,156,71,162,180,0,139,129],
[155,186,137,175,226,202,0,232],
[164,161,163,162,215,212,109,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 476, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,177,184,171,165,177,166],
[162,0,163,171,168,155,178,173],
[164,178,0,175,174,175,177,180],
[157,170,166,0,166,173,176,170],
[170,173,167,175,0,176,180,171],
[176,186,166,168,165,0,173,169],
[164,163,164,165,161,168,0,168],
[175,168,161,171,170,172,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 477, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,155,160,164,154,178,160],
[180,0,180,170,173,173,186,171],
[186,161,0,176,180,173,196,169],
[181,171,165,0,181,172,192,179],
[177,168,161,160,0,165,193,175],
[187,168,168,169,176,0,203,186],
[163,155,145,149,148,138,0,143],
[181,170,172,162,166,155,198,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 478, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,169,188,178,150,181,174],
[185,0,169,200,192,174,198,204],
[172,172,0,204,175,164,192,181],
[153,141,137,0,148,124,167,148],
[163,149,166,193,0,159,197,158],
[191,167,177,217,182,0,188,172],
[160,143,149,174,144,153,0,143],
[167,137,160,193,183,169,198,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 479, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,154,202,173,157,181,182],
[165,0,197,171,194,173,187,132],
[187,144,0,167,158,125,181,180],
[139,170,174,0,200,154,187,210],
[168,147,183,141,0,149,213,182],
[184,168,216,187,192,0,208,203],
[160,154,160,154,128,133,0,143],
[159,209,161,131,159,138,198,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 480, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,200,207,181,170,202,198,199],
[141,0,166,180,168,172,175,173],
[134,175,0,156,158,186,173,164],
[160,161,185,0,185,184,183,181],
[171,173,183,156,0,179,178,168],
[139,169,155,157,162,0,183,176],
[143,166,168,158,163,158,0,156],
[142,168,177,160,173,165,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 481, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,161,157,160,185,176,155],
[166,0,162,142,149,171,133,167],
[180,179,0,160,198,209,177,147],
[184,199,181,0,162,171,165,147],
[181,192,143,179,0,228,167,195],
[156,170,132,170,113,0,154,141],
[165,208,164,176,174,187,0,154],
[186,174,194,194,146,200,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 482, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,190,162,164,150,169,173,187],
[151,0,170,157,133,148,175,169],
[179,171,0,182,175,171,169,182],
[177,184,159,0,156,147,153,166],
[191,208,166,185,0,166,169,188],
[172,193,170,194,175,0,169,192],
[168,166,172,188,172,172,0,185],
[154,172,159,175,153,149,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 483, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,173,184,169,168,179,179],
[169,0,171,171,179,161,183,186],
[168,170,0,172,166,170,182,176],
[157,170,169,0,171,177,186,176],
[172,162,175,170,0,175,185,186],
[173,180,171,164,166,0,173,192],
[162,158,159,155,156,168,0,162],
[162,155,165,165,155,149,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 484, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,187,181,168,190,178,172],
[155,0,159,167,163,165,169,152],
[154,182,0,172,168,164,165,164],
[160,174,169,0,170,175,172,166],
[173,178,173,171,0,169,169,170],
[151,176,177,166,172,0,171,176],
[163,172,176,169,172,170,0,172],
[169,189,177,175,171,165,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 485, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,180,185,184,163,182,183],
[180,0,186,193,189,170,193,155],
[161,155,0,173,175,157,179,149],
[156,148,168,0,178,149,164,157],
[157,152,166,163,0,172,179,173],
[178,171,184,192,169,0,200,168],
[159,148,162,177,162,141,0,145],
[158,186,192,184,168,173,196,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 486, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,184,195,201,192,202,178],
[182,0,168,176,165,177,184,174],
[157,173,0,167,159,173,162,172],
[146,165,174,0,171,180,194,165],
[140,176,182,170,0,183,169,161],
[149,164,168,161,158,0,172,172],
[139,157,179,147,172,169,0,152],
[163,167,169,176,180,169,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 487, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,188,164,170,191,177,186],
[164,0,177,166,174,176,164,159],
[153,164,0,164,167,173,160,173],
[177,175,177,0,164,189,173,173],
[171,167,174,177,0,190,177,167],
[150,165,168,152,151,0,178,164],
[164,177,181,168,164,163,0,166],
[155,182,168,168,174,177,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 488, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,173,177,180,171,166,170],
[178,0,178,166,182,176,170,174],
[168,163,0,190,188,178,184,183],
[164,175,151,0,172,170,176,163],
[161,159,153,169,0,179,152,158],
[170,165,163,171,162,0,162,173],
[175,171,157,165,189,179,0,170],
[171,167,158,178,183,168,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 489, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,161,154,179,163,165,160],
[172,0,176,171,174,169,176,165],
[180,165,0,168,184,172,177,176],
[187,170,173,0,192,170,180,180],
[162,167,157,149,0,144,165,155],
[178,172,169,171,197,0,183,188],
[176,165,164,161,176,158,0,158],
[181,176,165,161,186,153,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 490, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,145,170,154,154,167,177],
[172,0,171,178,185,154,167,178],
[196,170,0,164,168,187,176,160],
[171,163,177,0,168,159,171,191],
[187,156,173,173,0,179,177,191],
[187,187,154,182,162,0,183,173],
[174,174,165,170,164,158,0,173],
[164,163,181,150,150,168,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 491, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,143,174,162,144,151,157],
[187,0,175,202,156,187,196,177],
[198,166,0,176,178,168,187,182],
[167,139,165,0,160,155,162,164],
[179,185,163,181,0,166,157,156],
[197,154,173,186,175,0,159,182],
[190,145,154,179,184,182,0,177],
[184,164,159,177,185,159,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 492, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,140,168,131,156,154,167,134],
[201,0,198,162,195,193,170,142],
[173,143,0,149,169,166,178,166],
[210,179,192,0,176,161,182,170],
[185,146,172,165,0,138,147,162],
[187,148,175,180,203,0,189,187],
[174,171,163,159,194,152,0,161],
[207,199,175,171,179,154,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 493, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,194,175,165,183,172,188,196],
[147,0,170,175,187,155,161,165],
[166,171,0,165,185,175,169,181],
[176,166,176,0,169,165,174,162],
[158,154,156,172,0,170,174,160],
[169,186,166,176,171,0,181,174],
[153,180,172,167,167,160,0,177],
[145,176,160,179,181,167,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 494, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,177,157,166,167,151,153],
[181,0,184,168,158,193,157,164],
[164,157,0,141,148,164,155,141],
[184,173,200,0,169,191,185,177],
[175,183,193,172,0,178,172,168],
[174,148,177,150,163,0,153,154],
[190,184,186,156,169,188,0,159],
[188,177,200,164,173,187,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 495, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,148,184,129,163,167,187,157],
[193,0,176,157,179,176,200,193],
[157,165,0,169,168,175,189,169],
[212,184,172,0,165,173,199,200],
[178,162,173,176,0,174,192,182],
[174,165,166,168,167,0,178,185],
[154,141,152,142,149,163,0,179],
[184,148,172,141,159,156,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 496, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,147,162,169,159,170,173,148],
[194,0,192,183,168,186,181,190],
[179,149,0,173,177,161,173,179],
[172,158,168,0,165,165,167,162],
[182,173,164,176,0,167,179,186],
[171,155,180,176,174,0,172,186],
[168,160,168,174,162,169,0,174],
[193,151,162,179,155,155,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 497, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,255,159,180,163,288,226,227],
[86,0,99,183,199,209,228,148],
[182,242,0,247,156,271,218,227],
[161,158,94,0,130,190,160,285],
[178,142,185,211,0,257,132,225],
[53,132,70,151,84,0,132,145],
[115,113,123,181,209,209,0,211],
[114,193,114,56,116,196,130,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 498, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,149,153,168,172,167,153,153],
[192,0,158,172,190,189,174,182],
[188,183,0,183,188,170,172,179],
[173,169,158,0,178,164,165,171],
[169,151,153,163,0,159,153,157],
[174,152,171,177,182,0,154,171],
[188,167,169,176,188,187,0,171],
[188,159,162,170,184,170,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 499, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,156,169,173,145,163,180],
[168,0,168,175,158,136,167,173],
[185,173,0,186,176,171,168,177],
[172,166,155,0,158,159,161,173],
[168,183,165,183,0,149,167,185],
[196,205,170,182,192,0,172,182],
[178,174,173,180,174,169,0,176],
[161,168,164,168,156,159,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 500, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,117,139,196,162,173,139,143],
[224,0,162,147,224,237,237,241],
[202,179,0,166,220,124,233,192],
[145,194,175,0,194,165,126,220],
[179,117,121,147,0,147,147,143],
[168,104,217,176,194,0,168,153],
[202,104,108,215,194,173,0,166],
[198,100,149,121,198,188,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 501, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,184,171,180,187,159,163],
[152,0,170,175,185,158,173,171],
[157,171,0,161,174,171,160,153],
[170,166,180,0,191,189,170,169],
[161,156,167,150,0,175,165,160],
[154,183,170,152,166,0,177,178],
[182,168,181,171,176,164,0,185],
[178,170,188,172,181,163,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 502, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,182,176,169,172,153,181],
[174,0,167,181,158,157,144,180],
[159,174,0,170,157,158,154,188],
[165,160,171,0,172,162,150,196],
[172,183,184,169,0,145,159,176],
[169,184,183,179,196,0,171,196],
[188,197,187,191,182,170,0,195],
[160,161,153,145,165,145,146,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 503, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,174,152,177,170,138,181],
[161,0,176,176,192,191,138,201],
[167,165,0,175,187,187,175,195],
[189,165,166,0,180,176,159,184],
[164,149,154,161,0,166,115,190],
[171,150,154,165,175,0,169,201],
[203,203,166,182,226,172,0,206],
[160,140,146,157,151,140,135,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 504, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,174,152,168,153,176,163],
[150,0,149,159,172,150,152,152],
[167,192,0,175,186,160,162,161],
[189,182,166,0,181,185,176,163],
[173,169,155,160,0,142,141,168],
[188,191,181,156,199,0,174,176],
[165,189,179,165,200,167,0,175],
[178,189,180,178,173,165,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 505, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,195,182,183,197,170,166,182],
[146,0,150,161,193,175,164,177],
[159,191,0,179,196,163,158,171],
[158,180,162,0,200,160,163,176],
[144,148,145,141,0,153,143,154],
[171,166,178,181,188,0,171,165],
[175,177,183,178,198,170,0,164],
[159,164,170,165,187,176,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 506, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,197,178,165,200,206,191,179],
[144,0,188,180,158,219,164,161],
[163,153,0,171,165,190,194,149],
[176,161,170,0,165,176,180,154],
[141,183,176,176,0,188,165,174],
[135,122,151,165,153,0,158,129],
[150,177,147,161,176,183,0,165],
[162,180,192,187,167,212,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 507, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,169,179,167,177,159,180],
[171,0,181,158,170,171,178,182],
[172,160,0,158,181,152,156,166],
[162,183,183,0,185,175,170,183],
[174,171,160,156,0,156,169,173],
[164,170,189,166,185,0,166,163],
[182,163,185,171,172,175,0,184],
[161,159,175,158,168,178,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 508, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,160,163,153,167,176,167],
[171,0,159,161,163,160,169,155],
[181,182,0,178,175,169,170,173],
[178,180,163,0,165,175,177,174],
[188,178,166,176,0,187,181,173],
[174,181,172,166,154,0,168,163],
[165,172,171,164,160,173,0,163],
[174,186,168,167,168,178,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 509, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,216,157,158,219,168,184,186],
[125,0,131,171,193,155,159,173],
[184,210,0,166,207,186,171,192],
[183,170,175,0,193,161,172,175],
[122,148,134,148,0,155,141,158],
[173,186,155,180,186,0,186,196],
[157,182,170,169,200,155,0,151],
[155,168,149,166,183,145,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 510, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,184,163,183,188,151,168],
[166,0,158,175,188,208,177,194],
[157,183,0,196,150,191,169,190],
[178,166,145,0,166,180,165,181],
[158,153,191,175,0,180,142,191],
[153,133,150,161,161,0,151,176],
[190,164,172,176,199,190,0,191],
[173,147,151,160,150,165,150,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 511, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,270,205,261,184,269,262,142],
[71,0,154,203,133,186,140,103],
[136,187,0,219,124,219,231,148],
[80,138,122,0,122,174,245,146],
[157,208,217,219,0,223,308,197],
[72,155,122,167,118,0,167,184],
[79,201,110,96,33,174,0,109],
[199,238,193,195,144,157,232,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 512, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,139,171,180,163,145,178],
[182,0,175,168,186,176,170,166],
[202,166,0,145,179,158,155,168],
[170,173,196,0,185,175,165,199],
[161,155,162,156,0,144,142,162],
[178,165,183,166,197,0,183,208],
[196,171,186,176,199,158,0,165],
[163,175,173,142,179,133,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 513, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,168,169,155,171,175,165],
[177,0,175,172,152,163,183,170],
[173,166,0,166,174,161,173,157],
[172,169,175,0,168,182,173,165],
[186,189,167,173,0,182,188,180],
[170,178,180,159,159,0,201,171],
[166,158,168,168,153,140,0,151],
[176,171,184,176,161,170,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 514, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,171,182,162,184,183,181],
[156,0,167,183,178,156,172,166],
[170,174,0,182,168,187,176,173],
[159,158,159,0,159,173,171,169],
[179,163,173,182,0,184,192,180],
[157,185,154,168,157,0,166,173],
[158,169,165,170,149,175,0,186],
[160,175,168,172,161,168,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 515, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,163,170,189,171,194,168],
[186,0,182,174,183,159,188,181],
[178,159,0,183,189,165,195,192],
[171,167,158,0,170,158,187,182],
[152,158,152,171,0,149,166,166],
[170,182,176,183,192,0,186,170],
[147,153,146,154,175,155,0,167],
[173,160,149,159,175,171,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 516, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,187,157,158,165,173,156],
[172,0,178,168,172,172,162,160],
[154,163,0,158,169,172,172,173],
[184,173,183,0,177,189,182,155],
[183,169,172,164,0,188,158,180],
[176,169,169,152,153,0,174,153],
[168,179,169,159,183,167,0,169],
[185,181,168,186,161,188,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 517, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,189,171,186,197,168,182],
[169,0,185,173,177,179,162,176],
[152,156,0,162,172,174,162,168],
[170,168,179,0,186,183,171,180],
[155,164,169,155,0,165,169,169],
[144,162,167,158,176,0,157,176],
[173,179,179,170,172,184,0,172],
[159,165,173,161,172,165,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 518, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,162,157,168,143,166,164],
[165,0,179,163,168,169,182,168],
[179,162,0,135,146,153,159,157],
[184,178,206,0,178,172,175,160],
[173,173,195,163,0,152,159,147],
[198,172,188,169,189,0,195,202],
[175,159,182,166,182,146,0,169],
[177,173,184,181,194,139,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 519, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,169,147,153,142,156,180],
[155,0,152,157,169,164,149,163],
[172,189,0,176,180,197,159,160],
[194,184,165,0,170,184,163,171],
[188,172,161,171,0,175,179,158],
[199,177,144,157,166,0,160,170],
[185,192,182,178,162,181,0,187],
[161,178,181,170,183,171,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 520, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,210,215,167,173,182,195],
[170,0,185,166,199,163,176,187],
[131,156,0,164,181,167,159,176],
[126,175,177,0,171,148,150,159],
[174,142,160,170,0,142,158,200],
[168,178,174,193,199,0,173,184],
[159,165,182,191,183,168,0,172],
[146,154,165,182,141,157,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 521, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,192,183,171,154,149,159],
[173,0,182,163,172,164,164,171],
[149,159,0,159,170,151,167,154],
[158,178,182,0,189,160,175,170],
[170,169,171,152,0,175,180,164],
[187,177,190,181,166,0,175,176],
[192,177,174,166,161,166,0,168],
[182,170,187,171,177,165,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 522, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,148,138,156,116,185,134,162],
[193,0,160,177,149,189,145,184],
[203,181,0,150,164,193,173,196],
[185,164,191,0,185,214,189,201],
[225,192,177,156,0,215,198,189],
[156,152,148,127,126,0,146,188],
[207,196,168,152,143,195,0,175],
[179,157,145,140,152,153,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 523, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,178,169,168,183,184,181],
[170,0,182,169,180,189,184,181],
[163,159,0,180,160,171,166,178],
[172,172,161,0,171,176,176,177],
[173,161,181,170,0,177,180,192],
[158,152,170,165,164,0,168,178],
[157,157,175,165,161,173,0,160],
[160,160,163,164,149,163,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 524, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,137,202,189,194,176,217,212],
[204,0,143,99,135,117,176,117],
[139,198,0,147,210,124,165,110],
[152,242,194,0,176,222,263,204],
[147,206,131,165,0,164,211,106],
[165,224,217,119,177,0,237,146],
[124,165,176,78,130,104,0,110],
[129,224,231,137,235,195,231,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 525, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,166,163,169,162,171,157],
[179,0,171,165,191,208,195,182],
[175,170,0,181,179,193,188,187],
[178,176,160,0,178,186,182,176],
[172,150,162,163,0,172,179,158],
[179,133,148,155,169,0,174,163],
[170,146,153,159,162,167,0,163],
[184,159,154,165,183,178,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 526, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,170,173,176,175,154,160],
[178,0,166,163,176,180,171,170],
[171,175,0,188,185,179,167,178],
[168,178,153,0,197,186,154,160],
[165,165,156,144,0,176,157,157],
[166,161,162,155,165,0,142,160],
[187,170,174,187,184,199,0,188],
[181,171,163,181,184,181,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 527, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,159,175,192,156,179,149],
[178,0,152,186,176,166,166,179],
[182,189,0,185,185,173,176,163],
[166,155,156,0,175,179,150,169],
[149,165,156,166,0,161,154,164],
[185,175,168,162,180,0,154,171],
[162,175,165,191,187,187,0,172],
[192,162,178,172,177,170,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 528, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,162,153,172,171,180,179],
[176,0,187,166,165,175,176,186],
[179,154,0,164,163,164,175,182],
[188,175,177,0,164,183,167,175],
[169,176,178,177,0,182,176,180],
[170,166,177,158,159,0,167,175],
[161,165,166,174,165,174,0,177],
[162,155,159,166,161,166,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 529, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,203,187,201,221,230,176],
[177,0,190,159,126,186,165,189],
[138,151,0,140,177,181,179,150],
[154,182,201,0,144,173,179,128],
[140,215,164,197,0,194,209,194],
[120,155,160,168,147,0,181,129],
[111,176,162,162,132,160,0,146],
[165,152,191,213,147,212,195,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 530, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,177,168,179,176,215,156],
[166,0,187,178,160,154,224,154],
[164,154,0,138,173,145,189,174],
[173,163,203,0,159,215,197,182],
[162,181,168,182,0,170,210,157],
[165,187,196,126,171,0,177,123],
[126,117,152,144,131,164,0,153],
[185,187,167,159,184,218,188,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 531, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,119,104,134,76,156,197,106],
[222,0,84,87,183,203,235,86],
[237,257,0,169,203,235,167,180],
[207,254,172,0,203,237,205,128],
[265,158,138,138,0,127,187,129],
[185,138,106,104,214,0,217,112],
[144,106,174,136,154,124,0,149],
[235,255,161,213,212,229,192,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 532, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,161,161,166,156,152,162],
[175,0,158,163,157,156,154,155],
[180,183,0,168,173,178,161,172],
[180,178,173,0,184,163,174,171],
[175,184,168,157,0,160,166,173],
[185,185,163,178,181,0,174,191],
[189,187,180,167,175,167,0,171],
[179,186,169,170,168,150,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 533, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,156,176,152,156,142,174],
[170,0,179,177,170,168,173,169],
[185,162,0,166,173,186,163,170],
[165,164,175,0,166,176,153,179],
[189,171,168,175,0,181,156,173],
[185,173,155,165,160,0,149,169],
[199,168,178,188,185,192,0,190],
[167,172,171,162,168,172,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 534, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,156,180,155,168,183,177],
[161,0,172,184,182,190,191,186],
[185,169,0,191,186,177,196,186],
[161,157,150,0,156,161,162,147],
[186,159,155,185,0,183,199,180],
[173,151,164,180,158,0,166,168],
[158,150,145,179,142,175,0,174],
[164,155,155,194,161,173,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 535, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,177,167,173,172,192,181],
[182,0,185,170,164,171,163,166],
[164,156,0,162,164,163,159,155],
[174,171,179,0,177,169,173,165],
[168,177,177,164,0,166,168,154],
[169,170,178,172,175,0,165,173],
[149,178,182,168,173,176,0,168],
[160,175,186,176,187,168,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 536, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,196,173,183,163,172,201,201],
[145,0,143,211,163,151,235,191],
[168,198,0,123,124,168,241,222],
[158,130,218,0,191,197,222,254],
[178,178,217,150,0,217,249,266],
[169,190,173,144,124,0,191,222],
[140,106,100,119,92,150,0,207],
[140,150,119,87,75,119,134,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 537, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,176,183,178,191,179,186],
[172,0,192,166,161,184,198,191],
[165,149,0,178,169,171,177,189],
[158,175,163,0,164,170,179,184],
[163,180,172,177,0,170,183,181],
[150,157,170,171,171,0,180,167],
[162,143,164,162,158,161,0,158],
[155,150,152,157,160,174,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 538, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,144,153,127,152,161,166,170],
[197,0,158,149,142,153,129,166],
[188,183,0,156,171,157,168,137],
[214,192,185,0,163,193,210,194],
[189,199,170,178,0,183,181,174],
[180,188,184,148,158,0,152,163],
[175,212,173,131,160,189,0,172],
[171,175,204,147,167,178,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 539, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,168,183,161,192,191,176],
[157,0,197,180,157,179,197,159],
[173,144,0,146,157,172,160,164],
[158,161,195,0,161,191,171,168],
[180,184,184,180,0,183,159,168],
[149,162,169,150,158,0,156,165],
[150,144,181,170,182,185,0,157],
[165,182,177,173,173,176,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 540, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,155,157,179,167,147,170],
[182,0,183,161,177,191,161,178],
[186,158,0,145,167,181,165,158],
[184,180,196,0,170,180,180,171],
[162,164,174,171,0,177,162,178],
[174,150,160,161,164,0,159,180],
[194,180,176,161,179,182,0,189],
[171,163,183,170,163,161,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 541, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,165,163,169,163,166,154],
[164,0,162,179,171,166,155,159],
[176,179,0,178,188,164,188,164],
[178,162,163,0,172,160,158,163],
[172,170,153,169,0,165,162,156],
[178,175,177,181,176,0,167,164],
[175,186,153,183,179,174,0,176],
[187,182,177,178,185,177,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 542, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,163,157,159,162,181,160],
[163,0,166,162,172,167,175,162],
[178,175,0,159,159,161,179,162],
[184,179,182,0,162,170,176,166],
[182,169,182,179,0,171,178,172],
[179,174,180,171,170,0,176,168],
[160,166,162,165,163,165,0,157],
[181,179,179,175,169,173,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 543, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,197,180,160,147,130,161,257],
[144,0,195,144,115,124,83,209],
[161,146,0,180,171,209,148,177],
[181,197,161,0,160,154,138,230],
[194,226,170,181,0,235,146,212],
[211,217,132,187,106,0,171,179],
[180,258,193,203,195,170,0,290],
[84,132,164,111,129,162,51,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 544, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,149,175,155,153,154,158,172],
[192,0,191,170,183,161,178,180],
[166,150,0,150,169,172,169,176],
[186,171,191,0,172,177,165,190],
[188,158,172,169,0,164,169,190],
[187,180,169,164,177,0,185,182],
[183,163,172,176,172,156,0,174],
[169,161,165,151,151,159,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 545, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,168,174,177,147,154,171],
[171,0,176,168,177,148,140,155],
[173,165,0,183,184,189,160,185],
[167,173,158,0,179,165,150,148],
[164,164,157,162,0,143,150,171],
[194,193,152,176,198,0,171,205],
[187,201,181,191,191,170,0,187],
[170,186,156,193,170,136,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 546, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,185,177,186,159,166,185],
[171,0,167,166,168,170,177,174],
[156,174,0,167,165,161,173,176],
[164,175,174,0,176,160,177,213],
[155,173,176,165,0,180,167,200],
[182,171,180,181,161,0,168,202],
[175,164,168,164,174,173,0,192],
[156,167,165,128,141,139,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 547, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,145,176,179,164,177,157,177],
[196,0,162,183,179,188,179,196],
[165,179,0,174,167,203,161,173],
[162,158,167,0,172,186,156,170],
[177,162,174,169,0,163,151,183],
[164,153,138,155,178,0,161,176],
[184,162,180,185,190,180,0,177],
[164,145,168,171,158,165,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 548, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,166,177,163,175,176,177],
[160,0,157,162,155,152,157,166],
[175,184,0,182,170,165,169,178],
[164,179,159,0,174,157,161,167],
[178,186,171,167,0,172,167,181],
[166,189,176,184,169,0,176,172],
[165,184,172,180,174,165,0,187],
[164,175,163,174,160,169,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 549, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,175,159,164,162,185,173],
[177,0,171,164,168,162,170,181],
[166,170,0,155,159,163,152,162],
[182,177,186,0,165,169,173,171],
[177,173,182,176,0,174,168,169],
[179,179,178,172,167,0,172,169],
[156,171,189,168,173,169,0,169],
[168,160,179,170,172,172,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 550, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,193,193,166,191,161,184],
[155,0,168,138,160,149,171,173],
[148,173,0,170,145,160,169,160],
[148,203,171,0,163,163,156,183],
[175,181,196,178,0,183,172,164],
[150,192,181,178,158,0,169,168],
[180,170,172,185,169,172,0,179],
[157,168,181,158,177,173,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 551, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,149,155,153,150,176,165],
[168,0,162,160,167,161,173,167],
[192,179,0,177,180,162,187,177],
[186,181,164,0,167,172,188,176],
[188,174,161,174,0,157,174,168],
[191,180,179,169,184,0,194,170],
[165,168,154,153,167,147,0,161],
[176,174,164,165,173,171,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 552, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,168,158,177,157,187,165],
[168,0,149,176,186,168,178,166],
[173,192,0,170,193,188,191,171],
[183,165,171,0,183,175,180,174],
[164,155,148,158,0,140,156,151],
[184,173,153,166,201,0,177,176],
[154,163,150,161,185,164,0,167],
[176,175,170,167,190,165,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 553, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,181,164,157,155,177,170],
[173,0,182,164,150,166,191,165],
[160,159,0,165,143,158,145,145],
[177,177,176,0,150,169,176,165],
[184,191,198,191,0,167,191,178],
[186,175,183,172,174,0,184,167],
[164,150,196,165,150,157,0,161],
[171,176,196,176,163,174,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 554, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,193,170,156,173,194,161,157],
[148,0,153,130,153,166,154,147],
[171,188,0,154,177,171,179,168],
[185,211,187,0,182,190,192,165],
[168,188,164,159,0,167,181,135],
[147,175,170,151,174,0,161,182],
[180,187,162,149,160,180,0,160],
[184,194,173,176,206,159,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 555, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,173,184,164,164,176,193],
[176,0,168,189,158,204,202,176],
[168,173,0,183,158,154,180,178],
[157,152,158,0,172,151,151,186],
[177,183,183,169,0,185,194,189],
[177,137,187,190,156,0,184,182],
[165,139,161,190,147,157,0,178],
[148,165,163,155,152,159,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 556, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,181,164,152,152,164,163],
[162,0,156,144,152,146,165,147],
[160,185,0,157,146,150,167,166],
[177,197,184,0,173,194,168,194],
[189,189,195,168,0,175,165,176],
[189,195,191,147,166,0,182,169],
[177,176,174,173,176,159,0,173],
[178,194,175,147,165,172,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 557, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,155,189,130,147,159,147],
[183,0,145,188,151,147,168,168],
[186,196,0,211,173,174,158,182],
[152,153,130,0,130,138,155,124],
[211,190,168,211,0,168,174,179],
[194,194,167,203,173,0,190,173],
[182,173,183,186,167,151,0,164],
[194,173,159,217,162,168,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 558, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,155,161,185,152,158,161],
[163,0,140,150,170,142,154,144],
[186,201,0,189,188,151,178,170],
[180,191,152,0,184,159,164,164],
[156,171,153,157,0,146,147,143],
[189,199,190,182,195,0,182,166],
[183,187,163,177,194,159,0,174],
[180,197,171,177,198,175,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 559, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,185,148,163,169,180,166],
[185,0,188,161,181,152,164,159],
[156,153,0,144,154,174,150,180],
[193,180,197,0,174,161,164,194],
[178,160,187,167,0,187,161,168],
[172,189,167,180,154,0,182,183],
[161,177,191,177,180,159,0,196],
[175,182,161,147,173,158,145,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 560, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,161,150,160,164,166,153],
[181,0,168,172,188,188,176,190],
[180,173,0,174,182,168,178,197],
[191,169,167,0,175,178,176,177],
[181,153,159,166,0,167,173,165],
[177,153,173,163,174,0,175,175],
[175,165,163,165,168,166,0,181],
[188,151,144,164,176,166,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 561, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,211,197,203,160,191,201,189],
[130,0,148,168,169,150,173,182],
[144,193,0,192,196,194,189,230],
[138,173,149,0,171,192,164,174],
[181,172,145,170,0,165,173,189],
[150,191,147,149,176,0,175,207],
[140,168,152,177,168,166,0,154],
[152,159,111,167,152,134,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 562, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,167,203,151,182,184,168],
[188,0,183,213,166,183,181,172],
[174,158,0,208,161,189,195,158],
[138,128,133,0,147,166,170,145],
[190,175,180,194,0,183,182,164],
[159,158,152,175,158,0,167,146],
[157,160,146,171,159,174,0,152],
[173,169,183,196,177,195,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 563, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,173,189,183,192,161,193],
[159,0,155,166,169,185,180,203],
[168,186,0,180,179,188,191,201],
[152,175,161,0,156,177,170,179],
[158,172,162,185,0,171,167,202],
[149,156,153,164,170,0,175,184],
[180,161,150,171,174,166,0,193],
[148,138,140,162,139,157,148,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 564, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,160,157,169,144,166,141],
[167,0,170,169,146,142,158,151],
[181,171,0,165,157,141,168,163],
[184,172,176,0,152,158,162,163],
[172,195,184,189,0,171,188,163],
[197,199,200,183,170,0,187,173],
[175,183,173,179,153,154,0,169],
[200,190,178,178,178,168,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 565, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,172,183,179,155,170,173],
[187,0,197,182,186,172,161,173],
[169,144,0,153,156,163,150,170],
[158,159,188,0,157,153,187,171],
[162,155,185,184,0,138,183,167],
[186,169,178,188,203,0,181,204],
[171,180,191,154,158,160,0,203],
[168,168,171,170,174,137,138,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 566, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,172,180,161,178,194,177],
[176,0,160,180,173,167,186,179],
[169,181,0,178,156,173,182,174],
[161,161,163,0,156,172,170,170],
[180,168,185,185,0,199,179,177],
[163,174,168,169,142,0,158,169],
[147,155,159,171,162,183,0,171],
[164,162,167,171,164,172,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 567, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,182,162,205,177,176,187],
[164,0,175,165,196,172,188,196],
[159,166,0,163,214,169,161,178],
[179,176,178,0,185,158,178,191],
[136,145,127,156,0,142,158,172],
[164,169,172,183,199,0,171,184],
[165,153,180,163,183,170,0,199],
[154,145,163,150,169,157,142,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 568, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,209,173,226,171,142,220,196],
[132,0,133,163,128,137,142,186],
[168,208,0,198,178,206,234,224],
[115,178,143,0,151,180,185,157],
[170,213,163,190,0,183,167,188],
[199,204,135,161,158,0,205,184],
[121,199,107,156,174,136,0,152],
[145,155,117,184,153,157,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 569, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,162,172,160,177,169,172],
[172,0,164,185,162,181,170,170],
[179,177,0,156,183,165,157,157],
[169,156,185,0,179,181,170,179],
[181,179,158,162,0,164,153,154],
[164,160,176,160,177,0,150,189],
[172,171,184,171,188,191,0,170],
[169,171,184,162,187,152,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 570, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,158,165,156,152,168,149],
[183,0,184,169,166,174,177,174],
[183,157,0,172,168,172,163,161],
[176,172,169,0,172,180,173,169],
[185,175,173,169,0,166,175,169],
[189,167,169,161,175,0,181,183],
[173,164,178,168,166,160,0,161],
[192,167,180,172,172,158,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 571, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,193,160,164,180,169,172,172],
[148,0,165,151,167,134,158,157],
[181,176,0,188,158,170,182,181],
[177,190,153,0,183,168,168,143],
[161,174,183,158,0,168,165,157],
[172,207,171,173,173,0,175,169],
[169,183,159,173,176,166,0,156],
[169,184,160,198,184,172,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 572, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,170,200,175,193,197,152],
[155,0,153,171,163,167,180,138],
[171,188,0,169,150,151,199,177],
[141,170,172,0,158,161,159,132],
[166,178,191,183,0,176,190,143],
[148,174,190,180,165,0,174,151],
[144,161,142,182,151,167,0,141],
[189,203,164,209,198,190,200,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 573, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,63,186,195,144,240,102],
[182,0,162,180,195,177,263,243],
[278,179,0,201,215,167,250,161],
[155,161,140,0,68,32,239,152],
[146,146,126,273,0,122,284,133],
[197,164,174,309,219,0,290,165],
[101,78,91,102,57,51,0,107],
[239,98,180,189,208,176,234,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 574, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,153,170,174,175,167,180],
[172,0,155,178,154,169,170,169],
[188,186,0,188,169,183,173,179],
[171,163,153,0,158,166,147,181],
[167,187,172,183,0,173,163,192],
[166,172,158,175,168,0,167,188],
[174,171,168,194,178,174,0,178],
[161,172,162,160,149,153,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 575, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,168,158,175,179,167,181],
[174,0,179,168,181,169,179,191],
[173,162,0,160,175,175,168,181],
[183,173,181,0,185,174,164,195],
[166,160,166,156,0,141,163,164],
[162,172,166,167,200,0,162,175],
[174,162,173,177,178,179,0,172],
[160,150,160,146,177,166,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 576, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,176,199,184,191,179,164],
[164,0,152,196,173,178,158,159],
[165,189,0,197,181,181,189,178],
[142,145,144,0,160,164,144,139],
[157,168,160,181,0,163,170,165],
[150,163,160,177,178,0,165,155],
[162,183,152,197,171,176,0,167],
[177,182,163,202,176,186,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 577, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,165,173,175,177,181,171],
[180,0,177,167,174,164,177,182],
[176,164,0,169,165,154,168,166],
[168,174,172,0,163,181,189,163],
[166,167,176,178,0,188,181,167],
[164,177,187,160,153,0,175,165],
[160,164,173,152,160,166,0,151],
[170,159,175,178,174,176,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 578, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,177,179,168,162,154,191],
[170,0,180,178,162,166,163,170],
[164,161,0,184,172,156,180,184],
[162,163,157,0,165,163,160,167],
[173,179,169,176,0,170,172,185],
[179,175,185,178,171,0,168,188],
[187,178,161,181,169,173,0,186],
[150,171,157,174,156,153,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 579, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,152,149,195,170,156,131],
[163,0,154,123,166,153,148,130],
[189,187,0,140,209,165,157,169],
[192,218,201,0,194,168,175,180],
[146,175,132,147,0,133,143,105],
[171,188,176,173,208,0,172,153],
[185,193,184,166,198,169,0,184],
[210,211,172,161,236,188,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 580, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,158,177,140,187,157,164],
[183,0,160,182,162,197,151,160],
[183,181,0,206,165,204,190,167],
[164,159,135,0,130,184,143,157],
[201,179,176,211,0,225,155,180],
[154,144,137,157,116,0,126,118],
[184,190,151,198,186,215,0,154],
[177,181,174,184,161,223,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 581, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,207,187,174,176,169,179,180],
[134,0,175,127,147,144,164,148],
[154,166,0,143,163,155,175,176],
[167,214,198,0,189,171,194,178],
[165,194,178,152,0,155,200,191],
[172,197,186,170,186,0,173,169],
[162,177,166,147,141,168,0,168],
[161,193,165,163,150,172,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 582, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,164,166,172,161,165,158],
[173,0,179,170,166,163,177,175],
[177,162,0,175,170,172,173,160],
[175,171,166,0,168,165,178,161],
[169,175,171,173,0,171,160,155],
[180,178,169,176,170,0,176,173],
[176,164,168,163,181,165,0,158],
[183,166,181,180,186,168,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 583, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,171,201,160,173,184,178],
[174,0,179,197,165,167,190,178],
[170,162,0,175,160,168,171,171],
[140,144,166,0,149,163,180,182],
[181,176,181,192,0,162,189,178],
[168,174,173,178,179,0,204,185],
[157,151,170,161,152,137,0,164],
[163,163,170,159,163,156,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 584, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,234,144,143,145,218,159],
[184,0,227,170,163,148,237,187],
[107,114,0,106,91,116,197,147],
[197,171,235,0,188,138,253,171],
[198,178,250,153,0,230,261,220],
[196,193,225,203,111,0,251,176],
[123,104,144,88,80,90,0,116],
[182,154,194,170,121,165,225,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 585, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,126,226,157,183,154,180,180],
[215,0,229,236,195,214,177,158],
[115,112,0,118,97,179,148,128],
[184,105,223,0,209,168,192,138],
[158,146,244,132,0,153,188,93],
[187,127,162,173,188,0,157,187],
[161,164,193,149,153,184,0,149],
[161,183,213,203,248,154,192,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 586, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,179,176,182,190,174,161],
[159,0,144,167,186,182,158,167],
[162,197,0,170,177,204,178,189],
[165,174,171,0,183,178,172,174],
[159,155,164,158,0,184,171,163],
[151,159,137,163,157,0,163,170],
[167,183,163,169,170,178,0,177],
[180,174,152,167,178,171,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 587, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,129,149,133,159,187,176],
[176,0,145,116,130,134,179,132],
[212,196,0,183,232,189,230,154],
[192,225,158,0,189,189,219,188],
[208,211,109,152,0,155,194,157],
[182,207,152,152,186,0,175,179],
[154,162,111,122,147,166,0,142],
[165,209,187,153,184,162,199,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 588, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,160,177,159,197,161,138],
[155,0,164,158,171,173,179,184],
[181,177,0,156,185,188,165,169],
[164,183,185,0,166,184,157,138],
[182,170,156,175,0,192,164,154],
[144,168,153,157,149,0,138,147],
[180,162,176,184,177,203,0,165],
[203,157,172,203,187,194,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 589, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,165,169,179,178,176,170],
[164,0,165,167,185,183,177,178],
[176,176,0,173,181,173,176,169],
[172,174,168,0,175,176,186,175],
[162,156,160,166,0,166,171,163],
[163,158,168,165,175,0,166,169],
[165,164,165,155,170,175,0,180],
[171,163,172,166,178,172,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 590, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,152,174,172,167,177,151],
[176,0,168,178,168,170,169,164],
[189,173,0,184,170,174,181,176],
[167,163,157,0,170,172,169,150],
[169,173,171,171,0,166,177,151],
[174,171,167,169,175,0,161,171],
[164,172,160,172,164,180,0,160],
[190,177,165,191,190,170,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 591, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,164,174,172,161,173,164],
[171,0,156,180,180,175,174,183],
[177,185,0,165,171,184,177,173],
[167,161,176,0,166,154,173,161],
[169,161,170,175,0,169,153,174],
[180,166,157,187,172,0,153,159],
[168,167,164,168,188,188,0,163],
[177,158,168,180,167,182,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 592, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,168,188,187,166,187,175],
[161,0,156,160,167,177,163,157],
[173,185,0,192,179,191,192,165],
[153,181,149,0,169,170,173,145],
[154,174,162,172,0,183,172,156],
[175,164,150,171,158,0,162,149],
[154,178,149,168,169,179,0,152],
[166,184,176,196,185,192,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 593, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,181,172,169,187,190,181],
[168,0,175,164,172,188,190,186],
[160,166,0,155,162,172,179,170],
[169,177,186,0,187,189,190,182],
[172,169,179,154,0,171,176,184],
[154,153,169,152,170,0,164,174],
[151,151,162,151,165,177,0,177],
[160,155,171,159,157,167,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 594, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,159,155,167,157,161,162],
[174,0,175,171,168,169,165,176],
[182,166,0,161,168,165,169,170],
[186,170,180,0,174,171,167,180],
[174,173,173,167,0,164,163,183],
[184,172,176,170,177,0,181,178],
[180,176,172,174,178,160,0,173],
[179,165,171,161,158,163,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 595, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,151,190,203,188,200,194],
[166,0,163,184,199,166,165,189],
[190,178,0,166,219,170,190,177],
[151,157,175,0,195,154,176,170],
[138,142,122,146,0,161,156,156],
[153,175,171,187,180,0,213,193],
[141,176,151,165,185,128,0,176],
[147,152,164,171,185,148,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 596, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,168,168,179,149,181,151],
[181,0,173,171,189,159,188,162],
[173,168,0,165,186,158,172,160],
[173,170,176,0,182,172,175,164],
[162,152,155,159,0,150,177,158],
[192,182,183,169,191,0,186,181],
[160,153,169,166,164,155,0,160],
[190,179,181,177,183,160,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 597, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,172,168,176,192,167,177],
[174,0,161,177,176,174,161,165],
[169,180,0,182,189,188,169,185],
[173,164,159,0,176,178,155,175],
[165,165,152,165,0,178,173,162],
[149,167,153,163,163,0,168,169],
[174,180,172,186,168,173,0,173],
[164,176,156,166,179,172,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 598, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,197,165,174,154,194,166,166],
[144,0,138,139,124,142,127,159],
[176,203,0,170,138,146,164,174],
[167,202,171,0,134,160,187,174],
[187,217,203,207,0,196,154,171],
[147,199,195,181,145,0,190,149],
[175,214,177,154,187,151,0,179],
[175,182,167,167,170,192,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 599, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,129,139,154,162,159,158,165],
[212,0,183,186,178,156,177,195],
[202,158,0,190,164,157,169,181],
[187,155,151,0,147,145,177,178],
[179,163,177,194,0,144,154,169],
[182,185,184,196,197,0,190,158],
[183,164,172,164,187,151,0,174],
[176,146,160,163,172,183,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 600, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,166,163,180,143,156,162],
[174,0,162,185,190,176,197,187],
[175,179,0,167,185,174,177,170],
[178,156,174,0,188,168,174,179],
[161,151,156,153,0,152,150,158],
[198,165,167,173,189,0,168,172],
[185,144,164,167,191,173,0,175],
[179,154,171,162,183,169,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 601, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,177,185,181,190,170,152],
[149,0,184,181,193,196,197,193],
[164,157,0,158,189,176,161,176],
[156,160,183,0,161,175,185,173],
[160,148,152,180,0,151,151,186],
[151,145,165,166,190,0,188,144],
[171,144,180,156,190,153,0,182],
[189,148,165,168,155,197,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 602, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,171,177,155,162,172,159],
[163,0,171,165,151,154,175,167],
[170,170,0,169,162,164,169,177],
[164,176,172,0,167,163,178,173],
[186,190,179,174,0,165,180,172],
[179,187,177,178,176,0,185,170],
[169,166,172,163,161,156,0,162],
[182,174,164,168,169,171,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 603, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,175,177,164,171,190,185],
[184,0,178,182,187,168,190,200],
[166,163,0,164,149,166,172,174],
[164,159,177,0,184,180,182,188],
[177,154,192,157,0,172,186,189],
[170,173,175,161,169,0,183,181],
[151,151,169,159,155,158,0,165],
[156,141,167,153,152,160,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 604, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,211,172,126,190,154,166,148],
[130,0,179,184,87,171,166,140],
[169,162,0,150,141,165,161,210],
[215,157,191,0,135,157,189,225],
[151,254,200,206,0,192,156,200],
[187,170,176,184,149,0,183,228],
[175,175,180,152,185,158,0,152],
[193,201,131,116,141,113,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 605, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,169,163,148,173,169,165],
[185,0,181,178,163,166,173,170],
[172,160,0,160,154,169,158,155],
[178,163,181,0,173,181,185,158],
[193,178,187,168,0,189,181,182],
[168,175,172,160,152,0,159,148],
[172,168,183,156,160,182,0,162],
[176,171,186,183,159,193,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 606, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,180,171,134,163,167,174],
[189,0,184,168,176,177,197,210],
[161,157,0,160,158,165,173,191],
[170,173,181,0,158,178,175,173],
[207,165,183,183,0,189,179,184],
[178,164,176,163,152,0,162,195],
[174,144,168,166,162,179,0,187],
[167,131,150,168,157,146,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 607, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,159,168,155,185,152,168],
[178,0,160,170,167,179,177,182],
[182,181,0,180,171,183,169,180],
[173,171,161,0,162,179,163,173],
[186,174,170,179,0,178,172,173],
[156,162,158,162,163,0,162,160],
[189,164,172,178,169,179,0,178],
[173,159,161,168,168,181,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 608, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,180,170,176,175,178,171],
[170,0,167,180,175,170,164,169],
[161,174,0,181,164,168,175,166],
[171,161,160,0,159,164,170,165],
[165,166,177,182,0,166,181,159],
[166,171,173,177,175,0,176,158],
[163,177,166,171,160,165,0,181],
[170,172,175,176,182,183,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 609, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,176,168,183,174,170,156],
[184,0,180,191,190,166,187,161],
[165,161,0,162,153,148,165,137],
[173,150,179,0,171,157,167,156],
[158,151,188,170,0,161,171,176],
[167,175,193,184,180,0,177,182],
[171,154,176,174,170,164,0,155],
[185,180,204,185,165,159,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 610, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,200,279,279,283,144,223,174],
[141,0,279,187,83,187,176,79],
[62,62,0,161,79,15,124,15],
[62,154,180,0,184,45,109,75],
[58,258,262,157,0,157,234,154],
[197,154,326,296,184,0,109,122],
[118,165,217,232,107,232,0,118],
[167,262,326,266,187,219,223,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 611, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,174,179,181,170,183,172],
[153,0,158,155,160,149,160,148],
[167,183,0,154,178,173,169,169],
[162,186,187,0,167,166,185,167],
[160,181,163,174,0,172,180,168],
[171,192,168,175,169,0,176,173],
[158,181,172,156,161,165,0,152],
[169,193,172,174,173,168,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 612, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,180,173,177,172,160,171],
[173,0,157,171,172,166,170,173],
[161,184,0,168,173,182,167,173],
[168,170,173,0,173,167,154,167],
[164,169,168,168,0,157,160,160],
[169,175,159,174,184,0,167,171],
[181,171,174,187,181,174,0,169],
[170,168,168,174,181,170,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 613, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,163,166,156,171,175,175],
[177,0,181,181,167,188,200,188],
[178,160,0,169,145,165,176,176],
[175,160,172,0,172,180,174,180],
[185,174,196,169,0,187,199,180],
[170,153,176,161,154,0,155,165],
[166,141,165,167,142,186,0,173],
[166,153,165,161,161,176,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 614, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,164,180,172,169,163,149],
[175,0,172,174,171,161,168,170],
[177,169,0,182,174,173,166,169],
[161,167,159,0,167,172,171,169],
[169,170,167,174,0,154,172,164],
[172,180,168,169,187,0,178,172],
[178,173,175,170,169,163,0,167],
[192,171,172,172,177,169,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 615, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,171,171,177,163,162,172],
[180,0,184,191,196,182,166,190],
[170,157,0,182,174,189,166,194],
[170,150,159,0,168,152,157,172],
[164,145,167,173,0,145,151,164],
[178,159,152,189,196,0,175,181],
[179,175,175,184,190,166,0,186],
[169,151,147,169,177,160,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 616, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,169,175,195,220,205,215],
[168,0,172,198,200,164,200,232],
[172,169,0,171,147,178,177,211],
[166,143,170,0,184,182,182,209],
[146,141,194,157,0,190,174,200],
[121,177,163,159,151,0,164,228],
[136,141,164,159,167,177,0,202],
[126,109,130,132,141,113,139,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 617, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,197,158,163,172,169,181,196],
[144,0,167,156,155,143,169,162],
[183,174,0,173,184,176,169,185],
[178,185,168,0,189,167,167,189],
[169,186,157,152,0,176,181,167],
[172,198,165,174,165,0,177,176],
[160,172,172,174,160,164,0,173],
[145,179,156,152,174,165,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 618, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,79,186,163,148,191,166,194],
[262,0,238,199,172,296,165,240],
[155,103,0,179,170,192,199,188],
[178,142,162,0,193,207,183,171],
[193,169,171,148,0,203,141,234],
[150,45,149,134,138,0,148,226],
[175,176,142,158,200,193,0,196],
[147,101,153,170,107,115,145,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 619, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,76,242,197,194,174,170,164],
[265,0,265,220,138,207,285,220],
[99,76,0,50,67,121,119,17],
[144,121,291,0,106,121,217,236],
[147,203,274,235,0,186,200,217],
[167,134,220,220,155,0,187,187],
[171,56,222,124,141,154,0,91],
[177,121,324,105,124,154,250,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 620, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,170,180,167,164,161,178],
[158,0,176,172,167,168,165,174],
[171,165,0,185,165,163,159,164],
[161,169,156,0,161,161,157,146],
[174,174,176,180,0,170,173,166],
[177,173,178,180,171,0,168,167],
[180,176,182,184,168,173,0,164],
[163,167,177,195,175,174,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 621, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,196,159,206,164,224,179],
[157,0,163,132,160,185,207,180],
[145,178,0,186,205,143,201,191],
[182,209,155,0,216,146,207,187],
[135,181,136,125,0,126,166,138],
[177,156,198,195,215,0,236,221],
[117,134,140,134,175,105,0,133],
[162,161,150,154,203,120,208,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 622, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,146,143,167,157,142,134,180],
[195,0,168,198,218,178,153,168],
[198,173,0,181,200,173,141,161],
[174,143,160,0,232,161,128,155],
[184,123,141,109,0,115,128,171],
[199,163,168,180,226,0,175,185],
[207,188,200,213,213,166,0,179],
[161,173,180,186,170,156,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 623, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,172,152,173,194,171,155],
[163,0,155,165,151,159,162,134],
[169,186,0,178,162,175,188,158],
[189,176,163,0,167,178,176,173],
[168,190,179,174,0,203,178,179],
[147,182,166,163,138,0,176,156],
[170,179,153,165,163,165,0,157],
[186,207,183,168,162,185,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 624, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,231,341,232,86,321,231,231],
[110,0,199,110,196,341,109,341],
[0,142,0,176,86,231,175,231],
[109,231,165,0,106,231,231,231],
[255,145,255,235,0,235,145,235],
[20,0,110,110,106,0,0,20],
[110,232,166,110,196,341,0,252],
[110,0,110,110,106,321,89,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 625, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,163,167,168,164,153,160],
[158,0,168,179,162,168,163,162],
[178,173,0,186,182,181,164,176],
[174,162,155,0,168,162,156,170],
[173,179,159,173,0,161,156,175],
[177,173,160,179,180,0,145,174],
[188,178,177,185,185,196,0,165],
[181,179,165,171,166,167,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 626, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,169,162,200,195,174,173],
[169,0,170,187,189,198,158,175],
[172,171,0,186,170,201,184,171],
[179,154,155,0,165,198,163,161],
[141,152,171,176,0,172,165,157],
[146,143,140,143,169,0,127,136],
[167,183,157,178,176,214,0,188],
[168,166,170,180,184,205,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 627, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,165,180,184,200,179,186],
[160,0,171,179,177,170,178,171],
[176,170,0,178,161,193,191,146],
[161,162,163,0,160,177,186,174],
[157,164,180,181,0,185,168,155],
[141,171,148,164,156,0,160,148],
[162,163,150,155,173,181,0,154],
[155,170,195,167,186,193,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 628, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,161,165,182,168,169,194],
[173,0,155,165,146,186,173,177],
[180,186,0,169,183,156,179,170],
[176,176,172,0,172,165,155,174],
[159,195,158,169,0,170,167,160],
[173,155,185,176,171,0,172,150],
[172,168,162,186,174,169,0,167],
[147,164,171,167,181,191,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 629, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,194,140,174,120,142,162],
[173,0,162,124,152,86,144,129],
[147,179,0,148,168,140,149,182],
[201,217,193,0,218,172,161,148],
[167,189,173,123,0,177,194,156],
[221,255,201,169,164,0,186,152],
[199,197,192,180,147,155,0,156],
[179,212,159,193,185,189,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 630, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,116,153,114,140,102,126,100],
[225,0,160,176,165,133,163,179],
[188,181,0,219,160,162,103,125],
[227,165,122,0,157,164,155,124],
[201,176,181,184,0,210,177,105],
[239,208,179,177,131,0,159,176],
[215,178,238,186,164,182,0,119],
[241,162,216,217,236,165,222,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 631, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,170,169,167,170,179,171],
[172,0,159,183,176,174,184,156],
[171,182,0,187,182,168,189,172],
[172,158,154,0,176,163,189,170],
[174,165,159,165,0,181,173,171],
[171,167,173,178,160,0,180,176],
[162,157,152,152,168,161,0,155],
[170,185,169,171,170,165,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 632, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,168,159,171,173,169,177],
[183,0,153,158,189,194,160,143],
[173,188,0,167,190,185,176,159],
[182,183,174,0,165,202,159,148],
[170,152,151,176,0,192,150,147],
[168,147,156,139,149,0,152,150],
[172,181,165,182,191,189,0,156],
[164,198,182,193,194,191,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 633, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,146,177,169,124,227,204,175],
[195,0,180,219,155,239,181,221],
[164,161,0,197,151,193,198,165],
[172,122,144,0,105,159,135,147],
[217,186,190,236,0,166,222,213],
[114,102,148,182,175,0,194,162],
[137,160,143,206,119,147,0,186],
[166,120,176,194,128,179,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 634, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,183,152,188,176,204,148],
[169,0,210,179,213,207,221,164],
[158,131,0,160,187,172,182,145],
[189,162,181,0,184,185,201,175],
[153,128,154,157,0,153,173,130],
[165,134,169,156,188,0,179,125],
[137,120,159,140,168,162,0,129],
[193,177,196,166,211,216,212,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 635, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,130,129,164,235,150,159],
[171,0,143,158,156,196,188,176],
[211,198,0,169,219,245,196,184],
[212,183,172,0,162,221,219,187],
[177,185,122,179,0,163,197,166],
[106,145,96,120,178,0,185,121],
[191,153,145,122,144,156,0,111],
[182,165,157,154,175,220,230,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 636, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,173,179,172,183,176,181],
[181,0,181,187,181,171,163,181],
[168,160,0,182,169,171,175,189],
[162,154,159,0,172,162,173,168],
[169,160,172,169,0,177,152,154],
[158,170,170,179,164,0,161,164],
[165,178,166,168,189,180,0,178],
[160,160,152,173,187,177,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 637, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,161,155,161,190,180,170],
[174,0,165,168,157,175,167,165],
[180,176,0,152,167,180,168,182],
[186,173,189,0,176,198,161,179],
[180,184,174,165,0,202,192,173],
[151,166,161,143,139,0,158,171],
[161,174,173,180,149,183,0,161],
[171,176,159,162,168,170,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 638, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,198,175,179,179,144,141,166],
[143,0,172,198,183,133,160,158],
[166,169,0,181,185,172,143,160],
[162,143,160,0,160,126,122,152],
[162,158,156,181,0,137,148,136],
[197,208,169,215,204,0,182,188],
[200,181,198,219,193,159,0,159],
[175,183,181,189,205,153,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 639, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,153,150,165,148,152,162],
[180,0,233,166,174,149,169,157],
[188,108,0,143,108,114,99,122],
[191,175,198,0,147,151,150,126],
[176,167,233,194,0,124,179,161],
[193,192,227,190,217,0,162,156],
[189,172,242,191,162,179,0,181],
[179,184,219,215,180,185,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 640, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,192,184,168,179,177,182],
[167,0,192,175,167,171,163,175],
[149,149,0,173,171,157,169,163],
[157,166,168,0,166,160,177,164],
[173,174,170,175,0,163,172,160],
[162,170,184,181,178,0,179,176],
[164,178,172,164,169,162,0,172],
[159,166,178,177,181,165,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 641, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,165,174,200,156,190,197],
[160,0,181,172,189,150,179,180],
[176,160,0,162,185,176,166,171],
[167,169,179,0,183,170,159,202],
[141,152,156,158,0,154,162,157],
[185,191,165,171,187,0,178,169],
[151,162,175,182,179,163,0,173],
[144,161,170,139,184,172,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 642, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,169,148,170,170,172,174],
[189,0,184,178,184,179,176,168],
[172,157,0,179,176,154,172,156],
[193,163,162,0,181,170,163,173],
[171,157,165,160,0,156,159,159],
[171,162,187,171,185,0,183,171],
[169,165,169,178,182,158,0,158],
[167,173,185,168,182,170,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 643, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,174,194,182,163,175,162],
[162,0,170,172,173,163,157,151],
[167,171,0,163,195,167,167,146],
[147,169,178,0,177,168,167,137],
[159,168,146,164,0,149,166,137],
[178,178,174,173,192,0,185,163],
[166,184,174,174,175,156,0,173],
[179,190,195,204,204,178,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 644, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,177,176,193,184,169,167],
[168,0,182,177,176,187,186,168],
[164,159,0,178,198,164,167,172],
[165,164,163,0,172,164,164,189],
[148,165,143,169,0,151,137,175],
[157,154,177,177,190,0,172,144],
[172,155,174,177,204,169,0,190],
[174,173,169,152,166,197,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 645, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,168,170,163,169,169,159],
[170,0,179,169,168,171,170,172],
[173,162,0,164,162,167,154,156],
[171,172,177,0,159,166,161,163],
[178,173,179,182,0,173,170,172],
[172,170,174,175,168,0,167,171],
[172,171,187,180,171,174,0,164],
[182,169,185,178,169,170,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 646, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,195,152,164,185,171,192,168],
[146,0,158,170,181,140,135,146],
[189,183,0,158,192,161,181,164],
[177,171,183,0,209,163,185,152],
[156,160,149,132,0,160,147,161],
[170,201,180,178,181,0,183,180],
[149,206,160,156,194,158,0,158],
[173,195,177,189,180,161,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 647, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,170,181,167,161,170,176],
[178,0,185,165,185,179,172,190],
[171,156,0,177,174,184,165,181],
[160,176,164,0,169,164,161,188],
[174,156,167,172,0,159,172,168],
[180,162,157,177,182,0,172,176],
[171,169,176,180,169,169,0,173],
[165,151,160,153,173,165,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 648, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,149,180,184,171,169,161,176],
[192,0,185,196,169,215,194,184],
[161,156,0,169,173,193,167,190],
[157,145,172,0,152,170,137,143],
[170,172,168,189,0,190,174,183],
[172,126,148,171,151,0,158,158],
[180,147,174,204,167,183,0,174],
[165,157,151,198,158,183,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 649, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,174,168,166,176,190,174],
[158,0,169,170,171,179,190,162],
[167,172,0,174,173,184,173,168],
[173,171,167,0,174,182,188,166],
[175,170,168,167,0,173,174,171],
[165,162,157,159,168,0,168,159],
[151,151,168,153,167,173,0,142],
[167,179,173,175,170,182,199,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 650, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,169,171,186,187,170,168],
[159,0,163,167,169,180,169,174],
[172,178,0,169,183,181,173,173],
[170,174,172,0,185,172,183,166],
[155,172,158,156,0,167,173,161],
[154,161,160,169,174,0,167,177],
[171,172,168,158,168,174,0,169],
[173,167,168,175,180,164,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 651, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,193,167,174,160,189,167,175],
[148,0,156,119,142,157,160,172],
[174,185,0,170,173,197,193,189],
[167,222,171,0,173,184,178,188],
[181,199,168,168,0,187,175,176],
[152,184,144,157,154,0,151,190],
[174,181,148,163,166,190,0,187],
[166,169,152,153,165,151,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 652, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,156,155,151,174,164,172],
[184,0,186,162,178,194,184,174],
[185,155,0,161,159,186,173,177],
[186,179,180,0,161,184,187,177],
[190,163,182,180,0,178,187,190],
[167,147,155,157,163,0,151,167],
[177,157,168,154,154,190,0,177],
[169,167,164,164,151,174,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 653, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,158,178,172,160,165,173],
[182,0,191,168,171,164,176,188],
[183,150,0,180,161,164,157,179],
[163,173,161,0,175,169,171,175],
[169,170,180,166,0,170,161,179],
[181,177,177,172,171,0,152,174],
[176,165,184,170,180,189,0,178],
[168,153,162,166,162,167,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 654, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,181,181,161,188,179,178],
[163,0,178,165,164,177,163,172],
[160,163,0,174,160,163,159,152],
[160,176,167,0,165,180,166,171],
[180,177,181,176,0,183,180,169],
[153,164,178,161,158,0,156,169],
[162,178,182,175,161,185,0,165],
[163,169,189,170,172,172,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 655, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,162,167,186,150,157,156],
[164,0,151,179,188,174,202,141],
[179,190,0,183,173,171,203,169],
[174,162,158,0,175,134,154,146],
[155,153,168,166,0,133,155,139],
[191,167,170,207,208,0,216,196],
[184,139,138,187,186,125,0,177],
[185,200,172,195,202,145,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 656, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,157,163,164,174,168,156],
[173,0,175,170,172,166,170,151],
[184,166,0,172,182,187,178,171],
[178,171,169,0,170,181,178,167],
[177,169,159,171,0,169,164,163],
[167,175,154,160,172,0,170,156],
[173,171,163,163,177,171,0,168],
[185,190,170,174,178,185,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 657, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,183,207,142,149,135,167],
[158,0,206,192,164,176,180,169],
[158,135,0,195,151,159,126,163],
[134,149,146,0,141,139,124,154],
[199,177,190,200,0,166,148,191],
[192,165,182,202,175,0,172,166],
[206,161,215,217,193,169,0,177],
[174,172,178,187,150,175,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 658, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,180,176,177,175,181,173],
[175,0,189,174,166,165,192,187],
[161,152,0,160,191,166,176,172],
[165,167,181,0,176,174,189,172],
[164,175,150,165,0,173,168,164],
[166,176,175,167,168,0,184,166],
[160,149,165,152,173,157,0,157],
[168,154,169,169,177,175,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 659, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,163,165,162,168,176,166],
[178,0,176,168,169,175,171,166],
[178,165,0,167,175,152,180,165],
[176,173,174,0,180,171,159,174],
[179,172,166,161,0,166,171,184],
[173,166,189,170,175,0,183,168],
[165,170,161,182,170,158,0,171],
[175,175,176,167,157,173,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 660, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,0,116,255,341,202,116,139],
[341,0,116,255,341,202,116,255],
[225,225,0,139,225,86,139,139],
[86,86,202,0,225,202,202,139],
[0,0,116,116,0,116,116,0],
[139,139,255,139,225,0,139,139],
[225,225,202,139,225,202,0,139],
[202,86,202,202,341,202,202,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 661, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,157,154,164,188,186,159],
[169,0,167,164,159,182,165,161],
[184,174,0,145,170,169,174,156],
[187,177,196,0,183,179,167,165],
[177,182,171,158,0,203,179,179],
[153,159,172,162,138,0,163,169],
[155,176,167,174,162,178,0,154],
[182,180,185,176,162,172,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 662, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,159,203,184,94,112,195],
[149,0,183,91,186,96,145,134],
[182,158,0,150,139,101,135,171],
[138,250,191,0,156,194,134,220],
[157,155,202,185,0,113,144,152],
[247,245,240,147,228,0,198,241],
[229,196,206,207,197,143,0,169],
[146,207,170,121,189,100,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 663, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,181,185,184,165,173,180],
[172,0,180,184,178,169,175,182],
[160,161,0,173,170,154,168,171],
[156,157,168,0,166,144,167,169],
[157,163,171,175,0,177,161,189],
[176,172,187,197,164,0,178,189],
[168,166,173,174,180,163,0,176],
[161,159,170,172,152,152,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 664, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,183,168,144,162,184,171],
[162,0,163,184,145,169,182,162],
[158,178,0,169,146,170,173,170],
[173,157,172,0,165,165,171,170],
[197,196,195,176,0,168,198,180],
[179,172,171,176,173,0,198,170],
[157,159,168,170,143,143,0,170],
[170,179,171,171,161,171,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 665, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,200,186,195,156,172,163,153],
[141,0,166,181,174,162,143,165],
[155,175,0,200,180,174,154,175],
[146,160,141,0,165,133,150,141],
[185,167,161,176,0,188,171,172],
[169,179,167,208,153,0,167,170],
[178,198,187,191,170,174,0,170],
[188,176,166,200,169,171,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 666, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,210,141,244,211,174,223,178],
[131,0,178,238,234,115,194,201],
[200,163,0,254,270,178,157,206],
[97,103,87,0,233,141,122,131],
[130,107,71,108,0,142,137,108],
[167,226,163,200,199,0,181,186],
[118,147,184,219,204,160,0,99],
[163,140,135,210,233,155,242,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 667, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,165,173,177,160,203,174],
[155,0,141,153,129,149,153,167],
[176,200,0,149,152,160,198,170],
[168,188,192,0,161,166,186,181],
[164,212,189,180,0,173,188,184],
[181,192,181,175,168,0,186,197],
[138,188,143,155,153,155,0,181],
[167,174,171,160,157,144,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 668, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,132,78,141,182,213,145,169],
[209,0,163,136,253,171,181,178],
[263,178,0,184,188,207,144,217],
[200,205,157,0,200,208,188,132],
[159,88,153,141,0,178,131,142],
[128,170,134,133,163,0,191,126],
[196,160,197,153,210,150,0,190],
[172,163,124,209,199,215,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 669, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,129,173,192,161,167,218],
[160,0,143,186,185,195,179,191],
[212,198,0,205,203,150,178,233],
[168,155,136,0,162,144,161,210],
[149,156,138,179,0,174,156,214],
[180,146,191,197,167,0,183,175],
[174,162,163,180,185,158,0,189],
[123,150,108,131,127,166,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 670, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,178,161,186,172,173,181],
[166,0,166,158,169,143,171,178],
[163,175,0,160,180,158,174,158],
[180,183,181,0,170,170,178,180],
[155,172,161,171,0,153,169,174],
[169,198,183,171,188,0,191,187],
[168,170,167,163,172,150,0,166],
[160,163,183,161,167,154,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 671, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,140,161,137,143,151,142,140],
[201,0,179,166,166,170,160,156],
[180,162,0,160,174,151,139,146],
[204,175,181,0,165,174,164,159],
[198,175,167,176,0,156,158,147],
[190,171,190,167,185,0,178,171],
[199,181,202,177,183,163,0,166],
[201,185,195,182,194,170,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 672, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,174,177,164,157,164,176],
[165,0,162,162,160,168,163,172],
[167,179,0,169,139,161,175,166],
[164,179,172,0,160,175,171,173],
[177,181,202,181,0,164,180,200],
[184,173,180,166,177,0,167,171],
[177,178,166,170,161,174,0,179],
[165,169,175,168,141,170,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 673, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,158,196,183,190,151,183],
[154,0,166,175,185,169,160,177],
[183,175,0,183,177,166,171,201],
[145,166,158,0,176,149,148,173],
[158,156,164,165,0,141,163,177],
[151,172,175,192,200,0,174,186],
[190,181,170,193,178,167,0,179],
[158,164,140,168,164,155,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 674, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,173,164,174,181,183,168],
[166,0,145,167,168,168,174,166],
[168,196,0,181,165,192,188,189],
[177,174,160,0,167,173,170,169],
[167,173,176,174,0,181,196,182],
[160,173,149,168,160,0,177,167],
[158,167,153,171,145,164,0,152],
[173,175,152,172,159,174,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 675, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,153,176,153,145,159,152],
[189,0,171,178,172,160,186,170],
[188,170,0,189,163,176,180,172],
[165,163,152,0,147,151,165,154],
[188,169,178,194,0,169,175,171],
[196,181,165,190,172,0,173,192],
[182,155,161,176,166,168,0,160],
[189,171,169,187,170,149,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 676, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,167,176,178,191,179,174],
[166,0,164,170,170,172,174,172],
[174,177,0,179,163,182,182,170],
[165,171,162,0,168,173,167,167],
[163,171,178,173,0,185,175,170],
[150,169,159,168,156,0,179,174],
[162,167,159,174,166,162,0,168],
[167,169,171,174,171,167,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 677, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,167,182,178,178,172,169],
[172,0,173,179,159,168,168,168],
[174,168,0,182,164,162,163,167],
[159,162,159,0,165,158,163,163],
[163,182,177,176,0,167,165,171],
[163,173,179,183,174,0,178,176],
[169,173,178,178,176,163,0,178],
[172,173,174,178,170,165,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 678, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,226,195,219,246,204,199,163],
[115,0,171,193,222,251,221,202],
[146,170,0,108,242,232,187,222],
[122,148,233,0,239,259,225,239],
[95,119,99,102,0,163,179,157],
[137,90,109,82,178,0,170,123],
[142,120,154,116,162,171,0,160],
[178,139,119,102,184,218,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 679, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,183,189,176,169,190,186],
[164,0,175,171,165,180,174,169],
[158,166,0,165,155,164,177,170],
[152,170,176,0,181,182,195,169],
[165,176,186,160,0,179,174,176],
[172,161,177,159,162,0,162,177],
[151,167,164,146,167,179,0,174],
[155,172,171,172,165,164,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 680, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,165,178,160,181,144,158],
[167,0,174,189,165,173,163,175],
[176,167,0,175,173,184,175,167],
[163,152,166,0,143,163,148,135],
[181,176,168,198,0,184,180,175],
[160,168,157,178,157,0,153,173],
[197,178,166,193,161,188,0,171],
[183,166,174,206,166,168,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 681, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,135,168,200,145,141,148,168],
[206,0,205,206,197,194,190,168],
[173,136,0,204,167,168,168,192],
[141,135,137,0,144,148,117,124],
[196,144,174,197,0,182,177,179],
[200,147,173,193,159,0,162,191],
[193,151,173,224,164,179,0,195],
[173,173,149,217,162,150,146,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 682, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,194,166,181,182,188,202],
[153,0,194,238,178,193,175,216],
[147,147,0,176,162,186,162,174],
[175,103,165,0,146,148,183,192],
[160,163,179,195,0,198,208,189],
[159,148,155,193,143,0,190,163],
[153,166,179,158,133,151,0,158],
[139,125,167,149,152,178,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 683, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,149,176,177,160,159,173],
[177,0,194,189,192,182,154,168],
[192,147,0,160,185,169,159,168],
[165,152,181,0,167,136,158,134],
[164,149,156,174,0,166,162,178],
[181,159,172,205,175,0,171,169],
[182,187,182,183,179,170,0,182],
[168,173,173,207,163,172,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 684, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,164,156,182,162,188,176],
[175,0,128,145,185,194,175,136],
[177,213,0,163,192,169,172,202],
[185,196,178,0,171,206,187,170],
[159,156,149,170,0,148,173,143],
[179,147,172,135,193,0,182,191],
[153,166,169,154,168,159,0,139],
[165,205,139,171,198,150,202,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 685, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,207,173,175,187,164,172,200],
[134,0,157,148,186,157,150,176],
[168,184,0,210,215,174,187,177],
[166,193,131,0,195,161,135,186],
[154,155,126,146,0,158,164,150],
[177,184,167,180,183,0,153,198],
[169,191,154,206,177,188,0,193],
[141,165,164,155,191,143,148,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 686, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,311,163,219,186,243,158,101],
[30,0,122,0,0,68,57,6],
[178,219,0,186,186,216,243,154],
[122,341,155,0,130,251,244,128],
[155,341,155,211,0,249,120,185],
[98,273,125,90,92,0,212,155],
[183,284,98,97,221,129,0,189],
[240,335,187,213,156,186,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 687, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,241,192,184,156,157,198,238],
[100,0,150,127,108,104,154,138],
[149,191,0,181,174,173,149,252],
[157,214,160,0,167,170,172,159],
[185,233,167,174,0,166,178,246],
[184,237,168,171,175,0,220,196],
[143,187,192,169,163,121,0,192],
[103,203,89,182,95,145,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 688, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,142,159,138,106,117,139],
[175,0,143,180,177,160,111,144],
[199,198,0,190,185,141,123,197],
[182,161,151,0,143,154,74,132],
[203,164,156,198,0,114,114,183],
[235,181,200,187,227,0,183,168],
[224,230,218,267,227,158,0,222],
[202,197,144,209,158,173,119,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 689, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,143,175,181,175,156,152],
[165,0,164,181,194,161,161,162],
[198,177,0,198,196,194,168,176],
[166,160,143,0,186,157,150,151],
[160,147,145,155,0,150,164,140],
[166,180,147,184,191,0,166,160],
[185,180,173,191,177,175,0,152],
[189,179,165,190,201,181,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 690, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,167,166,205,169,168,164],
[182,0,154,168,197,176,178,179],
[174,187,0,167,203,170,178,189],
[175,173,174,0,195,170,187,189],
[136,144,138,146,0,149,151,149],
[172,165,171,171,192,0,176,175],
[173,163,163,154,190,165,0,155],
[177,162,152,152,192,166,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 691, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,150,161,169,166,175,154,172],
[191,0,175,172,160,185,189,179],
[180,166,0,170,178,170,181,168],
[172,169,171,0,153,177,174,161],
[175,181,163,188,0,185,164,181],
[166,156,171,164,156,0,166,161],
[187,152,160,167,177,175,0,179],
[169,162,173,180,160,180,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 692, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,176,156,180,188,161,161],
[152,0,168,159,159,182,178,174],
[165,173,0,162,175,198,171,158],
[185,182,179,0,171,184,169,176],
[161,182,166,170,0,172,183,160],
[153,159,143,157,169,0,167,169],
[180,163,170,172,158,174,0,162],
[180,167,183,165,181,172,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 693, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,240,248,144,83,205,190],
[173,0,219,197,148,140,184,235],
[101,122,0,152,79,40,88,119],
[93,144,189,0,75,93,61,139],
[197,193,262,266,0,141,147,185],
[258,201,301,248,200,0,170,274],
[136,157,253,280,194,171,0,184],
[151,106,222,202,156,67,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 694, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,173,175,163,180,180,167],
[169,0,175,175,175,179,176,169],
[168,166,0,169,162,170,182,183],
[166,166,172,0,171,176,170,174],
[178,166,179,170,0,185,185,179],
[161,162,171,165,156,0,166,167],
[161,165,159,171,156,175,0,170],
[174,172,158,167,162,174,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 695, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,169,188,172,155,157,161],
[162,0,163,173,164,163,161,152],
[172,178,0,177,179,159,171,169],
[153,168,164,0,162,157,165,154],
[169,177,162,179,0,161,156,155],
[186,178,182,184,180,0,179,167],
[184,180,170,176,185,162,0,172],
[180,189,172,187,186,174,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 696, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,166,153,162,144,167,145],
[174,0,164,170,163,165,167,154],
[175,177,0,156,164,161,170,173],
[188,171,185,0,178,166,194,145],
[179,178,177,163,0,172,175,148],
[197,176,180,175,169,0,175,148],
[174,174,171,147,166,166,0,155],
[196,187,168,196,193,193,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 697, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,152,168,183,162,160,148],
[155,0,141,137,174,141,159,138],
[189,200,0,162,198,185,167,161],
[173,204,179,0,176,160,181,180],
[158,167,143,165,0,148,163,157],
[179,200,156,181,193,0,196,182],
[181,182,174,160,178,145,0,174],
[193,203,180,161,184,159,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 698, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,157,157,162,165,157,158],
[184,0,165,179,162,177,164,183],
[184,176,0,161,162,188,166,179],
[184,162,180,0,158,164,166,181],
[179,179,179,183,0,162,170,176],
[176,164,153,177,179,0,179,188],
[184,177,175,175,171,162,0,182],
[183,158,162,160,165,153,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 699, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,136,166,175,160,149,165],
[171,0,165,189,185,141,162,154],
[205,176,0,197,179,150,149,164],
[175,152,144,0,163,162,163,159],
[166,156,162,178,0,147,183,152],
[181,200,191,179,194,0,165,180],
[192,179,192,178,158,176,0,159],
[176,187,177,182,189,161,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 700, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,161,156,182,174,182,180],
[164,0,174,155,163,153,154,173],
[180,167,0,173,186,160,166,161],
[185,186,168,0,175,161,157,174],
[159,178,155,166,0,173,164,170],
[167,188,181,180,168,0,170,181],
[159,187,175,184,177,171,0,189],
[161,168,180,167,171,160,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 701, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,191,178,167,172,186,170],
[173,0,176,180,174,169,182,164],
[150,165,0,133,175,147,157,147],
[163,161,208,0,140,152,162,174],
[174,167,166,201,0,181,164,178],
[169,172,194,189,160,0,184,176],
[155,159,184,179,177,157,0,144],
[171,177,194,167,163,165,197,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 702, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,185,187,178,167,158,172],
[158,0,148,177,145,153,137,172],
[156,193,0,174,176,153,137,170],
[154,164,167,0,164,148,146,178],
[163,196,165,177,0,159,175,167],
[174,188,188,193,182,0,155,187],
[183,204,204,195,166,186,0,192],
[169,169,171,163,174,154,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 703, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,140,164,147,171,149,166,147],
[201,0,195,188,204,157,195,175],
[177,146,0,173,180,176,168,172],
[194,153,168,0,197,165,177,187],
[170,137,161,144,0,156,164,151],
[192,184,165,176,185,0,173,171],
[175,146,173,164,177,168,0,166],
[194,166,169,154,190,170,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 704, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,155,217,158,158,173,162],
[158,0,155,212,157,167,173,160],
[186,186,0,194,181,171,183,152],
[124,129,147,0,119,159,150,134],
[183,184,160,222,0,163,183,162],
[183,174,170,182,178,0,167,148],
[168,168,158,191,158,174,0,172],
[179,181,189,207,179,193,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 705, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,240,240,190,119,44,168,130],
[101,0,277,111,119,66,209,64],
[101,64,0,152,177,50,117,7],
[151,230,189,0,189,120,203,93],
[222,222,164,152,0,208,281,165],
[297,275,291,221,133,0,260,261],
[173,132,224,138,60,81,0,79],
[211,277,334,248,176,80,262,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 706, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,190,177,187,181,169,184],
[163,0,170,160,177,160,189,176],
[151,171,0,160,167,169,161,165],
[164,181,181,0,183,171,178,172],
[154,164,174,158,0,169,162,163],
[160,181,172,170,172,0,177,179],
[172,152,180,163,179,164,0,174],
[157,165,176,169,178,162,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 707, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,170,171,172,167,189,137],
[187,0,152,167,153,172,195,145],
[171,189,0,185,200,148,164,150],
[170,174,156,0,146,140,146,152],
[169,188,141,195,0,159,171,178],
[174,169,193,201,182,0,182,159],
[152,146,177,195,170,159,0,145],
[204,196,191,189,163,182,196,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 708, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,163,131,153,173,166,161],
[182,0,191,174,167,178,181,174],
[178,150,0,133,155,156,169,161],
[210,167,208,0,188,182,178,172],
[188,174,186,153,0,184,188,182],
[168,163,185,159,157,0,180,161],
[175,160,172,163,153,161,0,163],
[180,167,180,169,159,180,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 709, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,162,166,183,170,168,165],
[171,0,150,169,169,152,173,154],
[179,191,0,182,204,170,196,178],
[175,172,159,0,183,157,172,162],
[158,172,137,158,0,162,158,158],
[171,189,171,184,179,0,181,170],
[173,168,145,169,183,160,0,152],
[176,187,163,179,183,171,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 710, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,203,167,177,172,187,167,177],
[138,0,150,165,126,157,164,153],
[174,191,0,198,152,181,193,187],
[164,176,143,0,122,142,169,177],
[169,215,189,219,0,172,189,177],
[154,184,160,199,169,0,161,161],
[174,177,148,172,152,180,0,180],
[164,188,154,164,164,180,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 711, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,172,168,167,178,166,158],
[164,0,169,174,177,173,167,158],
[169,172,0,174,174,179,187,175],
[173,167,167,0,160,174,171,167],
[174,164,167,181,0,172,184,171],
[163,168,162,167,169,0,175,152],
[175,174,154,170,157,166,0,163],
[183,183,166,174,170,189,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 712, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,180,150,174,160,179,156],
[152,0,173,161,150,167,160,178],
[161,168,0,157,161,167,151,167],
[191,180,184,0,179,189,166,190],
[167,191,180,162,0,189,169,193],
[181,174,174,152,152,0,163,187],
[162,181,190,175,172,178,0,176],
[185,163,174,151,148,154,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 713, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,129,186,185,127,131,159,147],
[212,0,205,198,164,187,148,187],
[155,136,0,174,157,158,155,161],
[156,143,167,0,159,146,149,125],
[214,177,184,182,0,165,172,176],
[210,154,183,195,176,0,158,163],
[182,193,186,192,169,183,0,181],
[194,154,180,216,165,178,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 714, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,303,338,211,204,152,177],
[185,0,260,298,182,178,151,115],
[38,81,0,164,143,187,42,114],
[3,43,177,0,143,102,30,29],
[130,159,198,198,0,138,109,108],
[137,163,154,239,203,0,64,136],
[189,190,299,311,232,277,0,158],
[164,226,227,312,233,205,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 715, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,171,181,172,170,171,163],
[172,0,171,180,165,153,173,164],
[170,170,0,185,183,165,163,189],
[160,161,156,0,165,156,165,159],
[169,176,158,176,0,181,162,164],
[171,188,176,185,160,0,166,173],
[170,168,178,176,179,175,0,173],
[178,177,152,182,177,168,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 716, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,190,169,170,170,146,165],
[162,0,207,156,179,157,137,144],
[151,134,0,128,149,154,127,159],
[172,185,213,0,159,187,135,193],
[171,162,192,182,0,160,144,178],
[171,184,187,154,181,0,165,175],
[195,204,214,206,197,176,0,169],
[176,197,182,148,163,166,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 717, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,166,185,189,159,170,179],
[168,0,164,177,193,152,183,184],
[175,177,0,167,165,171,169,199],
[156,164,174,0,170,154,151,180],
[152,148,176,171,0,155,145,176],
[182,189,170,187,186,0,171,195],
[171,158,172,190,196,170,0,164],
[162,157,142,161,165,146,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 718, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,162,169,154,164,163,167],
[178,0,179,177,172,176,170,162],
[179,162,0,165,159,183,168,173],
[172,164,176,0,166,175,166,169],
[187,169,182,175,0,175,175,176],
[177,165,158,166,166,0,170,168],
[178,171,173,175,166,171,0,175],
[174,179,168,172,165,173,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 719, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,162,183,148,145,197,172],
[162,0,165,179,166,137,176,175],
[179,176,0,180,152,147,166,130],
[158,162,161,0,204,164,174,169],
[193,175,189,137,0,180,185,190],
[196,204,194,177,161,0,214,198],
[144,165,175,167,156,127,0,146],
[169,166,211,172,151,143,195,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 720, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,158,164,170,180,171,165],
[161,0,156,167,144,171,161,164],
[183,185,0,178,150,192,171,179],
[177,174,163,0,164,185,155,173],
[171,197,191,177,0,192,164,182],
[161,170,149,156,149,0,161,158],
[170,180,170,186,177,180,0,185],
[176,177,162,168,159,183,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 721, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,167,176,176,205,193,175],
[156,0,174,156,136,165,163,190],
[174,167,0,169,148,178,168,167],
[165,185,172,0,154,199,147,194],
[165,205,193,187,0,188,186,176],
[136,176,163,142,153,0,138,187],
[148,178,173,194,155,203,0,191],
[166,151,174,147,165,154,150,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 722, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,180,188,163,188,213,188],
[156,0,195,204,180,204,210,173],
[161,146,0,183,170,187,193,154],
[153,137,158,0,164,162,203,164],
[178,161,171,177,0,176,182,150],
[153,137,154,179,165,0,184,147],
[128,131,148,138,159,157,0,128],
[153,168,187,177,191,194,213,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 723, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,168,176,183,172,168,178],
[157,0,174,160,163,152,163,159],
[173,167,0,162,168,174,177,163],
[165,181,179,0,180,150,157,172],
[158,178,173,161,0,149,179,170],
[169,189,167,191,192,0,172,170],
[173,178,164,184,162,169,0,179],
[163,182,178,169,171,171,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 724, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,192,193,204,176,180,202],
[172,0,218,172,188,155,201,205],
[149,123,0,163,183,136,163,178],
[148,169,178,0,164,144,172,170],
[137,153,158,177,0,137,163,167],
[165,186,205,197,204,0,188,205],
[161,140,178,169,178,153,0,176],
[139,136,163,171,174,136,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 725, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,130,145,129,117,187,152,150],
[211,0,198,141,183,218,164,179],
[196,143,0,151,170,170,155,145],
[212,200,190,0,167,201,187,191],
[224,158,171,174,0,222,198,170],
[154,123,171,140,119,0,142,135],
[189,177,186,154,143,199,0,177],
[191,162,196,150,171,206,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 726, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,156,156,183,206,195,158],
[159,0,170,124,185,205,185,123],
[185,171,0,164,161,199,219,197],
[185,217,177,0,201,237,147,145],
[158,156,180,140,0,192,198,159],
[135,136,142,104,149,0,148,80],
[146,156,122,194,143,193,0,148],
[183,218,144,196,182,261,193,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 727, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,171,173,161,159,164,166],
[165,0,168,169,167,152,181,168],
[170,173,0,176,172,172,190,170],
[168,172,165,0,163,170,179,160],
[180,174,169,178,0,168,192,180],
[182,189,169,171,173,0,180,180],
[177,160,151,162,149,161,0,154],
[175,173,171,181,161,161,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 728, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,144,173,165,132,137,154],
[190,0,144,190,176,157,162,180],
[197,197,0,200,184,175,163,186],
[168,151,141,0,146,137,128,163],
[176,165,157,195,0,146,160,163],
[209,184,166,204,195,0,182,185],
[204,179,178,213,181,159,0,188],
[187,161,155,178,178,156,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 729, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,221,187,181,164,205,157,221],
[120,0,169,160,130,150,179,175],
[154,172,0,176,132,224,146,190],
[160,181,165,0,103,164,118,211],
[177,211,209,238,0,156,185,226],
[136,191,117,177,185,0,141,191],
[184,162,195,223,156,200,0,168],
[120,166,151,130,115,150,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 730, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,184,172,180,178,171,166],
[152,0,172,174,174,179,172,161],
[157,169,0,182,174,181,170,172],
[169,167,159,0,168,170,162,162],
[161,167,167,173,0,168,168,153],
[163,162,160,171,173,0,166,168],
[170,169,171,179,173,175,0,162],
[175,180,169,179,188,173,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 731, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,147,145,165,158,150,151,182],
[194,0,166,187,169,186,180,177],
[196,175,0,181,174,162,157,172],
[176,154,160,0,157,164,158,178],
[183,172,167,184,0,159,144,182],
[191,155,179,177,182,0,168,188],
[190,161,184,183,197,173,0,189],
[159,164,169,163,159,153,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 732, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,192,192,181,172,186,177],
[172,0,202,201,188,178,197,165],
[149,139,0,190,187,158,183,151],
[149,140,151,0,188,167,176,159],
[160,153,154,153,0,152,157,145],
[169,163,183,174,189,0,191,175],
[155,144,158,165,184,150,0,166],
[164,176,190,182,196,166,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 733, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,176,178,162,144,204,197],
[163,0,149,176,147,155,171,179],
[165,192,0,170,191,170,190,186],
[163,165,171,0,193,174,176,178],
[179,194,150,148,0,164,185,175],
[197,186,171,167,177,0,190,179],
[137,170,151,165,156,151,0,166],
[144,162,155,163,166,162,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 734, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,105,205,134,199,145,178,124],
[236,0,223,162,226,170,182,182],
[136,118,0,119,139,137,152,82],
[207,179,222,0,228,172,154,150],
[142,115,202,113,0,99,162,107],
[196,171,204,169,242,0,166,186],
[163,159,189,187,179,175,0,128],
[217,159,259,191,234,155,213,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 735, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,167,174,171,207,114,183],
[167,0,190,194,209,227,178,253],
[174,151,0,168,199,208,177,184],
[167,147,173,0,175,162,135,180],
[170,132,142,166,0,223,138,167],
[134,114,133,179,118,0,135,162],
[227,163,164,206,203,206,0,227],
[158,88,157,161,174,179,114,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 736, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,209,160,190,153,189,181,191],
[132,0,148,159,134,167,139,159],
[181,193,0,169,180,193,166,197],
[151,182,172,0,165,169,172,155],
[188,207,161,176,0,183,175,210],
[152,174,148,172,158,0,159,176],
[160,202,175,169,166,182,0,190],
[150,182,144,186,131,165,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 737, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,195,160,182,212,178,187],
[163,0,215,158,176,207,172,200],
[146,126,0,169,169,196,160,172],
[181,183,172,0,161,214,193,222],
[159,165,172,180,0,198,174,171],
[129,134,145,127,143,0,132,194],
[163,169,181,148,167,209,0,201],
[154,141,169,119,170,147,140,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 738, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,212,192,210,168,183,120],
[169,0,222,183,194,152,169,180],
[129,119,0,170,125,97,152,112],
[149,158,171,0,179,146,170,163],
[131,147,216,162,0,124,170,154],
[173,189,244,195,217,0,238,142],
[158,172,189,171,171,103,0,139],
[221,161,229,178,187,199,202,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 739, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,179,181,197,179,190,169],
[162,0,177,168,180,164,162,163],
[162,164,0,158,165,129,163,168],
[160,173,183,0,170,168,166,174],
[144,161,176,171,0,172,155,171],
[162,177,212,173,169,0,177,186],
[151,179,178,175,186,164,0,182],
[172,178,173,167,170,155,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 740, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,177,162,172,179,155,180],
[175,0,170,165,133,152,147,152],
[164,171,0,175,134,183,148,150],
[179,176,166,0,139,167,160,151],
[169,208,207,202,0,197,189,192],
[162,189,158,174,144,0,145,147],
[186,194,193,181,152,196,0,174],
[161,189,191,190,149,194,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 741, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,189,182,178,172,174,172],
[171,0,180,173,179,175,164,168],
[152,161,0,182,165,164,156,165],
[159,168,159,0,163,163,159,166],
[163,162,176,178,0,160,157,161],
[169,166,177,178,181,0,162,192],
[167,177,185,182,184,179,0,172],
[169,173,176,175,180,149,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 742, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,161,174,187,188,180,149],
[156,0,145,182,159,153,162,165],
[180,196,0,170,172,181,181,166],
[167,159,171,0,165,157,161,181],
[154,182,169,176,0,171,182,158],
[153,188,160,184,170,0,171,167],
[161,179,160,180,159,170,0,166],
[192,176,175,160,183,174,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 743, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,122,201,211,165,91,84,125],
[219,0,178,162,198,157,145,162],
[140,163,0,145,186,101,167,165],
[130,179,196,0,172,144,188,166],
[176,143,155,169,0,134,89,141],
[250,184,240,197,207,0,167,212],
[257,196,174,153,252,174,0,178],
[216,179,176,175,200,129,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 744, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,172,195,170,192,191,192],
[170,0,166,190,175,185,177,165],
[169,175,0,194,172,180,190,172],
[146,151,147,0,155,161,153,168],
[171,166,169,186,0,170,177,178],
[149,156,161,180,171,0,166,173],
[150,164,151,188,164,175,0,173],
[149,176,169,173,163,168,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 745, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,257,221,136,122,185,191,120],
[84,0,166,159,140,76,139,143],
[120,175,0,151,151,72,125,125],
[205,182,190,0,162,140,210,205],
[219,201,190,179,0,170,185,214],
[156,265,269,201,171,0,219,249],
[150,202,216,131,156,122,0,180],
[221,198,216,136,127,92,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 746, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,205,211,245,198,160,141,217],
[136,0,192,153,208,214,188,210],
[130,149,0,98,117,164,163,116],
[96,188,243,0,108,175,163,135],
[143,133,224,233,0,168,215,156],
[181,127,177,166,173,0,163,129],
[200,153,178,178,126,178,0,192],
[124,131,225,206,185,212,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 747, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,195,173,160,167,160,185],
[153,0,177,161,164,173,168,177],
[146,164,0,158,153,162,157,176],
[168,180,183,0,163,171,170,182],
[181,177,188,178,0,172,145,187],
[174,168,179,170,169,0,171,172],
[181,173,184,171,196,170,0,188],
[156,164,165,159,154,169,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 748, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,146,139,165,148,149,175,177],
[195,0,161,173,167,169,187,202],
[202,180,0,181,168,171,190,191],
[176,168,160,0,174,159,182,172],
[193,174,173,167,0,184,195,195],
[192,172,170,182,157,0,189,200],
[166,154,151,159,146,152,0,178],
[164,139,150,169,146,141,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 749, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,170,187,172,180,183,155],
[169,0,170,180,168,184,166,169],
[171,171,0,169,180,181,171,169],
[154,161,172,0,170,181,165,169],
[169,173,161,171,0,181,174,173],
[161,157,160,160,160,0,156,168],
[158,175,170,176,167,185,0,172],
[186,172,172,172,168,173,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 750, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,179,160,188,186,190,186],
[166,0,156,172,176,180,179,167],
[162,185,0,146,170,181,149,178],
[181,169,195,0,200,200,173,183],
[153,165,171,141,0,169,161,158],
[155,161,160,141,172,0,181,159],
[151,162,192,168,180,160,0,175],
[155,174,163,158,183,182,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 751, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,166,168,169,165,160,158],
[166,0,162,149,136,149,151,158],
[175,179,0,170,166,173,169,178],
[173,192,171,0,161,156,173,165],
[172,205,175,180,0,170,172,178],
[176,192,168,185,171,0,181,168],
[181,190,172,168,169,160,0,171],
[183,183,163,176,163,173,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 752, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,164,178,168,167,158,176],
[174,0,168,168,184,171,168,179],
[177,173,0,179,162,169,184,184],
[163,173,162,0,168,178,175,169],
[173,157,179,173,0,166,168,174],
[174,170,172,163,175,0,178,168],
[183,173,157,166,173,163,0,184],
[165,162,157,172,167,173,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 753, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,164,190,194,191,169,160],
[159,0,172,171,179,183,157,152],
[177,169,0,169,186,195,160,174],
[151,170,172,0,183,196,150,165],
[147,162,155,158,0,188,135,158],
[150,158,146,145,153,0,150,171],
[172,184,181,191,206,191,0,168],
[181,189,167,176,183,170,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 754, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,147,164,163,181,144,156,174],
[194,0,175,154,206,171,166,172],
[177,166,0,161,181,165,154,172],
[178,187,180,0,170,156,163,181],
[160,135,160,171,0,147,169,162],
[197,170,176,185,194,0,181,176],
[185,175,187,178,172,160,0,178],
[167,169,169,160,179,165,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 755, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,161,155,162,172,147,162],
[182,0,169,173,177,172,169,165],
[180,172,0,166,180,175,163,174],
[186,168,175,0,171,173,182,171],
[179,164,161,170,0,161,170,170],
[169,169,166,168,180,0,161,176],
[194,172,178,159,171,180,0,183],
[179,176,167,170,171,165,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 756, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,173,163,171,163,184,147],
[149,0,154,152,148,165,182,137],
[168,187,0,177,164,189,185,176],
[178,189,164,0,184,185,189,149],
[170,193,177,157,0,181,189,166],
[178,176,152,156,160,0,198,137],
[157,159,156,152,152,143,0,135],
[194,204,165,192,175,204,206,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 757, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,175,167,167,176,179,167],
[167,0,175,167,160,182,170,154],
[166,166,0,177,166,175,167,157],
[174,174,164,0,163,178,184,171],
[174,181,175,178,0,178,177,166],
[165,159,166,163,163,0,168,158],
[162,171,174,157,164,173,0,157],
[174,187,184,170,175,183,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 758, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,153,168,148,137,147,145],
[159,0,160,185,152,153,165,156],
[188,181,0,188,150,158,166,177],
[173,156,153,0,129,165,171,154],
[193,189,191,212,0,176,201,165],
[204,188,183,176,165,0,163,175],
[194,176,175,170,140,178,0,154],
[196,185,164,187,176,166,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 759, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,169,174,158,156,180,165],
[179,0,178,177,174,170,179,177],
[172,163,0,170,152,174,168,159],
[167,164,171,0,175,157,177,167],
[183,167,189,166,0,172,178,182],
[185,171,167,184,169,0,176,167],
[161,162,173,164,163,165,0,174],
[176,164,182,174,159,174,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 760, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,198,166,178,180,200,180],
[156,0,180,157,155,162,178,163],
[143,161,0,160,163,151,151,179],
[175,184,181,0,169,162,166,190],
[163,186,178,172,0,163,181,169],
[161,179,190,179,178,0,184,170],
[141,163,190,175,160,157,0,169],
[161,178,162,151,172,171,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 761, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,169,161,168,175,186,144],
[159,0,158,160,168,154,168,148],
[172,183,0,162,165,164,198,172],
[180,181,179,0,183,167,188,155],
[173,173,176,158,0,169,190,159],
[166,187,177,174,172,0,206,160],
[155,173,143,153,151,135,0,134],
[197,193,169,186,182,181,207,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 762, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,198,175,205,155,159,147],
[169,0,196,172,190,191,161,166],
[143,145,0,121,178,154,142,132],
[166,169,220,0,187,189,146,173],
[136,151,163,154,0,137,137,160],
[186,150,187,152,204,0,195,155],
[182,180,199,195,204,146,0,176],
[194,175,209,168,181,186,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 763, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,173,198,186,175,201,159],
[170,0,162,184,149,170,180,158],
[168,179,0,187,161,177,185,162],
[143,157,154,0,152,149,158,132],
[155,192,180,189,0,168,176,171],
[166,171,164,192,173,0,174,161],
[140,161,156,183,165,167,0,149],
[182,183,179,209,170,180,192,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 764, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,174,177,170,182,173,180],
[170,0,166,183,173,186,183,184],
[167,175,0,197,176,172,186,198],
[164,158,144,0,154,157,159,164],
[171,168,165,187,0,177,182,183],
[159,155,169,184,164,0,163,174],
[168,158,155,182,159,178,0,169],
[161,157,143,177,158,167,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 765, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,166,170,168,150,172,169],
[177,0,154,175,164,169,181,169],
[175,187,0,167,170,162,177,190],
[171,166,174,0,173,158,175,177],
[173,177,171,168,0,171,182,189],
[191,172,179,183,170,0,187,180],
[169,160,164,166,159,154,0,164],
[172,172,151,164,152,161,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 766, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,167,150,170,161,165,153],
[188,0,174,167,178,171,181,172],
[174,167,0,170,170,166,179,171],
[191,174,171,0,170,170,176,168],
[171,163,171,171,0,168,177,171],
[180,170,175,171,173,0,175,167],
[176,160,162,165,164,166,0,166],
[188,169,170,173,170,174,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 767, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,172,169,184,167,178,185],
[170,0,183,171,191,185,178,189],
[169,158,0,158,172,165,165,168],
[172,170,183,0,181,178,170,181],
[157,150,169,160,0,172,167,164],
[174,156,176,163,169,0,180,184],
[163,163,176,171,174,161,0,164],
[156,152,173,160,177,157,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 768, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,148,174,163,166,151,134],
[173,0,160,160,178,183,180,130],
[193,181,0,189,161,176,214,181],
[167,181,152,0,153,141,155,166],
[178,163,180,188,0,144,191,183],
[175,158,165,200,197,0,166,169],
[190,161,127,186,150,175,0,171],
[207,211,160,175,158,172,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 769, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,168,158,167,173,174,189],
[177,0,172,144,162,180,159,181],
[173,169,0,174,170,192,173,186],
[183,197,167,0,188,201,186,205],
[174,179,171,153,0,193,182,195],
[168,161,149,140,148,0,157,179],
[167,182,168,155,159,184,0,186],
[152,160,155,136,146,162,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 770, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,186,174,178,174,178,185],
[173,0,188,181,178,163,189,188],
[155,153,0,173,156,170,148,181],
[167,160,168,0,145,171,160,161],
[163,163,185,196,0,170,192,175],
[167,178,171,170,171,0,172,184],
[163,152,193,181,149,169,0,181],
[156,153,160,180,166,157,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 771, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,149,144,168,189,185,156],
[174,0,147,137,220,169,171,175],
[192,194,0,171,216,218,190,166],
[197,204,170,0,180,170,192,200],
[173,121,125,161,0,142,160,137],
[152,172,123,171,199,0,185,158],
[156,170,151,149,181,156,0,164],
[185,166,175,141,204,183,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 772, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,166,160,165,169,158,171],
[170,0,157,167,173,162,151,172],
[175,184,0,171,173,167,172,183],
[181,174,170,0,188,176,169,184],
[176,168,168,153,0,178,149,179],
[172,179,174,165,163,0,169,188],
[183,190,169,172,192,172,0,185],
[170,169,158,157,162,153,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 773, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,118,172,139,157,156,194,202],
[223,0,202,182,197,154,160,206],
[169,139,0,160,156,112,200,196],
[202,159,181,0,176,174,180,181],
[184,144,185,165,0,156,215,212],
[185,187,229,167,185,0,239,216],
[147,181,141,161,126,102,0,172],
[139,135,145,160,129,125,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 774, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,182,169,164,156,173,167],
[167,0,169,150,158,153,166,177],
[159,172,0,157,145,146,166,163],
[172,191,184,0,163,159,169,171],
[177,183,196,178,0,161,186,183],
[185,188,195,182,180,0,172,167],
[168,175,175,172,155,169,0,153],
[174,164,178,170,158,174,188,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 775, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,151,155,161,181,162,164],
[177,0,161,183,177,183,165,170],
[190,180,0,172,165,188,169,175],
[186,158,169,0,178,184,175,171],
[180,164,176,163,0,165,168,164],
[160,158,153,157,176,0,162,160],
[179,176,172,166,173,179,0,167],
[177,171,166,170,177,181,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 776, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,168,159,165,176,165,173],
[189,0,169,186,187,181,170,176],
[173,172,0,176,190,210,166,182],
[182,155,165,0,171,177,174,173],
[176,154,151,170,0,179,157,152],
[165,160,131,164,162,0,158,156],
[176,171,175,167,184,183,0,182],
[168,165,159,168,189,185,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 777, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,179,178,173,168,178,173],
[156,0,160,172,162,165,162,166],
[162,181,0,171,168,159,170,175],
[163,169,170,0,147,166,167,167],
[168,179,173,194,0,184,193,173],
[173,176,182,175,157,0,177,180],
[163,179,171,174,148,164,0,172],
[168,175,166,174,168,161,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 778, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,165,181,194,176,172,172],
[167,0,192,191,179,175,175,191],
[176,149,0,162,171,152,160,168],
[160,150,179,0,180,165,165,153],
[147,162,170,161,0,138,161,169],
[165,166,189,176,203,0,178,195],
[169,166,181,176,180,163,0,168],
[169,150,173,188,172,146,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 779, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,180,189,153,172,170,178],
[168,0,162,158,161,163,162,185],
[161,179,0,171,169,157,166,190],
[152,183,170,0,168,163,180,188],
[188,180,172,173,0,161,170,190],
[169,178,184,178,180,0,171,189],
[171,179,175,161,171,170,0,165],
[163,156,151,153,151,152,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 780, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,145,193,182,155,174,132],
[187,0,171,194,187,167,192,167],
[196,170,0,180,191,169,176,144],
[148,147,161,0,160,148,134,156],
[159,154,150,181,0,151,155,140],
[186,174,172,193,190,0,154,162],
[167,149,165,207,186,187,0,176],
[209,174,197,185,201,179,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 781, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,185,171,172,187,182,176],
[177,0,179,169,177,191,176,177],
[156,162,0,175,174,175,175,168],
[170,172,166,0,175,172,174,176],
[169,164,167,166,0,171,164,172],
[154,150,166,169,170,0,154,165],
[159,165,166,167,177,187,0,174],
[165,164,173,165,169,176,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 782, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,153,151,181,154,166,180],
[165,0,172,189,176,177,177,191],
[188,169,0,176,197,176,195,198],
[190,152,165,0,174,161,171,178],
[160,165,144,167,0,157,165,171],
[187,164,165,180,184,0,182,182],
[175,164,146,170,176,159,0,173],
[161,150,143,163,170,159,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 783, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,172,178,181,179,167,180],
[166,0,167,173,184,171,163,164],
[169,174,0,186,187,190,183,172],
[163,168,155,0,179,176,157,163],
[160,157,154,162,0,170,157,157],
[162,170,151,165,171,0,161,158],
[174,178,158,184,184,180,0,167],
[161,177,169,178,184,183,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 784, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,173,159,162,180,174,158],
[171,0,165,171,169,191,185,165],
[168,176,0,168,169,189,167,167],
[182,170,173,0,186,179,182,170],
[179,172,172,155,0,169,161,183],
[161,150,152,162,172,0,187,149],
[167,156,174,159,180,154,0,165],
[183,176,174,171,158,192,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 785, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,166,163,171,163,159,161],
[177,0,167,173,172,172,169,160],
[175,174,0,159,174,168,161,176],
[178,168,182,0,174,167,157,178],
[170,169,167,167,0,168,162,160],
[178,169,173,174,173,0,157,168],
[182,172,180,184,179,184,0,170],
[180,181,165,163,181,173,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 786, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,143,188,177,164,174,179],
[164,0,179,172,157,171,153,164],
[198,162,0,174,167,177,150,192],
[153,169,167,0,174,175,149,185],
[164,184,174,167,0,186,159,194],
[177,170,164,166,155,0,163,160],
[167,188,191,192,182,178,0,193],
[162,177,149,156,147,181,148,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 787, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,116,149,147,196,166,239,219],
[225,0,212,189,238,157,256,199],
[192,129,0,143,167,179,210,151],
[194,152,198,0,137,151,211,193],
[145,103,174,204,0,131,193,127],
[175,184,162,190,210,0,230,152],
[102,85,131,130,148,111,0,119],
[122,142,190,148,214,189,222,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 788, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,166,173,164,175,162,179],
[177,0,181,170,181,179,178,176],
[175,160,0,173,174,171,158,171],
[168,171,168,0,164,174,168,174],
[177,160,167,177,0,181,175,177],
[166,162,170,167,160,0,155,168],
[179,163,183,173,166,186,0,182],
[162,165,170,167,164,173,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 789, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,203,165,184,173,171,174],
[178,0,204,179,163,191,158,182],
[138,137,0,142,176,148,145,135],
[176,162,199,0,193,175,164,171],
[157,178,165,148,0,163,146,164],
[168,150,193,166,178,0,166,154],
[170,183,196,177,195,175,0,166],
[167,159,206,170,177,187,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 790, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,159,179,189,183,169,127],
[173,0,184,181,197,193,163,189],
[182,157,0,228,200,176,155,196],
[162,160,113,0,175,183,178,159],
[152,144,141,166,0,176,151,144],
[158,148,165,158,165,0,148,128],
[172,178,186,163,190,193,0,169],
[214,152,145,182,197,213,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 791, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,192,179,137,143,162,163],
[184,0,198,203,173,163,154,172],
[149,143,0,176,140,153,152,152],
[162,138,165,0,146,141,153,151],
[204,168,201,195,0,177,181,192],
[198,178,188,200,164,0,173,180],
[179,187,189,188,160,168,0,170],
[178,169,189,190,149,161,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 792, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,170,158,165,154,181,154],
[181,0,167,177,183,180,166,176],
[171,174,0,174,156,155,168,149],
[183,164,167,0,168,179,163,177],
[176,158,185,173,0,162,158,161],
[187,161,186,162,179,0,166,177],
[160,175,173,178,183,175,0,169],
[187,165,192,164,180,164,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 793, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,173,178,157,179,151,140],
[187,0,191,180,175,187,162,175],
[168,150,0,168,155,170,151,154],
[163,161,173,0,149,176,158,154],
[184,166,186,192,0,183,179,168],
[162,154,171,165,158,0,153,161],
[190,179,190,183,162,188,0,160],
[201,166,187,187,173,180,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 794, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,172,155,177,159,173,183],
[165,0,161,159,177,166,166,154],
[169,180,0,167,178,160,176,154],
[186,182,174,0,180,169,186,172],
[164,164,163,161,0,153,160,160],
[182,175,181,172,188,0,181,155],
[168,175,165,155,181,160,0,170],
[158,187,187,169,181,186,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 795, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,153,178,175,179,180,183],
[180,0,173,196,174,169,194,196],
[188,168,0,187,186,158,183,180],
[163,145,154,0,176,164,174,163],
[166,167,155,165,0,168,180,190],
[162,172,183,177,173,0,193,191],
[161,147,158,167,161,148,0,153],
[158,145,161,178,151,150,188,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 796, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,158,167,194,182,156,200],
[169,0,201,170,190,190,172,166],
[183,140,0,173,177,158,160,185],
[174,171,168,0,190,163,167,203],
[147,151,164,151,0,144,161,164],
[159,151,183,178,197,0,148,165],
[185,169,181,174,180,193,0,184],
[141,175,156,138,177,176,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 797, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,186,183,203,181,194,157],
[189,0,223,134,212,249,222,176],
[155,118,0,162,148,189,150,192],
[158,207,179,0,187,164,101,242],
[138,129,193,154,0,184,178,132],
[160,92,152,177,157,0,152,177],
[147,119,191,240,163,189,0,252],
[184,165,149,99,209,164,89,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 798, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,165,175,161,159,151,167],
[177,0,171,176,182,176,169,175],
[176,170,0,180,181,169,187,173],
[166,165,161,0,181,184,177,172],
[180,159,160,160,0,161,151,159],
[182,165,172,157,180,0,158,160],
[190,172,154,164,190,183,0,164],
[174,166,168,169,182,181,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 799, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,195,177,171,152,172,171],
[166,0,174,169,164,137,182,169],
[146,167,0,167,151,147,130,167],
[164,172,174,0,166,149,177,161],
[170,177,190,175,0,164,148,199],
[189,204,194,192,177,0,171,153],
[169,159,211,164,193,170,0,191],
[170,172,174,180,142,188,150,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 800, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,169,166,188,165,174,178],
[163,0,172,160,171,150,157,186],
[172,169,0,171,191,174,156,185],
[175,181,170,0,192,152,177,186],
[153,170,150,149,0,149,146,182],
[176,191,167,189,192,0,167,188],
[167,184,185,164,195,174,0,179],
[163,155,156,155,159,153,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 801, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,173,173,179,187,165,163],
[156,0,164,174,172,178,164,162],
[168,177,0,174,171,181,166,179],
[168,167,167,0,167,180,173,158],
[162,169,170,174,0,180,163,171],
[154,163,160,161,161,0,154,146],
[176,177,175,168,178,187,0,168],
[178,179,162,183,170,195,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 802, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,184,181,186,184,177,166],
[167,0,171,163,181,168,173,169],
[157,170,0,172,174,174,162,168],
[160,178,169,0,182,174,163,160],
[155,160,167,159,0,158,161,160],
[157,173,167,167,183,0,153,157],
[164,168,179,178,180,188,0,173],
[175,172,173,181,181,184,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 803, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,162,182,154,161,151,171],
[180,0,163,178,158,181,159,177],
[179,178,0,189,174,170,165,173],
[159,163,152,0,145,155,163,163],
[187,183,167,196,0,177,170,185],
[180,160,171,186,164,0,176,177],
[190,182,176,178,171,165,0,175],
[170,164,168,178,156,164,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 804, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,168,185,156,169,148,158],
[176,0,171,183,178,189,141,182],
[173,170,0,154,140,166,167,176],
[156,158,187,0,152,166,142,168],
[185,163,201,189,0,203,165,192],
[172,152,175,175,138,0,157,165],
[193,200,174,199,176,184,0,164],
[183,159,165,173,149,176,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 805, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,170,158,206,111,169,111],
[167,0,194,155,180,143,205,147],
[171,147,0,155,195,185,116,133],
[183,186,186,0,230,141,200,215],
[135,161,146,111,0,122,215,169],
[230,198,156,200,219,0,177,155],
[172,136,225,141,126,164,0,209],
[230,194,208,126,172,186,132,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 806, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,179,178,171,172,164,174],
[164,0,184,171,191,161,174,162],
[162,157,0,181,179,171,162,163],
[163,170,160,0,164,169,154,149],
[170,150,162,177,0,167,157,157],
[169,180,170,172,174,0,158,163],
[177,167,179,187,184,183,0,152],
[167,179,178,192,184,178,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 807, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,148,152,165,167,164,163],
[179,0,163,159,172,184,164,174],
[193,178,0,185,178,175,178,168],
[189,182,156,0,175,178,169,171],
[176,169,163,166,0,179,176,166],
[174,157,166,163,162,0,153,171],
[177,177,163,172,165,188,0,160],
[178,167,173,170,175,170,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 808, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,160,191,181,159,176,185],
[175,0,165,183,173,173,179,171],
[181,176,0,185,177,167,181,172],
[150,158,156,0,163,150,164,155],
[160,168,164,178,0,169,170,156],
[182,168,174,191,172,0,183,167],
[165,162,160,177,171,158,0,170],
[156,170,169,186,185,174,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 809, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,166,162,159,179,159,168],
[184,0,182,167,162,169,171,165],
[175,159,0,160,169,171,168,181],
[179,174,181,0,158,162,160,164],
[182,179,172,183,0,166,162,151],
[162,172,170,179,175,0,170,179],
[182,170,173,181,179,171,0,169],
[173,176,160,177,190,162,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 810, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,162,173,178,173,175,176],
[169,0,165,167,176,172,165,171],
[179,176,0,198,184,189,161,180],
[168,174,143,0,166,169,154,161],
[163,165,157,175,0,171,167,163],
[168,169,152,172,170,0,159,161],
[166,176,180,187,174,182,0,170],
[165,170,161,180,178,180,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 811, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,168,163,165,172,172,161],
[165,0,170,163,181,170,159,163],
[173,171,0,164,170,160,161,167],
[178,178,177,0,169,175,180,158],
[176,160,171,172,0,158,169,161],
[169,171,181,166,183,0,171,171],
[169,182,180,161,172,170,0,159],
[180,178,174,183,180,170,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 812, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,184,185,183,174,174,179],
[184,0,179,196,184,190,163,189],
[157,162,0,172,168,167,155,178],
[156,145,169,0,145,168,160,178],
[158,157,173,196,0,172,154,180],
[167,151,174,173,169,0,157,181],
[167,178,186,181,187,184,0,189],
[162,152,163,163,161,160,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 813, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,201,217,151,239,235,179],
[188,0,223,232,173,241,276,166],
[140,118,0,168,115,156,210,138],
[124,109,173,0,137,198,200,100],
[190,168,226,204,0,211,221,164],
[102,100,185,143,130,0,177,124],
[106,65,131,141,120,164,0,119],
[162,175,203,241,177,217,222,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 814, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,157,177,184,157,179,174],
[161,0,157,155,156,144,173,148],
[184,184,0,179,181,184,186,169],
[164,186,162,0,179,152,192,157],
[157,185,160,162,0,151,184,143],
[184,197,157,189,190,0,178,180],
[162,168,155,149,157,163,0,172],
[167,193,172,184,198,161,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 815, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,158,159,181,169,160,182],
[180,0,167,164,185,180,152,180],
[183,174,0,172,176,173,172,170],
[182,177,169,0,182,179,172,175],
[160,156,165,159,0,144,150,159],
[172,161,168,162,197,0,166,169],
[181,189,169,169,191,175,0,184],
[159,161,171,166,182,172,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 816, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,168,153,158,161,163,170],
[182,0,175,171,158,171,176,171],
[173,166,0,165,167,173,177,175],
[188,170,176,0,173,178,180,177],
[183,183,174,168,0,176,189,177],
[180,170,168,163,165,0,174,173],
[178,165,164,161,152,167,0,174],
[171,170,166,164,164,168,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 817, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,90,320,204,200,115,203,117],
[251,0,249,184,199,114,183,116],
[21,92,0,143,160,136,142,56],
[137,157,198,0,266,185,271,252],
[141,142,181,75,0,117,142,117],
[226,227,205,156,224,0,227,208],
[138,158,199,70,199,114,0,134],
[224,225,285,89,224,133,207,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 818, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,149,165,151,167,153,164,167],
[192,0,179,164,162,172,176,179],
[176,162,0,166,160,155,165,164],
[190,177,175,0,182,168,185,190],
[174,179,181,159,0,169,183,184],
[188,169,186,173,172,0,173,204],
[177,165,176,156,158,168,0,163],
[174,162,177,151,157,137,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 819, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,204,186,171,166,189,230],
[158,0,229,183,151,224,144,187],
[137,112,0,135,161,149,171,142],
[155,158,206,0,155,200,156,208],
[170,190,180,186,0,205,144,217],
[175,117,192,141,136,0,131,158],
[152,197,170,185,197,210,0,231],
[111,154,199,133,124,183,110,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 820, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,177,176,169,174,175,163],
[166,0,180,172,170,180,180,181],
[164,161,0,162,159,164,155,160],
[165,169,179,0,167,180,173,175],
[172,171,182,174,0,168,167,184],
[167,161,177,161,173,0,179,182],
[166,161,186,168,174,162,0,170],
[178,160,181,166,157,159,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 821, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,173,174,167,181,172,165],
[172,0,168,157,164,164,172,169],
[168,173,0,155,164,169,165,157],
[167,184,186,0,160,167,172,179],
[174,177,177,181,0,179,178,166],
[160,177,172,174,162,0,165,154],
[169,169,176,169,163,176,0,169],
[176,172,184,162,175,187,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 822, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,160,171,237,179,192,194],
[149,0,162,184,203,151,170,192],
[181,179,0,188,213,157,165,216],
[170,157,153,0,212,157,180,219],
[104,138,128,129,0,131,127,172],
[162,190,184,184,210,0,179,212],
[149,171,176,161,214,162,0,224],
[147,149,125,122,169,129,117,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 823, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,159,160,159,157,172,165],
[169,0,179,171,180,156,176,172],
[182,162,0,176,186,162,188,169],
[181,170,165,0,167,163,175,171],
[182,161,155,174,0,155,164,177],
[184,185,179,178,186,0,184,169],
[169,165,153,166,177,157,0,159],
[176,169,172,170,164,172,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 824, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,197,164,157,163,200,194,174],
[144,0,140,160,143,152,178,152],
[177,201,0,172,161,184,191,180],
[184,181,169,0,171,180,181,179],
[178,198,180,170,0,189,185,179],
[141,189,157,161,152,0,184,167],
[147,163,150,160,156,157,0,164],
[167,189,161,162,162,174,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 825, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,169,162,173,161,172,159],
[156,0,162,149,161,149,149,156],
[172,179,0,164,174,166,169,159],
[179,192,177,0,170,174,169,166],
[168,180,167,171,0,167,150,163],
[180,192,175,167,174,0,183,172],
[169,192,172,172,191,158,0,158],
[182,185,182,175,178,169,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 826, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,160,172,170,170,156,173],
[170,0,172,161,161,169,169,164],
[181,169,0,170,157,166,161,168],
[169,180,171,0,161,158,149,157],
[171,180,184,180,0,183,178,162],
[171,172,175,183,158,0,155,166],
[185,172,180,192,163,186,0,182],
[168,177,173,184,179,175,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 827, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,215,102,187,164,161,143],
[150,0,118,76,186,171,169,109],
[126,223,0,150,175,193,211,158],
[239,265,191,0,241,220,258,170],
[154,155,166,100,0,114,185,148],
[177,170,148,121,227,0,206,173],
[180,172,130,83,156,135,0,137],
[198,232,183,171,193,168,204,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 828, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,120,195,127,189,138,142,138],
[221,0,234,222,156,164,136,186],
[146,107,0,195,138,152,173,148],
[214,119,146,0,191,149,179,142],
[152,185,203,150,0,174,197,161],
[203,177,189,192,167,0,246,160],
[199,205,168,162,144,95,0,176],
[203,155,193,199,180,181,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 829, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,223,183,166,178,150,179],
[162,0,195,165,163,168,171,202],
[118,146,0,164,137,141,122,141],
[158,176,177,0,151,153,173,173],
[175,178,204,190,0,202,164,190],
[163,173,200,188,139,0,167,165],
[191,170,219,168,177,174,0,171],
[162,139,200,168,151,176,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 830, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,209,192,116,148,163,121,184],
[132,0,140,136,140,112,109,163],
[149,201,0,200,164,171,174,199],
[225,205,141,0,126,188,153,219],
[193,201,177,215,0,196,151,155],
[178,229,170,153,145,0,143,161],
[220,232,167,188,190,198,0,226],
[157,178,142,122,186,180,115,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 831, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,227,187,175,205,184,193,163],
[114,0,163,133,153,137,178,94],
[154,178,0,152,224,152,154,139],
[166,208,189,0,225,211,207,189],
[136,188,117,116,0,133,140,127],
[157,204,189,130,208,0,220,148],
[148,163,187,134,201,121,0,137],
[178,247,202,152,214,193,204,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 832, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,160,167,160,173,171,164],
[160,0,178,163,174,164,166,163],
[181,163,0,170,162,170,176,163],
[174,178,171,0,169,175,191,156],
[181,167,179,172,0,185,189,171],
[168,177,171,166,156,0,178,156],
[170,175,165,150,152,163,0,172],
[177,178,178,185,170,185,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 833, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,121,147,162,161,116,163,124],
[220,0,171,145,190,161,237,215],
[194,170,0,162,169,176,240,157],
[179,196,179,0,136,185,182,195],
[180,151,172,205,0,145,210,169],
[225,180,165,156,196,0,202,163],
[178,104,101,159,131,139,0,125],
[217,126,184,146,172,178,216,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 834, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,191,162,205,179,211,197],
[154,0,148,111,153,173,162,173],
[150,193,0,156,168,141,174,181],
[179,230,185,0,193,162,189,198],
[136,188,173,148,0,149,185,200],
[162,168,200,179,192,0,160,198],
[130,179,167,152,156,181,0,170],
[144,168,160,143,141,143,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 835, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,248,203,182,133,235,142],
[170,0,194,149,94,241,236,148],
[93,147,0,149,128,93,149,235],
[138,192,192,0,40,138,138,203],
[159,247,213,301,0,153,303,163],
[208,100,248,203,188,0,209,188],
[106,105,192,203,38,132,0,148],
[199,193,106,138,178,153,193,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 836, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,145,124,122,152,158,168,165],
[196,0,166,154,155,163,169,144],
[217,175,0,183,168,182,215,202],
[219,187,158,0,163,176,193,182],
[189,186,173,178,0,158,172,178],
[183,178,159,165,183,0,167,173],
[173,172,126,148,169,174,0,172],
[176,197,139,159,163,168,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 837, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,181,160,187,196,173,177],
[159,0,170,145,168,194,191,173],
[160,171,0,134,177,173,167,163],
[181,196,207,0,170,193,216,195],
[154,173,164,171,0,178,170,190],
[145,147,168,148,163,0,189,175],
[168,150,174,125,171,152,0,142],
[164,168,178,146,151,166,199,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 838, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,176,171,174,146,174,187],
[160,0,162,192,196,167,185,188],
[165,179,0,183,183,157,169,180],
[170,149,158,0,170,156,182,158],
[167,145,158,171,0,163,177,161],
[195,174,184,185,178,0,170,169],
[167,156,172,159,164,171,0,151],
[154,153,161,183,180,172,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 839, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,209,209,170,177,200,187,184],
[132,0,147,140,147,144,172,167],
[132,194,0,167,164,142,186,161],
[171,201,174,0,159,181,158,176],
[164,194,177,182,0,162,144,178],
[141,197,199,160,179,0,187,173],
[154,169,155,183,197,154,0,164],
[157,174,180,165,163,168,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 840, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,169,167,175,174,185,179],
[156,0,165,173,181,165,169,165],
[172,176,0,155,180,161,165,175],
[174,168,186,0,177,179,188,199],
[166,160,161,164,0,161,177,159],
[167,176,180,162,180,0,183,174],
[156,172,176,153,164,158,0,172],
[162,176,166,142,182,167,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 841, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,187,181,167,171,175,186],
[166,0,174,185,165,168,179,182],
[154,167,0,188,167,151,165,178],
[160,156,153,0,157,141,170,171],
[174,176,174,184,0,161,197,166],
[170,173,190,200,180,0,191,197],
[166,162,176,171,144,150,0,169],
[155,159,163,170,175,144,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 842, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,179,183,184,158,160,178],
[176,0,174,187,184,170,175,169],
[162,167,0,187,168,149,148,148],
[158,154,154,0,168,163,153,159],
[157,157,173,173,0,138,152,156],
[183,171,192,178,203,0,170,178],
[181,166,193,188,189,171,0,163],
[163,172,193,182,185,163,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 843, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,231,135,150,192,136,278,226],
[110,0,151,162,76,144,140,173],
[206,190,0,88,142,98,261,187],
[191,179,253,0,164,220,226,233],
[149,265,199,177,0,181,245,170],
[205,197,243,121,160,0,241,223],
[63,201,80,115,96,100,0,126],
[115,168,154,108,171,118,215,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 844, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,145,153,194,126,139,171],
[149,0,131,177,146,131,161,137],
[196,210,0,203,190,152,175,166],
[188,164,138,0,182,151,167,142],
[147,195,151,159,0,138,159,149],
[215,210,189,190,203,0,165,200],
[202,180,166,174,182,176,0,159],
[170,204,175,199,192,141,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 845, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,180,162,184,164,193,175],
[170,0,174,176,196,167,197,160],
[161,167,0,152,163,175,170,163],
[179,165,189,0,188,156,199,171],
[157,145,178,153,0,165,194,176],
[177,174,166,185,176,0,185,174],
[148,144,171,142,147,156,0,166],
[166,181,178,170,165,167,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 846, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,182,188,158,160,193,162],
[175,0,133,151,145,169,166,167],
[159,208,0,170,170,178,182,173],
[153,190,171,0,173,170,153,175],
[183,196,171,168,0,175,186,179],
[181,172,163,171,166,0,185,176],
[148,175,159,188,155,156,0,153],
[179,174,168,166,162,165,188,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 847, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,154,167,173,163,156,157],
[162,0,161,165,178,161,167,171],
[187,180,0,176,176,168,183,176],
[174,176,165,0,181,164,151,178],
[168,163,165,160,0,158,167,170],
[178,180,173,177,183,0,165,191],
[185,174,158,190,174,176,0,178],
[184,170,165,163,171,150,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 848, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,123,179,167,172,166,167],
[157,0,137,170,178,180,174,157],
[218,204,0,147,190,208,202,203],
[162,171,194,0,180,156,188,180],
[174,163,151,161,0,161,140,167],
[169,161,133,185,180,0,180,196],
[175,167,139,153,201,161,0,168],
[174,184,138,161,174,145,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 849, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,180,157,188,184,172,170],
[162,0,174,154,178,157,192,186],
[161,167,0,148,173,169,174,174],
[184,187,193,0,168,193,182,183],
[153,163,168,173,0,162,183,170],
[157,184,172,148,179,0,170,187],
[169,149,167,159,158,171,0,176],
[171,155,167,158,171,154,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 850, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,181,161,176,183,169,164],
[155,0,156,150,154,175,149,157],
[160,185,0,150,170,187,150,147],
[180,191,191,0,166,188,160,179],
[165,187,171,175,0,184,149,169],
[158,166,154,153,157,0,167,153],
[172,192,191,181,192,174,0,169],
[177,184,194,162,172,188,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 851, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,160,150,170,172,171,179],
[152,0,159,141,154,164,155,165],
[181,182,0,176,164,173,169,180],
[191,200,165,0,163,180,155,164],
[171,187,177,178,0,175,170,176],
[169,177,168,161,166,0,152,164],
[170,186,172,186,171,189,0,191],
[162,176,161,177,165,177,150,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 852, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,180,178,178,172,160,164],
[169,0,183,170,162,167,152,153],
[161,158,0,159,157,166,157,158],
[163,171,182,0,175,168,173,167],
[163,179,184,166,0,165,149,153],
[169,174,175,173,176,0,168,173],
[181,189,184,168,192,173,0,169],
[177,188,183,174,188,168,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 853, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,159,165,164,167,160,158],
[172,0,165,162,177,168,171,175],
[182,176,0,178,187,167,163,175],
[176,179,163,0,180,171,160,172],
[177,164,154,161,0,158,171,155],
[174,173,174,170,183,0,168,159],
[181,170,178,181,170,173,0,164],
[183,166,166,169,186,182,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 854, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,176,174,171,175,174,171],
[189,0,170,172,155,188,181,171],
[165,171,0,170,154,171,176,185],
[167,169,171,0,175,169,185,181],
[170,186,187,166,0,189,179,185],
[166,153,170,172,152,0,169,164],
[167,160,165,156,162,172,0,175],
[170,170,156,160,156,177,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 855, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,183,132,179,165,156,198],
[158,0,168,158,147,152,165,186],
[158,173,0,173,159,171,133,219],
[209,183,168,0,180,176,178,203],
[162,194,182,161,0,183,167,194],
[176,189,170,165,158,0,146,188],
[185,176,208,163,174,195,0,199],
[143,155,122,138,147,153,142,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 856, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,172,168,167,186,173,171],
[172,0,179,161,166,194,194,178],
[169,162,0,159,161,177,177,173],
[173,180,182,0,171,189,169,164],
[174,175,180,170,0,175,184,165],
[155,147,164,152,166,0,167,143],
[168,147,164,172,157,174,0,154],
[170,163,168,177,176,198,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 857, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,166,160,162,158,209,198],
[172,0,194,169,176,174,192,222],
[175,147,0,167,157,148,176,190],
[181,172,174,0,174,142,188,206],
[179,165,184,167,0,165,192,194],
[183,167,193,199,176,0,192,234],
[132,149,165,153,149,149,0,206],
[143,119,151,135,147,107,135,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 858, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,205,158,171,182,215,136,196],
[136,0,152,132,115,149,102,155],
[183,189,0,182,159,214,179,193],
[170,209,159,0,155,224,145,191],
[159,226,182,186,0,235,158,154],
[126,192,127,117,106,0,89,132],
[205,239,162,196,183,252,0,196],
[145,186,148,150,187,209,145,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 859, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,112,131,135,132,139,130,171],
[229,0,193,185,173,170,139,236],
[210,148,0,175,207,173,175,223],
[206,156,166,0,142,191,166,170],
[209,168,134,199,0,184,163,197],
[202,171,168,150,157,0,190,167],
[211,202,166,175,178,151,0,184],
[170,105,118,171,144,174,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 860, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,178,166,172,191,195,182],
[154,0,160,134,169,172,163,149],
[163,181,0,166,195,176,170,168],
[175,207,175,0,187,186,187,170],
[169,172,146,154,0,160,167,151],
[150,169,165,155,181,0,177,162],
[146,178,171,154,174,164,0,152],
[159,192,173,171,190,179,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 861, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,192,184,168,151,153,167],
[176,0,212,202,185,185,148,152],
[149,129,0,145,151,136,126,155],
[157,139,196,0,160,152,142,161],
[173,156,190,181,0,140,139,158],
[190,156,205,189,201,0,173,202],
[188,193,215,199,202,168,0,209],
[174,189,186,180,183,139,132,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 862, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,112,168,140,151,148,123,182],
[229,0,202,174,178,215,164,168],
[173,139,0,165,160,113,157,140],
[201,167,176,0,172,162,165,198],
[190,163,181,169,0,178,175,193],
[193,126,228,179,163,0,159,156],
[218,177,184,176,166,182,0,188],
[159,173,201,143,148,185,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 863, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,136,186,136,117,152,150,168],
[205,0,269,194,164,111,239,287],
[155,72,0,115,78,56,120,170],
[205,147,226,0,155,174,251,170],
[224,177,263,186,0,147,172,239],
[189,230,285,167,194,0,164,262],
[191,102,221,90,169,177,0,227],
[173,54,171,171,102,79,114,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 864, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,150,167,163,159,154,163,158],
[191,0,185,180,168,173,181,176],
[174,156,0,171,166,159,168,163],
[178,161,170,0,169,160,172,159],
[182,173,175,172,0,164,169,170],
[187,168,182,181,177,0,183,164],
[178,160,173,169,172,158,0,166],
[183,165,178,182,171,177,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 865, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,175,169,168,178,181,172],
[172,0,176,166,180,165,174,162],
[166,165,0,159,162,159,154,165],
[172,175,182,0,179,175,169,179],
[173,161,179,162,0,159,180,165],
[163,176,182,166,182,0,170,179],
[160,167,187,172,161,171,0,166],
[169,179,176,162,176,162,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 866, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,189,186,172,188,195,182],
[173,0,179,165,182,173,177,185],
[152,162,0,158,156,164,178,174],
[155,176,183,0,160,165,184,194],
[169,159,185,181,0,179,174,174],
[153,168,177,176,162,0,184,178],
[146,164,163,157,167,157,0,179],
[159,156,167,147,167,163,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 867, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,156,177,176,178,192,194],
[182,0,163,164,176,182,174,213],
[185,178,0,177,174,159,188,159],
[164,177,164,0,163,173,201,180],
[165,165,167,178,0,162,210,200],
[163,159,182,168,179,0,185,186],
[149,167,153,140,131,156,0,192],
[147,128,182,161,141,155,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 868, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,182,174,172,175,168,148],
[173,0,182,171,186,172,163,176],
[159,159,0,165,166,172,147,146],
[167,170,176,0,167,188,160,177],
[169,155,175,174,0,158,139,155],
[166,169,169,153,183,0,158,154],
[173,178,194,181,202,183,0,169],
[193,165,195,164,186,187,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 869, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,166,152,163,168,157,151],
[165,0,163,159,160,172,158,162],
[175,178,0,167,170,167,151,164],
[189,182,174,0,176,188,169,170],
[178,181,171,165,0,163,159,150],
[173,169,174,153,178,0,168,174],
[184,183,190,172,182,173,0,167],
[190,179,177,171,191,167,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 870, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,163,164,166,152,161,194],
[172,0,159,172,175,152,153,160],
[178,182,0,175,182,183,169,172],
[177,169,166,0,185,152,156,183],
[175,166,159,156,0,171,163,171],
[189,189,158,189,170,0,176,176],
[180,188,172,185,178,165,0,174],
[147,181,169,158,170,165,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 871, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,155,155,183,179,171,171],
[182,0,179,165,177,185,175,183],
[186,162,0,179,173,163,174,169],
[186,176,162,0,189,170,175,164],
[158,164,168,152,0,163,173,166],
[162,156,178,171,178,0,158,171],
[170,166,167,166,168,183,0,183],
[170,158,172,177,175,170,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 872, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,179,173,184,170,173,171],
[159,0,159,149,178,153,174,175],
[162,182,0,165,189,163,178,168],
[168,192,176,0,193,171,186,169],
[157,163,152,148,0,159,160,155],
[171,188,178,170,182,0,166,170],
[168,167,163,155,181,175,0,164],
[170,166,173,172,186,171,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 873, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,159,157,152,157,180,171],
[177,0,168,157,172,167,166,176],
[182,173,0,168,179,174,171,180],
[184,184,173,0,175,166,183,188],
[189,169,162,166,0,162,182,180],
[184,174,167,175,179,0,170,178],
[161,175,170,158,159,171,0,170],
[170,165,161,153,161,163,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 874, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,196,153,159,188,188,174,189],
[145,0,158,169,181,182,159,188],
[188,183,0,174,191,182,159,210],
[182,172,167,0,166,188,178,170],
[153,160,150,175,0,181,164,155],
[153,159,159,153,160,0,173,160],
[167,182,182,163,177,168,0,177],
[152,153,131,171,186,181,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 875, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,174,177,185,170,197,176],
[165,0,192,179,177,175,175,163],
[167,149,0,197,150,149,115,143],
[164,162,144,0,179,169,137,161],
[156,164,191,162,0,163,146,158],
[171,166,192,172,178,0,203,195],
[144,166,226,204,195,138,0,182],
[165,178,198,180,183,146,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 876, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,162,110,116,161,170,222],
[149,0,164,95,213,126,160,237],
[179,177,0,220,137,139,205,201],
[231,246,121,0,167,184,240,246],
[225,128,204,174,0,171,171,218],
[180,215,202,157,170,0,219,163],
[171,181,136,101,170,122,0,206],
[119,104,140,95,123,178,135,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 877, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,190,156,147,170,210,187],
[156,0,180,178,141,181,216,201],
[151,161,0,177,153,196,165,169],
[185,163,164,0,191,184,179,191],
[194,200,188,150,0,199,204,196],
[171,160,145,157,142,0,142,167],
[131,125,176,162,137,199,0,169],
[154,140,172,150,145,174,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 878, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,161,190,195,194,211,222],
[170,0,177,191,165,127,194,185],
[180,164,0,210,165,169,203,222],
[151,150,131,0,121,112,122,140],
[146,176,176,220,0,126,178,180],
[147,214,172,229,215,0,218,237],
[130,147,138,219,163,123,0,206],
[119,156,119,201,161,104,135,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 879, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,185,184,181,166,166,184],
[156,0,158,151,162,160,143,170],
[156,183,0,154,155,142,164,160],
[157,190,187,0,182,170,164,173],
[160,179,186,159,0,163,161,174],
[175,181,199,171,178,0,175,166],
[175,198,177,177,180,166,0,178],
[157,171,181,168,167,175,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 880, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,179,171,162,186,171,173],
[180,0,190,171,175,191,160,131],
[162,151,0,158,184,184,162,139],
[170,170,183,0,161,189,178,120],
[179,166,157,180,0,170,170,122],
[155,150,157,152,171,0,153,112],
[170,181,179,163,171,188,0,151],
[168,210,202,221,219,229,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 881, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,181,177,165,183,175,182],
[154,0,171,191,166,183,178,182],
[160,170,0,178,177,167,167,177],
[164,150,163,0,151,158,152,172],
[176,175,164,190,0,181,172,183],
[158,158,174,183,160,0,158,173],
[166,163,174,189,169,183,0,183],
[159,159,164,169,158,168,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 882, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,200,163,154,168,173,177],
[171,0,196,164,167,195,168,193],
[141,145,0,165,152,153,146,180],
[178,177,176,0,161,169,158,177],
[187,174,189,180,0,179,169,197],
[173,146,188,172,162,0,157,182],
[168,173,195,183,172,184,0,192],
[164,148,161,164,144,159,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 883, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,188,165,187,221,177,182],
[182,0,156,177,179,203,157,192],
[153,185,0,174,173,195,184,180],
[176,164,167,0,176,204,185,181],
[154,162,168,165,0,199,166,207],
[120,138,146,137,142,0,152,167],
[164,184,157,156,175,189,0,175],
[159,149,161,160,134,174,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 884, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,171,179,167,180,178,173],
[187,0,186,171,178,183,201,169],
[170,155,0,161,161,176,175,172],
[162,170,180,0,166,180,196,170],
[174,163,180,175,0,184,187,167],
[161,158,165,161,157,0,169,173],
[163,140,166,145,154,172,0,160],
[168,172,169,171,174,168,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 885, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,153,179,146,162,152,173],
[164,0,172,188,170,171,171,175],
[188,169,0,190,162,165,179,174],
[162,153,151,0,176,150,156,156],
[195,171,179,165,0,181,182,198],
[179,170,176,191,160,0,174,176],
[189,170,162,185,159,167,0,181],
[168,166,167,185,143,165,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 886, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,147,173,192,171,165,161],
[172,0,181,173,169,176,164,168],
[194,160,0,187,176,191,175,173],
[168,168,154,0,176,174,170,149],
[149,172,165,165,0,173,170,158],
[170,165,150,167,168,0,175,164],
[176,177,166,171,171,166,0,160],
[180,173,168,192,183,177,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 887, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,180,169,174,167,177,170],
[173,0,186,172,171,167,172,177],
[161,155,0,168,175,163,177,170],
[172,169,173,0,171,170,179,154],
[167,170,166,170,0,178,169,170],
[174,174,178,171,163,0,176,162],
[164,169,164,162,172,165,0,170],
[171,164,171,187,171,179,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 888, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,164,163,173,189,186,172],
[164,0,179,180,170,186,181,181],
[177,162,0,160,176,177,185,170],
[178,161,181,0,175,200,172,174],
[168,171,165,166,0,179,180,183],
[152,155,164,141,162,0,176,158],
[155,160,156,169,161,165,0,166],
[169,160,171,167,158,183,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 889, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,167,162,165,157,158,176],
[182,0,171,173,187,183,166,183],
[174,170,0,172,172,163,174,165],
[179,168,169,0,171,188,179,178],
[176,154,169,170,0,176,158,193],
[184,158,178,153,165,0,160,173],
[183,175,167,162,183,181,0,200],
[165,158,176,163,148,168,141,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 890, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,140,203,148,114,143,136],
[180,0,164,181,202,125,182,132],
[201,177,0,189,185,165,165,180],
[138,160,152,0,174,125,160,153],
[193,139,156,167,0,135,157,146],
[227,216,176,216,206,0,192,163],
[198,159,176,181,184,149,0,146],
[205,209,161,188,195,178,195,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 891, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,99,133,128,129,93,142],
[186,0,158,188,158,177,159,151],
[242,183,0,178,201,193,165,188],
[208,153,163,0,166,185,165,173],
[213,183,140,175,0,182,171,173],
[212,164,148,156,159,0,156,193],
[248,182,176,176,170,185,0,186],
[199,190,153,168,168,148,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 892, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,199,162,133,153,132,147,148],
[142,0,130,133,147,130,125,152],
[179,211,0,155,174,135,174,190],
[208,208,186,0,167,135,161,173],
[188,194,167,174,0,189,157,191],
[209,211,206,206,152,0,172,180],
[194,216,167,180,184,169,0,182],
[193,189,151,168,150,161,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 893, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,175,171,161,163,182,171],
[165,0,156,185,179,166,168,157],
[166,185,0,172,174,167,177,184],
[170,156,169,0,163,176,184,172],
[180,162,167,178,0,164,167,171],
[178,175,174,165,177,0,201,173],
[159,173,164,157,174,140,0,163],
[170,184,157,169,170,168,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 894, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,159,174,166,164,174,175],
[162,0,144,156,161,153,167,151],
[182,197,0,177,174,173,179,163],
[167,185,164,0,175,166,169,163],
[175,180,167,166,0,167,164,147],
[177,188,168,175,174,0,174,159],
[167,174,162,172,177,167,0,151],
[166,190,178,178,194,182,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 895, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,168,167,171,180,168,175],
[168,0,181,180,165,179,177,180],
[173,160,0,167,164,175,165,173],
[174,161,174,0,161,193,172,178],
[170,176,177,180,0,180,163,175],
[161,162,166,148,161,0,161,162],
[173,164,176,169,178,180,0,165],
[166,161,168,163,166,179,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 896, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,147,142,143,150,172,154],
[179,0,168,171,165,176,196,175],
[194,173,0,163,148,175,181,189],
[199,170,178,0,182,184,186,180],
[198,176,193,159,0,180,193,194],
[191,165,166,157,161,0,187,180],
[169,145,160,155,148,154,0,166],
[187,166,152,161,147,161,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 897, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,162,173,169,151,157,165],
[157,0,166,170,157,160,169,163],
[179,175,0,165,176,161,148,171],
[168,171,176,0,192,173,155,179],
[172,184,165,149,0,160,175,174],
[190,181,180,168,181,0,169,169],
[184,172,193,186,166,172,0,183],
[176,178,170,162,167,172,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 898, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,154,140,117,118,130,190],
[182,0,210,173,109,190,141,203],
[187,131,0,188,119,169,141,187],
[201,168,153,0,187,197,157,241],
[224,232,222,154,0,227,221,229],
[223,151,172,144,114,0,180,199],
[211,200,200,184,120,161,0,213],
[151,138,154,100,112,142,128,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 899, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,216,173,202,221,226,162,186],
[125,0,165,160,179,161,149,143],
[168,176,0,166,174,150,143,147],
[139,181,175,0,212,155,183,128],
[120,162,167,129,0,147,132,126],
[115,180,191,186,194,0,144,146],
[179,192,198,158,209,197,0,178],
[155,198,194,213,215,195,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 900, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,171,167,187,179,175,160],
[171,0,173,156,193,173,168,165],
[170,168,0,159,179,179,167,179],
[174,185,182,0,194,181,150,171],
[154,148,162,147,0,159,146,142],
[162,168,162,160,182,0,164,160],
[166,173,174,191,195,177,0,167],
[181,176,162,170,199,181,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 901, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,174,178,168,167,146,164],
[172,0,165,185,164,180,170,180],
[167,176,0,184,162,180,170,155],
[163,156,157,0,164,155,153,150],
[173,177,179,177,0,181,160,182],
[174,161,161,186,160,0,158,177],
[195,171,171,188,181,183,0,157],
[177,161,186,191,159,164,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 902, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,166,177,177,170,179,183],
[165,0,173,164,174,172,187,166],
[175,168,0,160,169,169,188,168],
[164,177,181,0,175,167,191,175],
[164,167,172,166,0,162,173,162],
[171,169,172,174,179,0,178,169],
[162,154,153,150,168,163,0,164],
[158,175,173,166,179,172,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 903, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,167,154,165,136,178,154],
[172,0,187,188,171,186,197,170],
[174,154,0,126,145,118,139,159],
[187,153,215,0,159,164,165,171],
[176,170,196,182,0,151,181,162],
[205,155,223,177,190,0,176,191],
[163,144,202,176,160,165,0,165],
[187,171,182,170,179,150,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 904, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,169,161,171,158,150,161],
[157,0,155,155,168,155,148,154],
[172,186,0,163,167,166,164,168],
[180,186,178,0,175,177,166,173],
[170,173,174,166,0,159,167,154],
[183,186,175,164,182,0,167,163],
[191,193,177,175,174,174,0,167],
[180,187,173,168,187,178,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 905, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,159,162,172,184,171,177],
[173,0,158,160,173,177,158,159],
[182,183,0,177,169,190,170,175],
[179,181,164,0,178,187,174,164],
[169,168,172,163,0,184,173,158],
[157,164,151,154,157,0,148,159],
[170,183,171,167,168,193,0,167],
[164,182,166,177,183,182,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 906, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,188,195,184,182,165,173],
[174,0,163,191,189,189,156,177],
[153,178,0,190,168,171,173,175],
[146,150,151,0,173,158,144,153],
[157,152,173,168,0,156,150,143],
[159,152,170,183,185,0,166,153],
[176,185,168,197,191,175,0,170],
[168,164,166,188,198,188,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 907, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,162,167,183,219,171,152],
[150,0,134,148,171,156,152,139],
[179,207,0,158,212,213,148,183],
[174,193,183,0,189,197,157,172],
[158,170,129,152,0,181,154,138],
[122,185,128,144,160,0,124,150],
[170,189,193,184,187,217,0,175],
[189,202,158,169,203,191,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 908, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,153,167,176,153,155,161],
[187,0,148,176,194,157,129,161],
[188,193,0,168,202,171,197,204],
[174,165,173,0,194,155,157,185],
[165,147,139,147,0,123,152,134],
[188,184,170,186,218,0,180,183],
[186,212,144,184,189,161,0,194],
[180,180,137,156,207,158,147,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 909, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,135,128,152,182,110,140,134],
[206,0,166,188,275,184,243,219],
[213,175,0,214,219,159,186,207],
[189,153,127,0,174,183,141,144],
[159,66,122,167,0,119,104,186],
[231,157,182,158,222,0,166,209],
[201,98,155,200,237,175,0,190],
[207,122,134,197,155,132,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 910, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,177,164,179,152,173,146],
[166,0,176,174,188,174,174,161],
[164,165,0,174,164,170,166,151],
[177,167,167,0,158,163,178,142],
[162,153,177,183,0,166,164,170],
[189,167,171,178,175,0,175,177],
[168,167,175,163,177,166,0,169],
[195,180,190,199,171,164,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 911, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,151,157,201,195,173,165],
[166,0,201,185,219,161,175,182],
[190,140,0,155,172,127,185,165],
[184,156,186,0,213,157,216,184],
[140,122,169,128,0,176,137,145],
[146,180,214,184,165,0,179,153],
[168,166,156,125,204,162,0,154],
[176,159,176,157,196,188,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 912, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,244,173,172,192,154,131,181],
[97,0,136,136,147,175,99,166],
[168,205,0,135,180,156,104,215],
[169,205,206,0,170,196,160,216],
[149,194,161,171,0,219,186,188],
[187,166,185,145,122,0,164,179],
[210,242,237,181,155,177,0,226],
[160,175,126,125,153,162,115,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 913, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,182,177,176,185,161,172],
[156,0,169,160,168,173,158,167],
[159,172,0,161,166,167,175,173],
[164,181,180,0,185,185,165,172],
[165,173,175,156,0,170,143,156],
[156,168,174,156,171,0,163,178],
[180,183,166,176,198,178,0,182],
[169,174,168,169,185,163,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 914, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,201,200,196,174,176,160,200],
[140,0,185,142,171,155,150,196],
[141,156,0,154,153,160,154,184],
[145,199,187,0,168,158,168,203],
[167,170,188,173,0,155,160,200],
[165,186,181,183,186,0,186,186],
[181,191,187,173,181,155,0,184],
[141,145,157,138,141,155,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 915, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,172,176,187,165,179,172],
[169,0,171,176,174,164,192,164],
[169,170,0,196,181,185,189,165],
[165,165,145,0,159,159,181,167],
[154,167,160,182,0,171,169,160],
[176,177,156,182,170,0,179,165],
[162,149,152,160,172,162,0,148],
[169,177,176,174,181,176,193,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 916, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,181,188,164,176,192,189],
[162,0,166,187,170,166,180,163],
[160,175,0,179,165,163,189,178],
[153,154,162,0,150,156,163,169],
[177,171,176,191,0,166,170,190],
[165,175,178,185,175,0,184,185],
[149,161,152,178,171,157,0,160],
[152,178,163,172,151,156,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 917, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,213,209,200,179,182,159,191],
[128,0,183,167,146,152,134,141],
[132,158,0,133,98,119,152,123],
[141,174,208,0,134,158,168,156],
[162,195,243,207,0,207,182,159],
[159,189,222,183,134,0,183,162],
[182,207,189,173,159,158,0,182],
[150,200,218,185,182,179,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 918, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,189,177,164,239,163,186],
[163,0,165,128,171,246,175,236],
[152,176,0,188,153,208,136,205],
[164,213,153,0,162,266,136,185],
[177,170,188,179,0,257,201,191],
[102,95,133,75,84,0,92,114],
[178,166,205,205,140,249,0,201],
[155,105,136,156,150,227,140,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 919, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,169,185,179,184,163,179],
[152,0,178,183,172,178,166,164],
[172,163,0,172,197,173,176,177],
[156,158,169,0,180,163,144,175],
[162,169,144,161,0,176,148,151],
[157,163,168,178,165,0,169,162],
[178,175,165,197,193,172,0,179],
[162,177,164,166,190,179,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 920, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,197,168,175,163,187,184,169],
[144,0,173,159,154,163,170,163],
[173,168,0,165,163,175,176,159],
[166,182,176,0,169,180,186,174],
[178,187,178,172,0,190,191,166],
[154,178,166,161,151,0,170,146],
[157,171,165,155,150,171,0,153],
[172,178,182,167,175,195,188,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 921, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,180,182,180,165,179,190],
[163,0,174,164,163,162,157,181],
[161,167,0,162,160,155,156,171],
[159,177,179,0,163,166,169,173],
[161,178,181,178,0,177,168,184],
[176,179,186,175,164,0,169,178],
[162,184,185,172,173,172,0,190],
[151,160,170,168,157,163,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 922, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,168,188,171,177,171,180],
[167,0,175,167,166,171,167,169],
[173,166,0,166,169,166,170,178],
[153,174,175,0,152,177,173,191],
[170,175,172,189,0,169,181,174],
[164,170,175,164,172,0,163,168],
[170,174,171,168,160,178,0,178],
[161,172,163,150,167,173,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 923, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,170,160,168,163,164,157],
[178,0,174,174,193,186,182,162],
[171,167,0,179,186,176,168,172],
[181,167,162,0,178,174,161,168],
[173,148,155,163,0,154,156,153],
[178,155,165,167,187,0,167,148],
[177,159,173,180,185,174,0,160],
[184,179,169,173,188,193,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 924, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,169,154,160,162,151,168],
[172,0,171,167,166,179,152,167],
[172,170,0,172,186,168,165,164],
[187,174,169,0,168,175,176,171],
[181,175,155,173,0,178,166,178],
[179,162,173,166,163,0,160,168],
[190,189,176,165,175,181,0,172],
[173,174,177,170,163,173,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 925, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,165,170,177,174,170,172],
[167,0,167,179,168,175,170,170],
[176,174,0,178,173,168,163,182],
[171,162,163,0,154,155,156,162],
[164,173,168,187,0,176,175,180],
[167,166,173,186,165,0,160,166],
[171,171,178,185,166,181,0,176],
[169,171,159,179,161,175,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 926, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,195,188,162,174,169,176,164],
[146,0,178,159,168,184,163,160],
[153,163,0,166,169,139,158,157],
[179,182,175,0,180,162,176,170],
[167,173,172,161,0,168,157,173],
[172,157,202,179,173,0,173,172],
[165,178,183,165,184,168,0,162],
[177,181,184,171,168,169,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 927, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,140,143,128,144,131,159,152],
[201,0,166,180,144,150,172,181],
[198,175,0,208,161,154,171,197],
[213,161,133,0,140,128,152,171],
[197,197,180,201,0,160,130,198],
[210,191,187,213,181,0,162,181],
[182,169,170,189,211,179,0,192],
[189,160,144,170,143,160,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 928, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,191,176,190,190,166,174],
[168,0,185,180,179,179,178,178],
[150,156,0,147,174,173,157,155],
[165,161,194,0,176,190,151,191],
[151,162,167,165,0,183,167,172],
[151,162,168,151,158,0,170,153],
[175,163,184,190,174,171,0,174],
[167,163,186,150,169,188,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 929, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,167,163,160,168,148,158],
[187,0,166,165,186,182,184,177],
[174,175,0,160,171,166,167,158],
[178,176,181,0,182,164,173,164],
[181,155,170,159,0,176,169,145],
[173,159,175,177,165,0,167,168],
[193,157,174,168,172,174,0,165],
[183,164,183,177,196,173,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 930, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,166,158,172,196,176,185],
[164,0,178,156,177,178,168,193],
[175,163,0,157,134,189,148,178],
[183,185,184,0,165,179,189,180],
[169,164,207,176,0,193,183,184],
[145,163,152,162,148,0,136,153],
[165,173,193,152,158,205,0,187],
[156,148,163,161,157,188,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 931, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,173,178,152,151,149,154],
[169,0,179,162,172,158,175,169],
[168,162,0,190,164,170,169,171],
[163,179,151,0,131,163,139,165],
[189,169,177,210,0,164,172,183],
[190,183,171,178,177,0,173,169],
[192,166,172,202,169,168,0,176],
[187,172,170,176,158,172,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 932, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,160,151,165,168,158,172],
[175,0,171,166,180,180,172,180],
[181,170,0,171,172,175,164,180],
[190,175,170,0,177,184,175,172],
[176,161,169,164,0,183,157,172],
[173,161,166,157,158,0,156,159],
[183,169,177,166,184,185,0,167],
[169,161,161,169,169,182,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 933, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,148,157,153,170,158,152,160],
[193,0,183,171,182,181,182,169],
[184,158,0,155,160,161,180,172],
[188,170,186,0,185,185,178,177],
[171,159,181,156,0,179,174,159],
[183,160,180,156,162,0,158,166],
[189,159,161,163,167,183,0,173],
[181,172,169,164,182,175,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 934, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,149,160,169,157,156,176,161],
[192,0,183,170,175,185,181,179],
[181,158,0,163,144,167,173,167],
[172,171,178,0,162,170,186,169],
[184,166,197,179,0,177,188,179],
[185,156,174,171,164,0,188,149],
[165,160,168,155,153,153,0,170],
[180,162,174,172,162,192,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 935, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,178,156,158,158,144,171],
[178,0,176,145,178,181,166,183],
[163,165,0,145,149,152,164,166],
[185,196,196,0,178,198,169,191],
[183,163,192,163,0,178,172,181],
[183,160,189,143,163,0,160,169],
[197,175,177,172,169,181,0,189],
[170,158,175,150,160,172,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 936, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,182,231,174,168,162,143],
[182,0,173,195,160,160,155,134],
[159,168,0,180,154,166,172,147],
[110,146,161,0,155,139,138,114],
[167,181,187,186,0,164,205,149],
[173,181,175,202,177,0,196,143],
[179,186,169,203,136,145,0,176],
[198,207,194,227,192,198,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 937, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,169,158,168,162,183,172],
[156,0,164,164,157,162,177,161],
[172,177,0,175,172,170,183,166],
[183,177,166,0,154,157,174,165],
[173,184,169,187,0,174,173,191],
[179,179,171,184,167,0,175,167],
[158,164,158,167,168,166,0,163],
[169,180,175,176,150,174,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 938, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,157,151,156,159,170,165],
[162,0,153,149,159,153,168,166],
[184,188,0,172,163,179,179,181],
[190,192,169,0,179,187,183,189],
[185,182,178,162,0,171,188,181],
[182,188,162,154,170,0,171,168],
[171,173,162,158,153,170,0,164],
[176,175,160,152,160,173,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 939, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,173,177,161,171,177,163],
[172,0,168,166,170,170,169,169],
[168,173,0,178,163,161,181,171],
[164,175,163,0,157,168,163,159],
[180,171,178,184,0,173,174,167],
[170,171,180,173,168,0,168,165],
[164,172,160,178,167,173,0,159],
[178,172,170,182,174,176,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 940, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,168,174,182,184,177,166],
[168,0,173,167,160,174,184,175],
[173,168,0,160,172,189,166,181],
[167,174,181,0,176,188,182,184],
[159,181,169,165,0,188,160,171],
[157,167,152,153,153,0,152,149],
[164,157,175,159,181,189,0,181],
[175,166,160,157,170,192,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 941, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,145,140,149,143,176,163,166],
[196,0,176,198,147,192,190,166],
[201,165,0,183,187,193,183,183],
[192,143,158,0,143,206,166,179],
[198,194,154,198,0,213,195,183],
[165,149,148,135,128,0,149,147],
[178,151,158,175,146,192,0,181],
[175,175,158,162,158,194,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 942, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,247,235,304,265,141,210,304],
[94,0,228,221,228,134,221,221],
[106,113,0,304,207,180,210,304],
[37,120,37,0,138,37,210,297],
[76,113,134,203,0,134,203,203],
[200,207,161,304,207,0,304,304],
[131,120,131,131,138,37,0,297],
[37,120,37,44,138,37,44,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 943, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,185,165,215,173,188,164],
[156,0,152,153,153,174,193,159],
[156,189,0,172,198,188,192,181],
[176,188,169,0,210,191,220,162],
[126,188,143,131,0,137,153,136],
[168,167,153,150,204,0,181,177],
[153,148,149,121,188,160,0,159],
[177,182,160,179,205,164,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 944, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,155,169,157,153,177,160],
[188,0,165,165,175,173,183,179],
[186,176,0,181,183,157,180,169],
[172,176,160,0,162,157,168,169],
[184,166,158,179,0,168,187,165],
[188,168,184,184,173,0,192,175],
[164,158,161,173,154,149,0,160],
[181,162,172,172,176,166,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 945, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,157,176,167,186,166,162],
[190,0,172,185,182,192,181,164],
[184,169,0,186,175,191,178,172],
[165,156,155,0,171,181,165,158],
[174,159,166,170,0,184,172,165],
[155,149,150,160,157,0,162,154],
[175,160,163,176,169,179,0,159],
[179,177,169,183,176,187,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 946, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,159,196,168,136,173,172],
[180,0,192,208,186,161,188,176],
[182,149,0,196,165,171,163,150],
[145,133,145,0,137,119,149,152],
[173,155,176,204,0,165,156,121],
[205,180,170,222,176,0,203,189],
[168,153,178,192,185,138,0,177],
[169,165,191,189,220,152,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 947, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,184,198,169,189,165,181],
[168,0,175,197,174,181,167,173],
[157,166,0,182,183,188,175,182],
[143,144,159,0,154,164,146,165],
[172,167,158,187,0,178,163,165],
[152,160,153,177,163,0,154,166],
[176,174,166,195,178,187,0,194],
[160,168,159,176,176,175,147,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 948, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,189,179,180,178,175,178],
[171,0,184,175,169,179,171,176],
[152,157,0,168,172,166,169,156],
[162,166,173,0,160,176,160,168],
[161,172,169,181,0,163,166,165],
[163,162,175,165,178,0,156,168],
[166,170,172,181,175,185,0,173],
[163,165,185,173,176,173,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 949, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,148,176,174,161,151,156],
[170,0,181,188,184,172,166,171],
[193,160,0,178,195,165,179,173],
[165,153,163,0,184,166,146,173],
[167,157,146,157,0,153,162,155],
[180,169,176,175,188,0,177,171],
[190,175,162,195,179,164,0,174],
[185,170,168,168,186,170,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 950, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,170,160,156,171,160,162],
[167,0,159,162,164,158,163,160],
[171,182,0,172,171,161,178,165],
[181,179,169,0,169,177,162,175],
[185,177,170,172,0,177,170,166],
[170,183,180,164,164,0,157,174],
[181,178,163,179,171,184,0,173],
[179,181,176,166,175,167,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 951, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,179,182,185,183,174,183],
[178,0,157,180,176,176,179,180],
[162,184,0,172,169,164,164,179],
[159,161,169,0,158,149,155,179],
[156,165,172,183,0,164,168,173],
[158,165,177,192,177,0,161,180],
[167,162,177,186,173,180,0,173],
[158,161,162,162,168,161,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 952, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,163,165,169,174,173,158],
[157,0,159,154,164,162,174,158],
[178,182,0,167,174,173,190,167],
[176,187,174,0,174,169,186,177],
[172,177,167,167,0,164,175,166],
[167,179,168,172,177,0,172,153],
[168,167,151,155,166,169,0,160],
[183,183,174,164,175,188,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 953, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,184,171,198,170,191,182],
[153,0,151,152,182,160,177,162],
[157,190,0,181,172,173,187,165],
[170,189,160,0,195,169,197,170],
[143,159,169,146,0,162,160,156],
[171,181,168,172,179,0,174,167],
[150,164,154,144,181,167,0,167],
[159,179,176,171,185,174,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 954, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,212,187,161,142,139,192,125],
[129,0,178,164,195,146,174,156],
[154,163,0,128,177,158,169,181],
[180,177,213,0,184,187,175,167],
[199,146,164,157,0,151,159,123],
[202,195,183,154,190,0,178,194],
[149,167,172,166,182,163,0,165],
[216,185,160,174,218,147,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 955, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,165,154,163,165,184,174],
[165,0,164,161,147,153,182,173],
[176,177,0,152,148,153,163,160],
[187,180,189,0,163,175,188,160],
[178,194,193,178,0,187,170,188],
[176,188,188,166,154,0,188,170],
[157,159,178,153,171,153,0,174],
[167,168,181,181,153,171,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 956, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,147,178,178,218,156,182],
[155,0,130,157,169,183,146,151],
[194,211,0,177,175,213,153,158],
[163,184,164,0,195,186,155,140],
[163,172,166,146,0,198,148,167],
[123,158,128,155,143,0,133,118],
[185,195,188,186,193,208,0,161],
[159,190,183,201,174,223,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 957, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,164,169,173,183,166,175],
[168,0,160,159,171,167,160,168],
[177,181,0,175,173,174,166,182],
[172,182,166,0,173,174,173,174],
[168,170,168,168,0,171,168,176],
[158,174,167,167,170,0,171,175],
[175,181,175,168,173,170,0,171],
[166,173,159,167,165,166,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 958, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,187,187,175,180,195,176],
[171,0,187,203,168,166,192,174],
[154,154,0,180,144,165,170,157],
[154,138,161,0,158,158,179,162],
[166,173,197,183,0,178,191,173],
[161,175,176,183,163,0,194,171],
[146,149,171,162,150,147,0,153],
[165,167,184,179,168,170,188,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 959, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,143,162,142,176,156,155,158],
[198,0,166,155,187,170,188,178],
[179,175,0,155,185,166,175,179],
[199,186,186,0,189,164,189,193],
[165,154,156,152,0,162,153,163],
[185,171,175,177,179,0,182,162],
[186,153,166,152,188,159,0,179],
[183,163,162,148,178,179,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 960, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,235,180,133,181,196,196],
[179,0,171,177,117,104,128,160],
[106,170,0,137,204,127,215,134],
[161,164,204,0,147,190,208,199],
[208,224,137,194,0,134,133,207],
[160,237,214,151,207,0,185,187],
[145,213,126,133,208,156,0,150],
[145,181,207,142,134,154,191,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 961, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,190,196,151,164,183,156,196],
[151,0,141,147,152,165,137,150],
[145,200,0,171,168,184,176,166],
[190,194,170,0,171,170,147,178],
[177,189,173,170,0,181,172,176],
[158,176,157,171,160,0,165,166],
[185,204,165,194,169,176,0,193],
[145,191,175,163,165,175,148,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 962, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,174,181,179,155,166,183],
[177,0,180,164,176,189,172,183],
[167,161,0,172,171,172,163,182],
[160,177,169,0,183,148,148,161],
[162,165,170,158,0,171,158,164],
[186,152,169,193,170,0,171,186],
[175,169,178,193,183,170,0,206],
[158,158,159,180,177,155,135,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 963, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,125,155,161,148,149,150,141],
[216,0,202,184,175,185,178,170],
[186,139,0,171,162,153,180,144],
[180,157,170,0,167,166,167,164],
[193,166,179,174,0,165,170,160],
[192,156,188,175,176,0,162,154],
[191,163,161,174,171,179,0,184],
[200,171,197,177,181,187,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 964, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,156,163,167,166,169,164],
[188,0,173,167,190,155,187,178],
[185,168,0,155,170,161,182,166],
[178,174,186,0,170,180,190,182],
[174,151,171,171,0,161,188,165],
[175,186,180,161,180,0,173,181],
[172,154,159,151,153,168,0,173],
[177,163,175,159,176,160,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 965, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,193,148,152,185,158,180,177],
[148,0,128,285,141,128,221,201],
[193,213,0,184,149,184,221,259],
[189,56,157,0,125,151,113,144],
[156,200,192,216,0,138,160,211],
[183,213,157,190,203,0,157,237],
[161,120,120,228,181,184,0,209],
[164,140,82,197,130,104,132,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 966, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,136,139,174,151,204,144,193],
[205,0,191,185,150,187,195,222],
[202,150,0,194,197,226,170,188],
[167,156,147,0,156,231,176,183],
[190,191,144,185,0,163,181,173],
[137,154,115,110,178,0,102,138],
[197,146,171,165,160,239,0,195],
[148,119,153,158,168,203,146,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 967, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,91,152,134,106,106,153,127],
[250,0,152,169,250,143,153,180],
[189,189,0,179,257,188,292,133],
[207,172,162,0,197,90,163,100],
[235,91,84,144,0,0,163,60],
[235,198,153,251,341,0,231,167],
[188,188,49,178,178,110,0,122],
[214,161,208,241,281,174,219,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 968, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,168,145,174,171,154,165],
[182,0,187,177,199,162,175,183],
[173,154,0,165,188,172,169,154],
[196,164,176,0,170,176,156,173],
[167,142,153,171,0,160,150,179],
[170,179,169,165,181,0,160,181],
[187,166,172,185,191,181,0,180],
[176,158,187,168,162,160,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 969, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,174,179,169,155,162,151],
[178,0,167,186,162,175,174,161],
[167,174,0,182,162,156,181,161],
[162,155,159,0,150,144,148,149],
[172,179,179,191,0,157,190,160],
[186,166,185,197,184,0,183,172],
[179,167,160,193,151,158,0,155],
[190,180,180,192,181,169,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 970, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,165,170,178,172,169,167],
[178,0,180,177,178,189,163,187],
[176,161,0,171,163,166,145,166],
[171,164,170,0,167,183,171,169],
[163,163,178,174,0,182,151,173],
[169,152,175,158,159,0,164,169],
[172,178,196,170,190,177,0,183],
[174,154,175,172,168,172,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 971, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,172,165,169,171,166,172],
[190,0,180,169,183,181,180,184],
[169,161,0,169,162,179,167,178],
[176,172,172,0,158,183,175,175],
[172,158,179,183,0,176,160,178],
[170,160,162,158,165,0,167,175],
[175,161,174,166,181,174,0,180],
[169,157,163,166,163,166,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 972, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,189,164,178,178,170,182],
[169,0,171,177,164,177,154,179],
[152,170,0,161,158,172,179,172],
[177,164,180,0,164,183,165,193],
[163,177,183,177,0,191,175,179],
[163,164,169,158,150,0,172,171],
[171,187,162,176,166,169,0,174],
[159,162,169,148,162,170,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 973, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,204,174,166,177,199,158,180],
[137,0,174,147,166,160,149,186],
[167,167,0,154,174,180,185,193],
[175,194,187,0,168,187,188,192],
[164,175,167,173,0,163,178,203],
[142,181,161,154,178,0,151,155],
[183,192,156,153,163,190,0,195],
[161,155,148,149,138,186,146,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 974, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,187,185,157,175,171,180],
[166,0,162,178,158,151,182,158],
[154,179,0,180,164,168,179,181],
[156,163,161,0,150,158,170,158],
[184,183,177,191,0,169,183,174],
[166,190,173,183,172,0,178,174],
[170,159,162,171,158,163,0,166],
[161,183,160,183,167,167,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 975, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,164,170,183,157,170,164],
[177,0,176,179,179,167,170,161],
[177,165,0,181,180,168,177,162],
[171,162,160,0,175,154,171,169],
[158,162,161,166,0,157,170,164],
[184,174,173,187,184,0,168,177],
[171,171,164,170,171,173,0,175],
[177,180,179,172,177,164,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 976, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,178,174,174,172,187,169],
[163,0,157,158,159,157,174,153],
[163,184,0,177,162,173,169,177],
[167,183,164,0,173,181,175,177],
[167,182,179,168,0,160,171,169],
[169,184,168,160,181,0,173,166],
[154,167,172,166,170,168,0,163],
[172,188,164,164,172,175,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 977, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,177,176,191,176,178,164],
[158,0,169,165,165,160,162,153],
[164,172,0,172,165,159,175,153],
[165,176,169,0,171,165,158,172],
[150,176,176,170,0,162,168,157],
[165,181,182,176,179,0,167,160],
[163,179,166,183,173,174,0,156],
[177,188,188,169,184,181,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 978, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,190,169,164,171,162,163,165],
[151,0,164,154,173,166,179,158],
[172,177,0,159,171,158,169,155],
[177,187,182,0,176,170,172,165],
[170,168,170,165,0,157,179,161],
[179,175,183,171,184,0,169,173],
[178,162,172,169,162,172,0,154],
[176,183,186,176,180,168,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 979, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,184,165,193,172,167,172],
[166,0,179,153,210,162,162,185],
[157,162,0,159,181,169,158,171],
[176,188,182,0,222,153,187,189],
[148,131,160,119,0,140,150,159],
[169,179,172,188,201,0,159,192],
[174,179,183,154,191,182,0,191],
[169,156,170,152,182,149,150,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 980, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,158,133,160,165,185,181],
[190,0,159,134,190,178,177,176],
[183,182,0,178,196,169,198,190],
[208,207,163,0,198,157,162,192],
[181,151,145,143,0,134,165,180],
[176,163,172,184,207,0,208,199],
[156,164,143,179,176,133,0,172],
[160,165,151,149,161,142,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 981, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,137,169,201,180,152,158],
[163,0,170,175,168,179,198,184],
[204,171,0,166,213,187,233,174],
[172,166,175,0,194,157,203,169],
[140,173,128,147,0,157,172,141],
[161,162,154,184,184,0,163,156],
[189,143,108,138,169,178,0,98],
[183,157,167,172,200,185,243,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 982, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,194,166,181,195,167,176],
[160,0,161,161,165,162,162,160],
[147,180,0,184,168,168,158,159],
[175,180,157,0,162,184,184,170],
[160,176,173,179,0,183,156,178],
[146,179,173,157,158,0,164,161],
[174,179,183,157,185,177,0,161],
[165,181,182,171,163,180,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 983, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,166,168,172,160,162,185],
[172,0,172,172,153,160,163,166],
[175,169,0,182,156,166,161,169],
[173,169,159,0,162,171,157,168],
[169,188,185,179,0,177,165,172],
[181,181,175,170,164,0,172,170],
[179,178,180,184,176,169,0,176],
[156,175,172,173,169,171,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 984, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,181,181,173,178,181,178],
[174,0,170,161,162,169,171,175],
[160,171,0,172,172,160,175,160],
[160,180,169,0,172,174,187,164],
[168,179,169,169,0,175,182,166],
[163,172,181,167,166,0,171,170],
[160,170,166,154,159,170,0,160],
[163,166,181,177,175,171,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 985, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,178,177,183,176,160,172],
[178,0,167,177,180,174,152,165],
[163,174,0,189,181,174,171,172],
[164,164,152,0,181,166,152,172],
[158,161,160,160,0,163,149,162],
[165,167,167,175,178,0,157,171],
[181,189,170,189,192,184,0,185],
[169,176,169,169,179,170,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 986, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,180,175,180,156,170,175],
[170,0,183,174,189,169,173,182],
[161,158,0,165,171,164,163,163],
[166,167,176,0,186,176,173,176],
[161,152,170,155,0,147,155,163],
[185,172,177,165,194,0,169,172],
[171,168,178,168,186,172,0,171],
[166,159,178,165,178,169,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 987, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,179,174,155,158,149,166],
[188,0,205,165,185,178,168,179],
[162,136,0,166,159,165,130,153],
[167,176,175,0,188,170,172,172],
[186,156,182,153,0,171,148,159],
[183,163,176,171,170,0,160,175],
[192,173,211,169,193,181,0,164],
[175,162,188,169,182,166,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 988, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,167,171,207,182,162,182],
[163,0,135,137,175,159,151,154],
[174,206,0,173,199,186,163,181],
[170,204,168,0,174,179,171,153],
[134,166,142,167,0,177,159,163],
[159,182,155,162,164,0,145,171],
[179,190,178,170,182,196,0,206],
[159,187,160,188,178,170,135,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 989, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,204,174,173,153,184,196,198],
[137,0,148,131,155,173,170,179],
[167,193,0,166,189,186,201,202],
[168,210,175,0,175,187,194,178],
[188,186,152,166,0,168,198,182],
[157,168,155,154,173,0,188,179],
[145,171,140,147,143,153,0,147],
[143,162,139,163,159,162,194,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 990, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,169,181,163,167,158,153],
[168,0,172,176,163,183,163,170],
[172,169,0,190,171,173,170,190],
[160,165,151,0,166,165,166,161],
[178,178,170,175,0,180,174,165],
[174,158,168,176,161,0,176,166],
[183,178,171,175,167,165,0,166],
[188,171,151,180,176,175,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 991, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,139,183,158,161,157,180],
[177,0,143,200,185,133,175,136],
[202,198,0,206,198,162,181,174],
[158,141,135,0,183,130,166,121],
[183,156,143,158,0,149,145,156],
[180,208,179,211,192,0,204,147],
[184,166,160,175,196,137,0,144],
[161,205,167,220,185,194,197,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 992, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,159,160,174,171,162,156],
[182,0,172,170,181,163,171,155],
[182,169,0,173,173,175,176,173],
[181,171,168,0,178,167,166,165],
[167,160,168,163,0,157,163,151],
[170,178,166,174,184,0,180,174],
[179,170,165,175,178,161,0,174],
[185,186,168,176,190,167,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 993, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,171,190,165,170,187,152],
[153,0,154,187,159,180,147,141],
[170,187,0,189,158,169,180,148],
[151,154,152,0,192,164,149,147],
[176,182,183,149,0,175,166,178],
[171,161,172,177,166,0,174,142],
[154,194,161,192,175,167,0,153],
[189,200,193,194,163,199,188,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 994, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,181,180,194,159,180,168],
[161,0,179,174,212,167,170,164],
[160,162,0,171,183,174,169,158],
[161,167,170,0,181,158,165,155],
[147,129,158,160,0,145,147,146],
[182,174,167,183,196,0,170,172],
[161,171,172,176,194,171,0,174],
[173,177,183,186,195,169,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 995, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,142,175,161,163,140,142],
[177,0,183,170,172,176,175,185],
[199,158,0,146,166,171,142,142],
[166,171,195,0,176,175,170,193],
[180,169,175,165,0,165,165,148],
[178,165,170,166,176,0,165,162],
[201,166,199,171,176,176,0,168],
[199,156,199,148,193,179,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 996, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,149,161,164,156,155,166],
[177,0,178,182,164,161,162,165],
[192,163,0,165,168,165,169,173],
[180,159,176,0,174,176,166,191],
[177,177,173,167,0,168,172,176],
[185,180,176,165,173,0,171,183],
[186,179,172,175,169,170,0,177],
[175,176,168,150,165,158,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 997, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,180,160,162,172,164,169],
[169,0,167,171,162,171,155,158],
[161,174,0,162,164,172,161,168],
[181,170,179,0,181,171,165,166],
[179,179,177,160,0,180,171,173],
[169,170,169,170,161,0,165,169],
[177,186,180,176,170,176,0,184],
[172,183,173,175,168,172,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 998, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,167,162,171,157,169,167],
[189,0,184,185,178,195,165,189],
[174,157,0,177,174,171,162,178],
[179,156,164,0,166,176,157,185],
[170,163,167,175,0,156,172,154],
[184,146,170,165,185,0,159,181],
[172,176,179,184,169,182,0,188],
[174,152,163,156,187,160,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 999, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,182,177,204,161,184,174],
[166,0,175,141,177,126,167,150],
[159,166,0,149,164,158,151,156],
[164,200,192,0,190,186,188,166],
[137,164,177,151,0,163,187,145],
[180,215,183,155,178,0,184,168],
[157,174,190,153,154,157,0,169],
[167,191,185,175,196,173,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1000, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,160,171,169,162,176,175],
[173,0,162,187,167,166,158,176],
[181,179,0,176,156,167,169,165],
[170,154,165,0,176,174,158,175],
[172,174,185,165,0,169,194,194],
[179,175,174,167,172,0,175,181],
[165,183,172,183,147,166,0,186],
[166,165,176,166,147,160,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1001, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,199,204,189,152,195,184,172],
[142,0,166,163,154,162,130,146],
[137,175,0,149,162,152,157,163],
[152,178,192,0,191,182,172,185],
[189,187,179,150,0,166,184,170],
[146,179,189,159,175,0,154,161],
[157,211,184,169,157,187,0,156],
[169,195,178,156,171,180,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1002, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,170,172,171,187,205,240],
[167,0,100,152,120,151,236,253],
[171,241,0,189,173,136,240,238],
[169,189,152,0,154,170,206,241],
[170,221,168,187,0,135,222,218],
[154,190,205,171,206,0,223,237],
[136,105,101,135,119,118,0,205],
[101,88,103,100,123,104,136,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1003, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,179,170,171,169,185,184],
[162,0,172,161,165,173,177,163],
[162,169,0,173,176,168,164,172],
[171,180,168,0,166,176,191,179],
[170,176,165,175,0,177,184,171],
[172,168,173,165,164,0,184,159],
[156,164,177,150,157,157,0,157],
[157,178,169,162,170,182,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1004, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,163,162,150,140,182,144],
[162,0,171,161,178,174,182,177],
[178,170,0,200,195,183,233,204],
[179,180,141,0,196,159,193,174],
[191,163,146,145,0,138,199,147],
[201,167,158,182,203,0,228,149],
[159,159,108,148,142,113,0,125],
[197,164,137,167,194,192,216,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1005, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,186,196,171,161,167,169],
[176,0,192,180,169,173,171,188],
[155,149,0,166,151,163,154,160],
[145,161,175,0,149,161,143,150],
[170,172,190,192,0,175,171,187],
[180,168,178,180,166,0,183,175],
[174,170,187,198,170,158,0,177],
[172,153,181,191,154,166,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1006, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,170,164,169,169,178,161],
[166,0,157,158,146,169,166,140],
[171,184,0,180,165,179,182,176],
[177,183,161,0,168,187,176,161],
[172,195,176,173,0,182,172,163],
[172,172,162,154,159,0,179,156],
[163,175,159,165,169,162,0,149],
[180,201,165,180,178,185,192,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1007, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,140,138,147,143,147,155,150],
[201,0,177,173,164,168,169,177],
[203,164,0,170,187,168,165,177],
[194,168,171,0,184,177,171,166],
[198,177,154,157,0,170,178,170],
[194,173,173,164,171,0,179,172],
[186,172,176,170,163,162,0,169],
[191,164,164,175,171,169,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1008, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,136,197,137,177,159,139,160],
[205,0,225,162,161,203,221,182],
[144,116,0,117,118,140,139,121],
[204,179,224,0,199,223,203,163],
[164,180,223,142,0,201,241,182],
[182,138,201,118,140,0,141,123],
[202,120,202,138,100,200,0,181],
[181,159,220,178,159,218,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1009, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,177,164,150,166,165,184],
[162,0,173,168,167,172,155,160],
[164,168,0,171,178,172,177,189],
[177,173,170,0,159,165,168,198],
[191,174,163,182,0,187,176,195],
[175,169,169,176,154,0,155,175],
[176,186,164,173,165,186,0,183],
[157,181,152,143,146,166,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1010, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,132,175,209,192,211,207],
[165,0,189,208,171,208,186,226],
[209,152,0,156,211,191,207,206],
[166,133,185,0,170,206,240,146],
[132,170,130,171,0,151,169,187],
[149,133,150,135,190,0,208,187],
[130,155,134,101,172,133,0,170],
[134,115,135,195,154,154,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1011, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,178,168,174,169,184,157],
[174,0,183,186,170,166,188,170],
[163,158,0,187,147,161,167,158],
[173,155,154,0,147,170,166,149],
[167,171,194,194,0,167,198,185],
[172,175,180,171,174,0,165,168],
[157,153,174,175,143,176,0,163],
[184,171,183,192,156,173,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1012, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,162,167,187,184,162,183],
[157,0,157,135,147,146,135,153],
[179,184,0,165,159,176,166,174],
[174,206,176,0,163,183,184,178],
[154,194,182,178,0,180,190,171],
[157,195,165,158,161,0,159,145],
[179,206,175,157,151,182,0,156],
[158,188,167,163,170,196,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1013, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,150,158,206,149,165,173,156],
[191,0,186,189,149,182,153,191],
[183,155,0,168,164,173,168,168],
[135,152,173,0,151,149,138,157],
[192,192,177,190,0,187,167,165],
[176,159,168,192,154,0,151,174],
[168,188,173,203,174,190,0,161],
[185,150,173,184,176,167,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1014, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,171,178,174,178,168,169],
[168,0,175,175,183,182,172,203],
[170,166,0,181,173,174,166,175],
[163,166,160,0,180,169,167,178],
[167,158,168,161,0,172,170,181],
[163,159,167,172,169,0,161,186],
[173,169,175,174,171,180,0,172],
[172,138,166,163,160,155,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1015, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,181,145,172,147,169,162],
[180,0,175,159,171,156,165,156],
[160,166,0,154,169,162,182,139],
[196,182,187,0,179,172,183,163],
[169,170,172,162,0,156,153,143],
[194,185,179,169,185,0,179,176],
[172,176,159,158,188,162,0,161],
[179,185,202,178,198,165,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1016, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,187,177,170,174,159,175],
[157,0,184,163,161,169,162,156],
[154,157,0,157,160,155,164,156],
[164,178,184,0,177,168,174,167],
[171,180,181,164,0,169,161,177],
[167,172,186,173,172,0,173,175],
[182,179,177,167,180,168,0,176],
[166,185,185,174,164,166,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1017, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,197,181,181,166,178,185,196],
[144,0,163,148,169,154,144,153],
[160,178,0,155,167,173,171,171],
[160,193,186,0,183,162,179,190],
[175,172,174,158,0,170,173,167],
[163,187,168,179,171,0,180,187],
[156,197,170,162,168,161,0,179],
[145,188,170,151,174,154,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1018, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,170,188,180,186,211,180],
[170,0,157,173,183,176,190,168],
[171,184,0,183,164,187,177,187],
[153,168,158,0,180,163,167,166],
[161,158,177,161,0,163,170,167],
[155,165,154,178,178,0,189,157],
[130,151,164,174,171,152,0,159],
[161,173,154,175,174,184,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1019, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,155,164,165,152,154,155],
[181,0,171,174,180,165,167,164],
[186,170,0,189,175,172,172,184],
[177,167,152,0,176,160,160,167],
[176,161,166,165,0,156,161,159],
[189,176,169,181,185,0,168,167],
[187,174,169,181,180,173,0,170],
[186,177,157,174,182,174,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1020, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,192,173,168,186,177,165],
[168,0,184,165,178,170,171,173],
[149,157,0,173,151,168,166,153],
[168,176,168,0,165,178,172,161],
[173,163,190,176,0,172,171,158],
[155,171,173,163,169,0,170,158],
[164,170,175,169,170,171,0,161],
[176,168,188,180,183,183,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1021, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,168,197,186,168,181,185],
[174,0,187,195,164,166,168,183],
[173,154,0,182,168,169,170,180],
[144,146,159,0,143,166,150,158],
[155,177,173,198,0,172,161,172],
[173,175,172,175,169,0,160,168],
[160,173,171,191,180,181,0,190],
[156,158,161,183,169,173,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1022, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,175,182,195,181,169,172],
[167,0,177,185,181,189,165,163],
[166,164,0,181,188,167,174,149],
[159,156,160,0,176,179,148,161],
[146,160,153,165,0,156,149,155],
[160,152,174,162,185,0,162,156],
[172,176,167,193,192,179,0,151],
[169,178,192,180,186,185,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1023, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,174,158,162,156,160,162],
[169,0,172,176,151,186,159,167],
[167,169,0,177,169,171,177,176],
[183,165,164,0,159,167,157,156],
[179,190,172,182,0,168,170,155],
[185,155,170,174,173,0,170,171],
[181,182,164,184,171,171,0,155],
[179,174,165,185,186,170,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1024, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,175,153,195,185,153,193],
[162,0,169,165,197,152,156,176],
[166,172,0,184,186,159,174,183],
[188,176,157,0,189,164,174,172],
[146,144,155,152,0,132,139,163],
[156,189,182,177,209,0,169,180],
[188,185,167,167,202,172,0,176],
[148,165,158,169,178,161,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1025, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,199,168,178,177,217,173,175],
[142,0,138,168,158,194,146,138],
[173,203,0,174,186,209,176,138],
[163,173,167,0,185,192,143,131],
[164,183,155,156,0,171,166,139],
[124,147,132,149,170,0,136,121],
[168,195,165,198,175,205,0,155],
[166,203,203,210,202,220,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1026, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,169,191,175,170,167,170],
[175,0,182,184,167,183,174,174],
[172,159,0,189,167,176,171,177],
[150,157,152,0,162,160,161,163],
[166,174,174,179,0,181,173,173],
[171,158,165,181,160,0,150,159],
[174,167,170,180,168,191,0,168],
[171,167,164,178,168,182,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1027, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,172,182,187,178,162,172],
[177,0,166,184,173,168,179,163],
[169,175,0,173,188,186,178,186],
[159,157,168,0,174,168,174,158],
[154,168,153,167,0,145,146,146],
[163,173,155,173,196,0,161,175],
[179,162,163,167,195,180,0,162],
[169,178,155,183,195,166,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1028, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,163,215,187,166,167,140],
[187,0,173,205,178,187,174,144],
[178,168,0,214,200,183,186,178],
[126,136,127,0,163,165,150,130],
[154,163,141,178,0,168,168,144],
[175,154,158,176,173,0,170,146],
[174,167,155,191,173,171,0,155],
[201,197,163,211,197,195,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1029, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,168,146,147,148,172,187],
[190,0,173,178,162,186,176,207],
[173,168,0,167,164,181,168,184],
[195,163,174,0,181,161,162,201],
[194,179,177,160,0,178,182,182],
[193,155,160,180,163,0,168,186],
[169,165,173,179,159,173,0,191],
[154,134,157,140,159,155,150,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1030, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,218,174,156,165,158,150],
[162,0,201,148,150,164,152,141],
[123,140,0,143,125,130,138,126],
[167,193,198,0,180,161,173,140],
[185,191,216,161,0,151,167,157],
[176,177,211,180,190,0,152,164],
[183,189,203,168,174,189,0,177],
[191,200,215,201,184,177,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1031, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,180,179,151,171,177,164],
[164,0,174,170,168,177,163,154],
[161,167,0,172,156,172,177,154],
[162,171,169,0,165,167,162,141],
[190,173,185,176,0,168,182,173],
[170,164,169,174,173,0,171,170],
[164,178,164,179,159,170,0,175],
[177,187,187,200,168,171,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1032, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,190,186,169,181,176,170],
[157,0,172,179,165,171,172,177],
[151,169,0,170,164,156,166,158],
[155,162,171,0,153,164,168,165],
[172,176,177,188,0,171,180,169],
[160,170,185,177,170,0,163,167],
[165,169,175,173,161,178,0,183],
[171,164,183,176,172,174,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1033, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,177,185,165,192,176,175],
[154,0,184,183,177,188,158,184],
[164,157,0,173,156,187,147,158],
[156,158,168,0,149,170,145,156],
[176,164,185,192,0,188,148,171],
[149,153,154,171,153,0,137,156],
[165,183,194,196,193,204,0,167],
[166,157,183,185,170,185,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1034, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,180,161,162,170,173,139],
[158,0,173,168,152,171,170,147],
[161,168,0,157,161,151,161,145],
[180,173,184,0,162,162,168,162],
[179,189,180,179,0,178,183,154],
[171,170,190,179,163,0,171,175],
[168,171,180,173,158,170,0,144],
[202,194,196,179,187,166,197,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1035, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,172,167,179,191,184,178],
[165,0,170,171,169,171,171,163],
[169,171,0,172,172,174,176,168],
[174,170,169,0,171,183,172,183],
[162,172,169,170,0,174,171,172],
[150,170,167,158,167,0,174,153],
[157,170,165,169,170,167,0,161],
[163,178,173,158,169,188,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1036, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,137,148,171,134,190,180,151],
[204,0,181,168,179,197,169,216],
[193,160,0,169,168,171,157,156],
[170,173,172,0,169,214,192,183],
[207,162,173,172,0,199,184,169],
[151,144,170,127,142,0,152,178],
[161,172,184,149,157,189,0,193],
[190,125,185,158,172,163,148,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1037, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,175,157,180,178,182,174],
[176,0,164,162,168,189,171,173],
[166,177,0,157,163,178,170,176],
[184,179,184,0,178,189,164,183],
[161,173,178,163,0,187,180,178],
[163,152,163,152,154,0,151,156],
[159,170,171,177,161,190,0,174],
[167,168,165,158,163,185,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1038, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,168,189,167,187,194,213],
[168,0,175,166,159,174,170,197],
[173,166,0,179,154,167,159,188],
[152,175,162,0,156,162,154,186],
[174,182,187,185,0,159,191,192],
[154,167,174,179,182,0,183,219],
[147,171,182,187,150,158,0,194],
[128,144,153,155,149,122,147,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1039, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,178,169,188,183,182,175],
[164,0,179,166,171,168,165,167],
[163,162,0,161,175,165,157,183],
[172,175,180,0,187,176,165,176],
[153,170,166,154,0,177,157,168],
[158,173,176,165,164,0,161,171],
[159,176,184,176,184,180,0,178],
[166,174,158,165,173,170,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1040, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,185,136,174,181,148,161],
[171,0,195,174,165,193,166,183],
[156,146,0,127,149,171,152,160],
[205,167,214,0,162,212,196,205],
[167,176,192,179,0,192,177,198],
[160,148,170,129,149,0,155,169],
[193,175,189,145,164,186,0,194],
[180,158,181,136,143,172,147,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1041, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,162,181,172,181,184,175],
[165,0,165,178,167,177,171,152],
[179,176,0,186,167,182,175,167],
[160,163,155,0,147,153,172,159],
[169,174,174,194,0,166,176,174],
[160,164,159,188,175,0,171,170],
[157,170,166,169,165,170,0,160],
[166,189,174,182,167,171,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1042, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,181,182,179,189,185,191],
[172,0,180,179,180,169,168,190],
[160,161,0,171,178,175,188,192],
[159,162,170,0,170,170,155,164],
[162,161,163,171,0,171,166,174],
[152,172,166,171,170,0,161,162],
[156,173,153,186,175,180,0,184],
[150,151,149,177,167,179,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1043, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,173,170,173,167,159,163],
[167,0,164,170,153,163,170,159],
[168,177,0,173,176,179,173,164],
[171,171,168,0,176,178,164,156],
[168,188,165,165,0,162,147,161],
[174,178,162,163,179,0,165,158],
[182,171,168,177,194,176,0,173],
[178,182,177,185,180,183,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1044, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,179,163,170,150,166,172],
[165,0,178,180,162,171,185,180],
[162,163,0,175,180,177,186,178],
[178,161,166,0,154,183,171,165],
[171,179,161,187,0,189,197,176],
[191,170,164,158,152,0,181,168],
[175,156,155,170,144,160,0,154],
[169,161,163,176,165,173,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1045, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,167,187,170,164,148,177],
[171,0,153,193,164,169,159,182],
[174,188,0,197,166,165,168,183],
[154,148,144,0,133,163,150,172],
[171,177,175,208,0,167,187,181],
[177,172,176,178,174,0,165,177],
[193,182,173,191,154,176,0,181],
[164,159,158,169,160,164,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1046, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,184,163,167,154,169,160],
[164,0,172,159,163,166,159,153],
[157,169,0,154,163,152,160,154],
[178,182,187,0,196,162,174,173],
[174,178,178,145,0,171,165,169],
[187,175,189,179,170,0,174,173],
[172,182,181,167,176,167,0,181],
[181,188,187,168,172,168,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1047, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,175,188,189,166,173,175],
[168,0,188,169,183,173,178,178],
[166,153,0,164,186,164,160,170],
[153,172,177,0,180,168,176,166],
[152,158,155,161,0,155,155,145],
[175,168,177,173,186,0,168,165],
[168,163,181,165,186,173,0,162],
[166,163,171,175,196,176,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1048, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,187,189,183,184,194,163],
[167,0,176,161,170,178,191,158],
[154,165,0,186,165,169,177,164],
[152,180,155,0,179,183,217,174],
[158,171,176,162,0,163,181,160],
[157,163,172,158,178,0,182,156],
[147,150,164,124,160,159,0,151],
[178,183,177,167,181,185,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1049, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,150,167,159,165,184,171],
[178,0,152,164,152,174,178,154],
[191,189,0,196,185,183,214,166],
[174,177,145,0,166,153,178,149],
[182,189,156,175,0,171,190,157],
[176,167,158,188,170,0,190,152],
[157,163,127,163,151,151,0,168],
[170,187,175,192,184,189,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1050, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,163,159,171,175,172,177],
[172,0,159,150,147,174,160,156],
[178,182,0,158,158,174,184,167],
[182,191,183,0,168,176,183,180],
[170,194,183,173,0,173,164,165],
[166,167,167,165,168,0,182,164],
[169,181,157,158,177,159,0,159],
[164,185,174,161,176,177,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1051, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,178,214,206,190,183,190],
[177,0,154,195,214,201,181,168],
[163,187,0,178,230,202,176,160],
[127,146,163,0,172,160,147,167],
[135,127,111,169,0,161,131,130],
[151,140,139,181,180,0,167,166],
[158,160,165,194,210,174,0,174],
[151,173,181,174,211,175,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1052, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,182,181,156,182,198,196],
[170,0,207,183,164,168,195,182],
[159,134,0,165,126,141,170,172],
[160,158,176,0,135,124,175,173],
[185,177,215,206,0,149,205,187],
[159,173,200,217,192,0,220,211],
[143,146,171,166,136,121,0,171],
[145,159,169,168,154,130,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1053, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,172,169,180,187,176,181],
[174,0,176,178,166,167,167,170],
[169,165,0,154,152,168,166,159],
[172,163,187,0,169,177,163,158],
[161,175,189,172,0,184,182,166],
[154,174,173,164,157,0,156,165],
[165,174,175,178,159,185,0,172],
[160,171,182,183,175,176,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1054, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,129,209,157,134,183,158,130],
[212,0,158,209,185,186,210,209],
[132,183,0,208,81,82,213,130],
[184,132,133,0,133,106,108,133],
[207,156,260,208,0,209,208,259],
[158,155,259,235,132,0,158,130],
[183,131,128,233,133,183,0,131],
[211,132,211,208,82,211,210,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1055, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,155,177,143,161,168,179],
[159,0,151,148,142,157,147,152],
[186,190,0,188,151,166,165,147],
[164,193,153,0,172,167,176,183],
[198,199,190,169,0,184,199,193],
[180,184,175,174,157,0,171,170],
[173,194,176,165,142,170,0,145],
[162,189,194,158,148,171,196,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1056, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,134,166,152,161,163,151,134],
[207,0,226,161,171,181,159,144],
[175,115,0,178,131,152,152,147],
[189,180,163,0,179,180,174,172],
[180,170,210,162,0,176,174,164],
[178,160,189,161,165,0,168,164],
[190,182,189,167,167,173,0,188],
[207,197,194,169,177,177,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1057, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,187,185,181,177,186,176],
[172,0,167,174,174,175,176,169],
[154,174,0,162,180,176,171,167],
[156,167,179,0,172,173,173,182],
[160,167,161,169,0,174,169,171],
[164,166,165,168,167,0,177,155],
[155,165,170,168,172,164,0,161],
[165,172,174,159,170,186,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1058, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,195,151,184,153,191,162,176],
[146,0,153,138,134,129,156,148],
[190,188,0,158,179,181,177,161],
[157,203,183,0,148,156,185,159],
[188,207,162,193,0,187,197,189],
[150,212,160,185,154,0,188,179],
[179,185,164,156,144,153,0,181],
[165,193,180,182,152,162,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1059, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,181,165,181,191,169,211],
[165,0,187,192,189,194,188,189],
[160,154,0,172,183,204,169,185],
[176,149,169,0,184,195,186,177],
[160,152,158,157,0,155,164,176],
[150,147,137,146,186,0,150,158],
[172,153,172,155,177,191,0,174],
[130,152,156,164,165,183,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1060, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,171,168,184,152,193,196],
[182,0,154,180,143,150,172,178],
[170,187,0,178,184,142,159,173],
[173,161,163,0,160,145,162,159],
[157,198,157,181,0,150,158,192],
[189,191,199,196,191,0,167,189],
[148,169,182,179,183,174,0,170],
[145,163,168,182,149,152,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1061, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,151,213,203,176,158,176],
[177,0,166,174,196,173,152,171],
[190,175,0,194,197,175,174,170],
[128,167,147,0,188,168,138,168],
[138,145,144,153,0,157,144,131],
[165,168,166,173,184,0,160,173],
[183,189,167,203,197,181,0,183],
[165,170,171,173,210,168,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1062, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,169,167,184,166,192,217],
[160,0,180,187,189,183,191,205],
[172,161,0,169,168,171,149,194],
[174,154,172,0,181,181,179,211],
[157,152,173,160,0,168,168,201],
[175,158,170,160,173,0,164,189],
[149,150,192,162,173,177,0,207],
[124,136,147,130,140,152,134,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1063, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,198,217,198,181,219,253],
[177,0,231,106,213,196,217,160],
[143,110,0,142,196,164,148,159],
[124,235,199,0,252,181,236,231],
[143,128,145,89,0,106,183,161],
[160,145,177,160,235,0,236,197],
[122,124,193,105,158,105,0,122],
[88,181,182,110,180,144,219,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1064, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,129,154,149,161,149,139],
[181,0,163,165,191,171,170,159],
[212,178,0,186,199,178,170,161],
[187,176,155,0,174,171,175,162],
[192,150,142,167,0,165,147,169],
[180,170,163,170,176,0,170,175],
[192,171,171,166,194,171,0,175],
[202,182,180,179,172,166,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1065, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,173,168,186,186,163,173],
[160,0,164,171,158,168,158,162],
[168,177,0,171,166,170,164,168],
[173,170,170,0,165,178,166,167],
[155,183,175,176,0,185,174,166],
[155,173,171,163,156,0,164,163],
[178,183,177,175,167,177,0,167],
[168,179,173,174,175,178,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1066, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,167,169,172,161,167,178],
[168,0,162,174,170,175,177,176],
[174,179,0,165,179,170,184,179],
[172,167,176,0,163,150,174,171],
[169,171,162,178,0,157,170,174],
[180,166,171,191,184,0,181,174],
[174,164,157,167,171,160,0,169],
[163,165,162,170,167,167,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1067, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,169,181,146,172,187,167],
[171,0,167,168,171,200,170,176],
[172,174,0,197,175,189,146,168],
[160,173,144,0,151,158,135,157],
[195,170,166,190,0,193,172,186],
[169,141,152,183,148,0,157,153],
[154,171,195,206,169,184,0,194],
[174,165,173,184,155,188,147,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1068, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,164,149,167,177,176,148],
[184,0,175,165,186,174,171,163],
[177,166,0,158,178,178,153,158],
[192,176,183,0,201,182,161,151],
[174,155,163,140,0,152,161,152],
[164,167,163,159,189,0,164,162],
[165,170,188,180,180,177,0,181],
[193,178,183,190,189,179,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1069, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,165,159,159,147,162,151],
[182,0,176,172,177,165,161,166],
[176,165,0,151,167,169,159,171],
[182,169,190,0,178,186,175,162],
[182,164,174,163,0,167,177,176],
[194,176,172,155,174,0,176,175],
[179,180,182,166,164,165,0,168],
[190,175,170,179,165,166,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1070, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,174,176,168,167,179,177],
[176,0,181,168,175,162,179,173],
[167,160,0,162,153,163,155,161],
[165,173,179,0,165,174,178,178],
[173,166,188,176,0,180,174,182],
[174,179,178,167,161,0,166,173],
[162,162,186,163,167,175,0,167],
[164,168,180,163,159,168,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1071, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,188,226,186,174,166,224],
[156,0,152,217,137,164,151,254],
[153,189,0,185,189,190,175,241],
[115,124,156,0,150,162,142,167],
[155,204,152,191,0,153,118,220],
[167,177,151,179,188,0,125,217],
[175,190,166,199,223,216,0,227],
[117,87,100,174,121,124,114,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1072, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,160,171,164,149,176,169],
[157,0,148,170,153,143,163,155],
[181,193,0,175,152,158,172,166],
[170,171,166,0,158,154,163,172],
[177,188,189,183,0,174,168,182],
[192,198,183,187,167,0,187,186],
[165,178,169,178,173,154,0,169],
[172,186,175,169,159,155,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1073, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,174,157,147,160,196,169],
[176,0,178,179,177,167,202,192],
[167,163,0,192,162,177,201,186],
[184,162,149,0,155,177,197,197],
[194,164,179,186,0,182,196,186],
[181,174,164,164,159,0,192,169],
[145,139,140,144,145,149,0,165],
[172,149,155,144,155,172,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1074, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,156,170,167,165,174,172],
[174,0,170,165,162,169,179,174],
[185,171,0,174,181,181,184,163],
[171,176,167,0,177,188,182,165],
[174,179,160,164,0,168,174,177],
[176,172,160,153,173,0,171,171],
[167,162,157,159,167,170,0,161],
[169,167,178,176,164,170,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1075, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,190,179,167,168,159,174,183],
[151,0,183,163,149,154,176,154],
[162,158,0,155,162,165,164,165],
[174,178,186,0,167,141,154,168],
[173,192,179,174,0,174,158,159],
[182,187,176,200,167,0,178,182],
[167,165,177,187,183,163,0,179],
[158,187,176,173,182,159,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1076, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,182,179,175,189,167,180],
[153,0,154,150,155,172,151,162],
[159,187,0,168,165,171,179,170],
[162,191,173,0,175,172,171,165],
[166,186,176,166,0,193,155,180],
[152,169,170,169,148,0,158,172],
[174,190,162,170,186,183,0,180],
[161,179,171,176,161,169,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1077, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,147,153,136,154,156,147],
[188,0,174,170,162,149,178,166],
[194,167,0,172,158,170,178,171],
[188,171,169,0,152,160,193,151],
[205,179,183,189,0,153,185,169],
[187,192,171,181,188,0,179,168],
[185,163,163,148,156,162,0,154],
[194,175,170,190,172,173,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1078, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,187,184,167,185,183,191],
[153,0,176,171,176,167,187,182],
[154,165,0,171,148,171,164,180],
[157,170,170,0,166,173,181,187],
[174,165,193,175,0,166,185,195],
[156,174,170,168,175,0,174,179],
[158,154,177,160,156,167,0,188],
[150,159,161,154,146,162,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1079, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,176,167,159,186,205,187],
[153,0,144,152,152,186,169,163],
[165,197,0,176,173,186,185,162],
[174,189,165,0,169,175,206,156],
[182,189,168,172,0,189,193,166],
[155,155,155,166,152,0,172,150],
[136,172,156,135,148,169,0,148],
[154,178,179,185,175,191,193,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1080, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,179,191,184,187,198,170],
[166,0,179,198,194,158,172,175],
[162,162,0,194,170,163,184,163],
[150,143,147,0,161,185,160,168],
[157,147,171,180,0,170,176,177],
[154,183,178,156,171,0,179,182],
[143,169,157,181,165,162,0,187],
[171,166,178,173,164,159,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1081, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,178,162,174,176,189,176],
[154,0,161,172,175,182,172,164],
[163,180,0,162,176,172,175,144],
[179,169,179,0,198,199,187,168],
[167,166,165,143,0,170,163,161],
[165,159,169,142,171,0,160,171],
[152,169,166,154,178,181,0,157],
[165,177,197,173,180,170,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1082, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,156,140,140,157,126,142],
[181,0,179,132,179,161,168,164],
[185,162,0,130,150,128,145,135],
[201,209,211,0,173,162,201,170],
[201,162,191,168,0,170,182,171],
[184,180,213,179,171,0,176,137],
[215,173,196,140,159,165,0,146],
[199,177,206,171,170,204,195,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1083, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,176,167,171,160,174,175],
[180,0,164,167,171,159,179,166],
[165,177,0,168,157,158,171,185],
[174,174,173,0,170,170,162,186],
[170,170,184,171,0,152,174,175],
[181,182,183,171,189,0,168,180],
[167,162,170,179,167,173,0,166],
[166,175,156,155,166,161,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1084, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,174,168,194,178,173,169],
[159,0,148,163,159,165,159,160],
[167,193,0,174,178,176,159,177],
[173,178,167,0,164,168,169,164],
[147,182,163,177,0,167,166,171],
[163,176,165,173,174,0,150,168],
[168,182,182,172,175,191,0,186],
[172,181,164,177,170,173,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1085, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,168,173,159,186,166,200],
[166,0,164,169,165,191,181,188],
[173,177,0,168,162,196,169,174],
[168,172,173,0,162,204,157,179],
[182,176,179,179,0,185,165,176],
[155,150,145,137,156,0,147,168],
[175,160,172,184,176,194,0,191],
[141,153,167,162,165,173,150,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1086, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,169,168,165,160,161,153],
[189,0,184,186,193,173,191,170],
[172,157,0,172,167,173,171,163],
[173,155,169,0,164,165,179,158],
[176,148,174,177,0,163,166,155],
[181,168,168,176,178,0,170,172],
[180,150,170,162,175,171,0,156],
[188,171,178,183,186,169,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1087, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,222,181,174,170,169,160,155],
[119,0,162,149,151,131,135,137],
[160,179,0,143,203,169,166,159],
[167,192,198,0,198,185,171,169],
[171,190,138,143,0,165,126,149],
[172,210,172,156,176,0,170,159],
[181,206,175,170,215,171,0,188],
[186,204,182,172,192,182,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1088, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,167,173,163,181,161,183],
[169,0,171,186,178,196,173,195],
[174,170,0,194,171,184,180,175],
[168,155,147,0,158,163,156,173],
[178,163,170,183,0,172,162,181],
[160,145,157,178,169,0,160,173],
[180,168,161,185,179,181,0,183],
[158,146,166,168,160,168,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1089, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,160,165,175,153,157,162],
[176,0,158,160,156,149,153,155],
[181,183,0,179,182,170,165,178],
[176,181,162,0,171,151,168,157],
[166,185,159,170,0,160,173,154],
[188,192,171,190,181,0,167,172],
[184,188,176,173,168,174,0,172],
[179,186,163,184,187,169,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1090, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,145,149,171,162,181,152,151],
[196,0,173,193,195,201,169,164],
[192,168,0,189,181,198,179,159],
[170,148,152,0,168,175,135,137],
[179,146,160,173,0,184,155,150],
[160,140,143,166,157,0,146,166],
[189,172,162,206,186,195,0,177],
[190,177,182,204,191,175,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1091, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,184,195,187,189,169,203],
[152,0,176,183,162,170,147,164],
[157,165,0,157,156,184,146,163],
[146,158,184,0,164,180,141,162],
[154,179,185,177,0,192,159,180],
[152,171,157,161,149,0,132,141],
[172,194,195,200,182,209,0,169],
[138,177,178,179,161,200,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1092, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,139,164,145,143,134,150,137],
[202,0,161,166,125,136,155,129],
[177,180,0,174,119,157,161,148],
[196,175,167,0,137,156,140,150],
[198,216,222,204,0,183,172,170],
[207,205,184,185,158,0,170,172],
[191,186,180,201,169,171,0,166],
[204,212,193,191,171,169,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1093, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,188,184,172,169,180,178],
[176,0,168,200,177,175,183,180],
[153,173,0,167,176,161,162,166],
[157,141,174,0,173,155,159,160],
[169,164,165,168,0,159,154,158],
[172,166,180,186,182,0,165,176],
[161,158,179,182,187,176,0,171],
[163,161,175,181,183,165,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1094, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,177,156,175,170,168,150],
[180,0,171,174,181,184,165,154],
[164,170,0,165,162,169,172,164],
[185,167,176,0,167,181,152,172],
[166,160,179,174,0,158,158,157],
[171,157,172,160,183,0,164,168],
[173,176,169,189,183,177,0,163],
[191,187,177,169,184,173,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1095, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,166,175,171,171,174,158],
[169,0,167,152,150,163,160,169],
[175,174,0,149,158,156,181,155],
[166,189,192,0,160,180,176,172],
[170,191,183,181,0,169,169,162],
[170,178,185,161,172,0,182,172],
[167,181,160,165,172,159,0,169],
[183,172,186,169,179,169,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1096, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,171,166,163,183,178,200],
[181,0,175,171,185,169,168,191],
[170,166,0,159,161,175,183,194],
[175,170,182,0,184,181,181,210],
[178,156,180,157,0,197,174,209],
[158,172,166,160,144,0,160,187],
[163,173,158,160,167,181,0,189],
[141,150,147,131,132,154,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1097, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,211,152,172,135,192,132,149],
[130,0,152,193,95,153,171,168],
[189,189,0,169,151,171,150,185],
[169,148,172,0,132,170,147,166],
[206,246,190,209,0,171,207,166],
[149,188,170,171,170,0,168,205],
[209,170,191,194,134,173,0,152],
[192,173,156,175,175,136,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1098, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,162,170,167,176,159,149],
[186,0,172,186,183,186,160,173],
[179,169,0,187,192,183,175,172],
[171,155,154,0,169,168,172,157],
[174,158,149,172,0,172,156,147],
[165,155,158,173,169,0,161,156],
[182,181,166,169,185,180,0,174],
[192,168,169,184,194,185,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1099, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,155,164,183,194,179,171],
[162,0,171,161,171,168,170,162],
[186,170,0,166,182,182,177,181],
[177,180,175,0,169,190,172,176],
[158,170,159,172,0,173,154,163],
[147,173,159,151,168,0,160,147],
[162,171,164,169,187,181,0,164],
[170,179,160,165,178,194,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1100, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,181,167,186,164,158,170],
[157,0,163,166,168,163,152,156],
[160,178,0,180,182,169,175,164],
[174,175,161,0,184,169,161,167],
[155,173,159,157,0,158,157,160],
[177,178,172,172,183,0,168,170],
[183,189,166,180,184,173,0,171],
[171,185,177,174,181,171,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1101, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,135,155,121,181,135,209,160],
[206,0,202,131,158,215,230,205],
[186,139,0,176,199,198,209,187],
[220,210,165,0,185,180,218,149],
[160,183,142,156,0,182,180,135],
[206,126,143,161,159,0,205,136],
[132,111,132,123,161,136,0,125],
[181,136,154,192,206,205,216,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1102, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,159,175,159,164,155,176],
[179,0,184,186,179,161,176,180],
[182,157,0,173,163,157,167,164],
[166,155,168,0,152,148,160,157],
[182,162,178,189,0,173,177,176],
[177,180,184,193,168,0,190,181],
[186,165,174,181,164,151,0,199],
[165,161,177,184,165,160,142,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1103, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,168,170,186,168,191,196],
[170,0,160,175,186,168,180,194],
[173,181,0,171,187,165,184,183],
[171,166,170,0,175,168,182,191],
[155,155,154,166,0,188,158,191],
[173,173,176,173,153,0,178,195],
[150,161,157,159,183,163,0,189],
[145,147,158,150,150,146,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1104, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,176,158,160,182,173,158],
[172,0,182,168,168,185,190,165],
[165,159,0,177,157,178,158,179],
[183,173,164,0,170,177,182,178],
[181,173,184,171,0,182,171,164],
[159,156,163,164,159,0,170,157],
[168,151,183,159,170,171,0,160],
[183,176,162,163,177,184,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1105, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,341,169,171,85,254,172,169],
[0,0,169,0,85,84,172,84],
[172,172,0,87,172,256,87,171],
[170,341,254,0,170,254,172,254],
[256,256,169,171,0,169,172,84],
[87,257,85,87,172,0,172,171],
[169,169,254,169,169,169,0,169],
[172,257,170,87,257,170,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1106, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,176,184,162,173,175,172],
[171,0,156,175,178,169,191,186],
[165,185,0,173,184,184,191,185],
[157,166,168,0,192,164,166,167],
[179,163,157,149,0,144,187,160],
[168,172,157,177,197,0,183,167],
[166,150,150,175,154,158,0,173],
[169,155,156,174,181,174,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1107, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,196,156,183,180,180,157,149],
[145,0,148,175,163,181,193,165],
[185,193,0,180,173,204,153,166],
[158,166,161,0,160,176,187,165],
[161,178,168,181,0,171,159,169],
[161,160,137,165,170,0,177,159],
[184,148,188,154,182,164,0,186],
[192,176,175,176,172,182,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1108, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,157,209,155,155,161,152],
[163,0,158,201,176,140,161,146],
[184,183,0,199,181,158,179,173],
[132,140,142,0,150,117,144,120],
[186,165,160,191,0,149,170,157],
[186,201,183,224,192,0,172,158],
[180,180,162,197,171,169,0,174],
[189,195,168,221,184,183,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1109, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,162,169,177,178,186,169],
[185,0,179,188,187,167,185,191],
[179,162,0,192,179,172,189,195],
[172,153,149,0,147,161,184,173],
[164,154,162,194,0,169,163,170],
[163,174,169,180,172,0,176,174],
[155,156,152,157,178,165,0,186],
[172,150,146,168,171,167,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1110, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,209,198,167,180,204,190,204],
[132,0,139,138,135,172,167,175],
[143,202,0,181,152,174,181,188],
[174,203,160,0,175,164,200,175],
[161,206,189,166,0,192,186,196],
[137,169,167,177,149,0,194,190],
[151,174,160,141,155,147,0,162],
[137,166,153,166,145,151,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1111, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,144,154,157,155,121,94,136],
[197,0,193,195,194,184,125,162],
[187,148,0,138,147,125,136,159],
[184,146,203,0,173,146,162,157],
[186,147,194,168,0,135,132,176],
[220,157,216,195,206,0,174,167],
[247,216,205,179,209,167,0,185],
[205,179,182,184,165,174,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1112, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,122,141,80,140,180,181,142],
[219,0,122,181,162,159,160,139],
[200,219,0,182,161,159,140,201],
[261,160,159,0,182,219,161,202],
[201,179,180,159,0,178,178,180],
[161,182,182,122,163,0,164,202],
[160,181,201,180,163,177,0,221],
[199,202,140,139,161,139,120,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1113, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,188,160,178,197,175,187],
[160,0,162,168,159,171,158,154],
[153,179,0,157,165,173,165,185],
[181,173,184,0,161,183,174,177],
[163,182,176,180,0,186,169,188],
[144,170,168,158,155,0,151,169],
[166,183,176,167,172,190,0,169],
[154,187,156,164,153,172,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1114, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,90,185,159,114,112,182,134],
[251,0,229,226,160,228,228,205],
[156,112,0,138,137,158,182,133],
[182,115,203,0,93,202,161,114],
[227,181,204,248,0,180,203,133],
[229,113,183,139,161,0,205,158],
[159,113,159,180,138,136,0,134],
[207,136,208,227,208,183,207,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1115, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,164,167,160,171,173,163],
[165,0,178,169,164,166,170,169],
[177,163,0,171,172,171,168,174],
[174,172,170,0,166,168,176,174],
[181,177,169,175,0,170,182,173],
[170,175,170,173,171,0,166,167],
[168,171,173,165,159,175,0,173],
[178,172,167,167,168,174,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1116, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,171,170,164,179,175,166],
[176,0,177,192,163,180,187,158],
[170,164,0,146,171,154,153,162],
[171,149,195,0,162,159,162,168],
[177,178,170,179,0,167,171,159],
[162,161,187,182,174,0,173,170],
[166,154,188,179,170,168,0,171],
[175,183,179,173,182,171,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1117, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,114,341,341,115,227,227,115],
[227,0,341,227,115,227,227,227],
[0,0,0,115,115,115,115,0],
[0,114,226,0,115,115,112,0],
[226,226,226,226,0,112,112,226],
[114,114,226,226,229,0,112,114],
[114,114,226,229,229,229,0,114],
[226,114,341,341,115,227,227,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1118, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,158,157,154,172,171,163],
[174,0,171,174,161,169,179,168],
[183,170,0,188,178,185,171,171],
[184,167,153,0,165,173,176,164],
[187,180,163,176,0,194,181,176],
[169,172,156,168,147,0,161,163],
[170,162,170,165,160,180,0,172],
[178,173,170,177,165,178,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1119, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,171,156,168,176,168,172],
[165,0,171,159,179,159,169,176],
[170,170,0,154,188,159,176,163],
[185,182,187,0,195,170,183,189],
[173,162,153,146,0,171,175,175],
[165,182,182,171,170,0,182,196],
[173,172,165,158,166,159,0,184],
[169,165,178,152,166,145,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1120, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,190,170,184,184,167,203,212],
[151,0,161,161,172,179,166,194],
[171,180,0,174,199,168,162,206],
[157,180,167,0,177,173,187,207],
[157,169,142,164,0,166,159,201],
[174,162,173,168,175,0,158,205],
[138,175,179,154,182,183,0,201],
[129,147,135,134,140,136,140,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1121, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,185,180,177,174,166,171],
[162,0,169,189,173,181,182,176],
[156,172,0,181,161,161,171,174],
[161,152,160,0,155,168,162,167],
[164,168,180,186,0,160,168,174],
[167,160,180,173,181,0,195,173],
[175,159,170,179,173,146,0,172],
[170,165,167,174,167,168,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1122, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,157,166,177,175,158,181],
[171,0,169,177,164,184,191,193],
[184,172,0,159,175,196,189,187],
[175,164,182,0,184,182,188,167],
[164,177,166,157,0,168,174,164],
[166,157,145,159,173,0,166,186],
[183,150,152,153,167,175,0,184],
[160,148,154,174,177,155,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1123, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,142,159,171,192,169,184,172],
[199,0,159,172,182,159,178,176],
[182,182,0,170,184,165,197,172],
[170,169,171,0,189,173,202,188],
[149,159,157,152,0,157,170,175],
[172,182,176,168,184,0,191,182],
[157,163,144,139,171,150,0,179],
[169,165,169,153,166,159,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1124, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,168,166,169,162,171,177],
[183,0,170,167,175,166,168,177],
[173,171,0,171,178,164,167,174],
[175,174,170,0,160,150,172,173],
[172,166,163,181,0,175,176,179],
[179,175,177,191,166,0,179,182],
[170,173,174,169,165,162,0,156],
[164,164,167,168,162,159,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1125, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,130,151,171,182,211,158,198],
[211,0,163,156,165,186,177,196],
[190,178,0,162,193,204,140,249],
[170,185,179,0,207,206,219,203],
[159,176,148,134,0,183,140,180],
[130,155,137,135,158,0,127,194],
[183,164,201,122,201,214,0,190],
[143,145,92,138,161,147,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1126, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,138,186,159,186,167,145,192],
[203,0,185,165,189,148,124,164],
[155,156,0,141,182,128,141,137],
[182,176,200,0,187,164,197,164],
[155,152,159,154,0,128,93,125],
[174,193,213,177,213,0,160,188],
[196,217,200,144,248,181,0,169],
[149,177,204,177,216,153,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1127, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,168,167,158,149,150,174],
[177,0,166,164,172,147,160,153],
[173,175,0,150,149,150,174,152],
[174,177,191,0,148,159,169,149],
[183,169,192,193,0,189,153,182],
[192,194,191,182,152,0,176,192],
[191,181,167,172,188,165,0,167],
[167,188,189,192,159,149,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1128, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,158,171,178,189,188,159],
[153,0,135,150,159,175,149,144],
[183,206,0,157,178,189,169,167],
[170,191,184,0,168,190,169,180],
[163,182,163,173,0,168,168,161],
[152,166,152,151,173,0,146,132],
[153,192,172,172,173,195,0,187],
[182,197,174,161,180,209,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1129, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,175,177,170,151,158,158],
[168,0,158,173,155,151,165,168],
[166,183,0,169,147,146,151,173],
[164,168,172,0,160,149,158,163],
[171,186,194,181,0,182,166,195],
[190,190,195,192,159,0,172,194],
[183,176,190,183,175,169,0,197],
[183,173,168,178,146,147,144,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1130, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,150,167,168,168,170,160,175],
[191,0,170,177,183,164,158,173],
[174,171,0,170,163,187,180,179],
[173,164,171,0,167,178,171,176],
[173,158,178,174,0,179,173,179],
[171,177,154,163,162,0,161,170],
[181,183,161,170,168,180,0,183],
[166,168,162,165,162,171,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1131, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,186,177,176,153,178,189],
[164,0,161,167,173,174,182,203],
[155,180,0,145,163,194,179,173],
[164,174,196,0,190,165,139,203],
[165,168,178,151,0,149,181,180],
[188,167,147,176,192,0,170,178],
[163,159,162,202,160,171,0,214],
[152,138,168,138,161,163,127,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1132, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,181,188,175,165,177,164],
[153,0,175,169,156,162,159,152],
[160,166,0,179,168,153,173,166],
[153,172,162,0,164,154,162,148],
[166,185,173,177,0,156,172,158],
[176,179,188,187,185,0,165,173],
[164,182,168,179,169,176,0,170],
[177,189,175,193,183,168,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1133, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,180,189,181,204,163,199],
[172,0,152,190,183,187,178,203],
[161,189,0,191,192,201,171,201],
[152,151,150,0,166,158,143,190],
[160,158,149,175,0,177,154,202],
[137,154,140,183,164,0,150,171],
[178,163,170,198,187,191,0,202],
[142,138,140,151,139,170,139,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1134, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,257,256,256,86,171,86],
[171,0,257,256,172,86,171,86],
[84,84,0,256,256,170,255,170],
[85,85,85,0,85,85,85,85],
[85,169,85,256,0,0,85,0],
[255,255,171,256,341,0,255,86],
[170,170,86,256,256,86,0,172],
[255,255,171,256,341,255,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1135, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,150,157,165,165,162,161],
[178,0,181,168,171,175,176,176],
[191,160,0,168,179,172,181,176],
[184,173,173,0,168,184,172,181],
[176,170,162,173,0,159,172,165],
[176,166,169,157,182,0,156,181],
[179,165,160,169,169,185,0,175],
[180,165,165,160,176,160,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1136, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,140,164,179,167,181,155],
[181,0,187,185,169,175,172,167],
[201,154,0,181,198,169,198,172],
[177,156,160,0,158,162,164,169],
[162,172,143,183,0,171,175,176],
[174,166,172,179,170,0,177,170],
[160,169,143,177,166,164,0,161],
[186,174,169,172,165,171,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1137, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,190,176,197,191,213,139,208],
[151,0,161,189,190,217,142,213],
[165,180,0,199,171,205,184,218],
[144,152,142,0,164,193,143,192],
[150,151,170,177,0,194,91,191],
[128,124,136,148,147,0,104,149],
[202,199,157,198,250,237,0,241],
[133,128,123,149,150,192,100,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1138, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,149,149,156,163,157,163,160],
[192,0,174,165,175,169,174,167],
[192,167,0,152,181,178,161,162],
[185,176,189,0,183,182,168,172],
[178,166,160,158,0,175,167,153],
[184,172,163,159,166,0,165,166],
[178,167,180,173,174,176,0,170],
[181,174,179,169,188,175,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1139, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,178,191,180,175,177,159],
[176,0,187,169,188,172,177,160],
[163,154,0,169,177,169,165,143],
[150,172,172,0,172,184,173,147],
[161,153,164,169,0,178,173,162],
[166,169,172,157,163,0,166,172],
[164,164,176,168,168,175,0,168],
[182,181,198,194,179,169,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1140, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,199,192,187,178,164,176],
[180,0,185,181,178,169,154,179],
[142,156,0,171,154,154,137,179],
[149,160,170,0,162,176,146,161],
[154,163,187,179,0,175,168,169],
[163,172,187,165,166,0,177,165],
[177,187,204,195,173,164,0,188],
[165,162,162,180,172,176,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1141, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,176,167,176,182,161,168],
[165,0,176,175,177,175,165,165],
[165,165,0,152,164,168,170,150],
[174,166,189,0,173,188,172,161],
[165,164,177,168,0,171,171,175],
[159,166,173,153,170,0,154,164],
[180,176,171,169,170,187,0,175],
[173,176,191,180,166,177,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1142, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,183,183,178,167,175,177],
[163,0,177,174,174,176,190,180],
[158,164,0,158,157,159,165,157],
[158,167,183,0,176,177,161,183],
[163,167,184,165,0,177,178,171],
[174,165,182,164,164,0,156,169],
[166,151,176,180,163,185,0,174],
[164,161,184,158,170,172,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1143, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,206,226,207,208,133,192,205],
[135,0,169,152,171,135,116,149],
[115,172,0,170,206,133,93,146],
[134,189,171,0,130,99,132,111],
[133,170,135,211,0,175,132,166],
[208,206,208,242,166,0,188,204],
[149,225,248,209,209,153,0,190],
[136,192,195,230,175,137,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1144, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,163,175,179,177,171,179],
[163,0,178,174,174,166,190,171],
[178,163,0,183,190,190,164,183],
[166,167,158,0,180,178,173,167],
[162,167,151,161,0,168,160,164],
[164,175,151,163,173,0,161,155],
[170,151,177,168,181,180,0,171],
[162,170,158,174,177,186,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1145, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,160,181,176,172,175,169],
[159,0,154,157,165,165,191,150],
[181,187,0,157,172,187,181,160],
[160,184,184,0,175,167,187,160],
[165,176,169,166,0,158,180,171],
[169,176,154,174,183,0,181,179],
[166,150,160,154,161,160,0,151],
[172,191,181,181,170,162,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1146, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,202,179,161,160,181,159,161],
[139,0,181,183,141,121,119,119],
[162,160,0,161,202,141,160,158],
[180,158,180,0,241,100,138,156],
[181,200,139,100,0,140,139,179],
[160,220,200,241,201,0,156,138],
[182,222,181,203,202,185,0,161],
[180,222,183,185,162,203,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1147, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,171,160,170,164,173,160],
[189,0,196,167,178,181,185,196],
[170,145,0,162,159,145,183,179],
[181,174,179,0,168,164,170,185],
[171,163,182,173,0,164,181,169],
[177,160,196,177,177,0,181,191],
[168,156,158,171,160,160,0,180],
[181,145,162,156,172,150,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1148, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,165,162,166,153,177,167],
[183,0,180,170,175,165,189,186],
[176,161,0,166,173,157,174,173],
[179,171,175,0,175,170,176,171],
[175,166,168,166,0,173,184,175],
[188,176,184,171,168,0,187,179],
[164,152,167,165,157,154,0,171],
[174,155,168,170,166,162,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1149, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,227,227,113,114,113,114,0],
[114,0,227,113,114,113,114,0],
[114,114,0,114,114,113,114,114],
[228,228,227,0,114,113,228,114],
[227,227,227,227,0,227,114,114],
[228,228,228,228,114,0,228,228],
[227,227,227,113,227,113,0,113],
[341,341,227,227,227,113,228,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1150, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,163,162,159,180,170,164],
[184,0,172,170,185,194,162,173],
[178,169,0,176,186,180,177,168],
[179,171,165,0,165,178,169,174],
[182,156,155,176,0,174,161,157],
[161,147,161,163,167,0,168,159],
[171,179,164,172,180,173,0,165],
[177,168,173,167,184,182,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1151, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,174,190,156,178,173,176],
[172,0,180,170,146,173,177,163],
[167,161,0,177,169,157,168,176],
[151,171,164,0,180,165,182,183],
[185,195,172,161,0,197,186,175],
[163,168,184,176,144,0,175,188],
[168,164,173,159,155,166,0,175],
[165,178,165,158,166,153,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1152, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,166,178,175,183,172,196],
[156,0,139,183,169,144,149,189],
[175,202,0,181,186,165,173,188],
[163,158,160,0,167,174,160,178],
[166,172,155,174,0,175,163,171],
[158,197,176,167,166,0,166,191],
[169,192,168,181,178,175,0,186],
[145,152,153,163,170,150,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1153, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,166,163,153,154,182,166],
[157,0,162,152,150,146,161,173],
[175,179,0,174,180,169,178,176],
[178,189,167,0,166,171,177,187],
[188,191,161,175,0,165,191,182],
[187,195,172,170,176,0,186,179],
[159,180,163,164,150,155,0,172],
[175,168,165,154,159,162,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1154, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,179,186,187,180,175,189],
[174,0,188,197,168,186,166,194],
[162,153,0,166,168,182,154,175],
[155,144,175,0,163,162,176,170],
[154,173,173,178,0,174,186,202],
[161,155,159,179,167,0,151,177],
[166,175,187,165,155,190,0,178],
[152,147,166,171,139,164,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1155, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,73,137,136,184,132,148,124],
[268,0,199,210,224,153,191,193],
[204,142,0,219,225,190,206,194],
[205,131,122,0,195,188,168,164],
[157,117,116,146,0,226,156,167],
[209,188,151,153,115,0,161,163],
[193,150,135,173,185,180,0,185],
[217,148,147,177,174,178,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1156, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,143,163,145,168,191,168],
[164,0,140,156,141,168,168,151],
[198,201,0,163,175,176,207,183],
[178,185,178,0,163,157,189,185],
[196,200,166,178,0,203,194,178],
[173,173,165,184,138,0,180,174],
[150,173,134,152,147,161,0,159],
[173,190,158,156,163,167,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1157, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,196,167,182,172,166,181],
[171,0,199,175,179,162,187,176],
[145,142,0,144,155,151,169,165],
[174,166,197,0,182,163,182,187],
[159,162,186,159,0,164,159,177],
[169,179,190,178,177,0,185,189],
[175,154,172,159,182,156,0,157],
[160,165,176,154,164,152,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1158, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,154,171,171,178,172,186],
[178,0,155,184,141,190,154,185],
[187,186,0,186,182,185,168,196],
[170,157,155,0,149,163,147,157],
[170,200,159,192,0,177,182,195],
[163,151,156,178,164,0,145,190],
[169,187,173,194,159,196,0,190],
[155,156,145,184,146,151,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1159, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,188,170,172,195,191,199],
[163,0,170,163,188,180,155,169],
[153,171,0,176,164,179,150,159],
[171,178,165,0,167,182,160,170],
[169,153,177,174,0,179,179,185],
[146,161,162,159,162,0,150,167],
[150,186,191,181,162,191,0,178],
[142,172,182,171,156,174,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1160, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,172,182,180,178,175,177],
[180,0,171,171,180,160,182,191],
[169,170,0,166,176,157,173,165],
[159,170,175,0,178,159,162,180],
[161,161,165,163,0,151,163,171],
[163,181,184,182,190,0,167,178],
[166,159,168,179,178,174,0,177],
[164,150,176,161,170,163,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1161, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,168,174,176,167,167,160],
[167,0,165,186,164,173,166,176],
[173,176,0,175,169,184,168,169],
[167,155,166,0,161,167,158,166],
[165,177,172,180,0,174,183,177],
[174,168,157,174,167,0,164,158],
[174,175,173,183,158,177,0,172],
[181,165,172,175,164,183,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1162, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,168,161,160,174,161,162],
[177,0,172,156,168,172,167,172],
[173,169,0,171,169,176,173,170],
[180,185,170,0,177,190,165,169],
[181,173,172,164,0,177,170,179],
[167,169,165,151,164,0,159,169],
[180,174,168,176,171,182,0,176],
[179,169,171,172,162,172,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1163, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,171,179,176,154,168,157],
[174,0,165,161,169,148,157,155],
[170,176,0,167,184,168,182,166],
[162,180,174,0,177,171,170,177],
[165,172,157,164,0,162,160,160],
[187,193,173,170,179,0,183,189],
[173,184,159,171,181,158,0,173],
[184,186,175,164,181,152,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1164, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,201,193,182,179,176,166,186],
[140,0,157,173,181,169,150,168],
[148,184,0,178,167,150,143,184],
[159,168,163,0,193,171,136,175],
[162,160,174,148,0,160,148,174],
[165,172,191,170,181,0,174,184],
[175,191,198,205,193,167,0,187],
[155,173,157,166,167,157,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1165, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,183,163,178,177,152,171],
[181,0,195,163,177,185,178,185],
[158,146,0,156,166,175,172,174],
[178,178,185,0,194,181,157,199],
[163,164,175,147,0,166,150,159],
[164,156,166,160,175,0,155,160],
[189,163,169,184,191,186,0,193],
[170,156,167,142,182,181,148,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1166, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,198,236,168,180,177,180],
[182,0,209,204,168,165,183,193],
[143,132,0,197,161,128,175,157],
[105,137,144,0,125,144,145,161],
[173,173,180,216,0,154,164,203],
[161,176,213,197,187,0,154,168],
[164,158,166,196,177,187,0,206],
[161,148,184,180,138,173,135,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1167, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,147,146,162,155,150,157,155],
[194,0,158,191,167,157,168,175],
[195,183,0,193,181,170,175,173],
[179,150,148,0,152,154,162,153],
[186,174,160,189,0,175,167,170],
[191,184,171,187,166,0,185,183],
[184,173,166,179,174,156,0,171],
[186,166,168,188,171,158,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1168, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,156,171,172,179,153,168],
[175,0,173,157,186,178,154,173],
[185,168,0,178,173,162,182,188],
[170,184,163,0,182,165,176,160],
[169,155,168,159,0,178,162,167],
[162,163,179,176,163,0,186,170],
[188,187,159,165,179,155,0,172],
[173,168,153,181,174,171,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1169, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,171,177,167,156,195,184],
[179,0,191,167,171,181,196,178],
[170,150,0,180,157,143,172,146],
[164,174,161,0,163,156,196,155],
[174,170,184,178,0,156,191,171],
[185,160,198,185,185,0,202,175],
[146,145,169,145,150,139,0,157],
[157,163,195,186,170,166,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1170, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,174,155,179,178,158,173],
[172,0,152,165,177,157,168,160],
[167,189,0,171,186,178,171,182],
[186,176,170,0,183,176,169,173],
[162,164,155,158,0,179,170,161],
[163,184,163,165,162,0,160,160],
[183,173,170,172,171,181,0,164],
[168,181,159,168,180,181,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1171, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,197,164,179,209,213,192,182],
[144,0,170,168,178,171,178,153],
[177,171,0,159,165,191,175,165],
[162,173,182,0,170,186,175,158],
[132,163,176,171,0,174,169,159],
[128,170,150,155,167,0,160,153],
[149,163,166,166,172,181,0,157],
[159,188,176,183,182,188,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1172, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,160,157,171,163,171,153],
[183,0,147,164,183,157,170,168],
[181,194,0,171,175,177,189,165],
[184,177,170,0,186,176,188,175],
[170,158,166,155,0,162,172,167],
[178,184,164,165,179,0,188,167],
[170,171,152,153,169,153,0,166],
[188,173,176,166,174,174,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1173, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,229,230,189,190,230,154,189],
[112,0,151,188,151,149,151,148],
[111,190,0,111,188,227,114,186],
[152,153,230,0,150,153,116,113],
[151,190,153,191,0,189,154,74],
[111,192,114,188,152,0,76,148],
[187,190,227,225,187,265,0,110],
[152,193,155,228,267,193,231,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1174, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,146,148,141,166,149,140,135],
[195,0,146,162,172,174,154,152],
[193,195,0,176,175,172,154,177],
[200,179,165,0,190,198,189,161],
[175,169,166,151,0,170,158,140],
[192,167,169,143,171,0,153,145],
[201,187,187,152,183,188,0,153],
[206,189,164,180,201,196,188,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1175, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,187,167,169,187,167,136],
[182,0,169,182,168,210,193,170],
[154,172,0,155,152,199,176,178],
[174,159,186,0,150,207,165,158],
[172,173,189,191,0,200,183,167],
[154,131,142,134,141,0,170,139],
[174,148,165,176,158,171,0,149],
[205,171,163,183,174,202,192,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1176, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,168,201,195,186,187,169],
[155,0,163,194,182,162,169,172],
[173,178,0,184,172,177,187,163],
[140,147,157,0,173,177,160,145],
[146,159,169,168,0,164,184,146],
[155,179,164,164,177,0,164,166],
[154,172,154,181,157,177,0,155],
[172,169,178,196,195,175,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1177, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,174,184,158,184,183,169],
[157,0,162,177,158,176,161,178],
[167,179,0,187,171,169,171,176],
[157,164,154,0,153,164,164,170],
[183,183,170,188,0,183,188,181],
[157,165,172,177,158,0,174,174],
[158,180,170,177,153,167,0,159],
[172,163,165,171,160,167,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1178, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,193,189,172,179,176,177],
[178,0,190,184,170,162,188,199],
[148,151,0,165,167,156,165,155],
[152,157,176,0,158,165,171,171],
[169,171,174,183,0,166,162,167],
[162,179,185,176,175,0,165,169],
[165,153,176,170,179,176,0,167],
[164,142,186,170,174,172,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1179, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,130,162,175,141,184,147],
[166,0,164,173,192,163,199,152],
[211,177,0,189,188,169,202,175],
[179,168,152,0,198,162,174,137],
[166,149,153,143,0,171,175,138],
[200,178,172,179,170,0,194,187],
[157,142,139,167,166,147,0,130],
[194,189,166,204,203,154,211,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1180, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,144,145,163,163,180,154,168],
[197,0,169,175,175,196,179,179],
[196,172,0,166,168,188,173,172],
[178,166,175,0,167,171,178,173],
[178,166,173,174,0,177,169,176],
[161,145,153,170,164,0,153,169],
[187,162,168,163,172,188,0,181],
[173,162,169,168,165,172,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1181, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,143,154,164,158,159,153,130],
[198,0,183,164,172,158,185,168],
[187,158,0,171,163,170,175,158],
[177,177,170,0,163,165,185,172],
[183,169,178,178,0,152,179,162],
[182,183,171,176,189,0,181,166],
[188,156,166,156,162,160,0,148],
[211,173,183,169,179,175,193,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1182, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,200,158,164,161,176,192,180],
[141,0,159,120,148,159,200,140],
[183,182,0,175,210,150,191,194],
[177,221,166,0,191,163,173,177],
[180,193,131,150,0,175,160,194],
[165,182,191,178,166,0,181,195],
[149,141,150,168,181,160,0,159],
[161,201,147,164,147,146,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1183, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,167,188,188,177,172,170],
[171,0,167,173,176,165,169,166],
[174,174,0,186,190,162,187,174],
[153,168,155,0,170,161,160,165],
[153,165,151,171,0,159,162,161],
[164,176,179,180,182,0,179,174],
[169,172,154,181,179,162,0,167],
[171,175,167,176,180,167,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1184, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,166,171,165,169,163,147],
[176,0,179,162,170,168,179,177],
[175,162,0,170,158,167,159,154],
[170,179,171,0,170,172,168,159],
[176,171,183,171,0,178,188,152],
[172,173,174,169,163,0,184,148],
[178,162,182,173,153,157,0,165],
[194,164,187,182,189,193,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1185, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,183,186,187,193,174,170],
[164,0,171,173,176,179,162,166],
[158,170,0,179,165,175,159,167],
[155,168,162,0,168,167,156,172],
[154,165,176,173,0,181,160,169],
[148,162,166,174,160,0,158,159],
[167,179,182,185,181,183,0,166],
[171,175,174,169,172,182,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1186, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,175,174,171,169,174,175],
[169,0,173,179,162,174,163,172],
[166,168,0,175,163,169,166,170],
[167,162,166,0,154,165,177,160],
[170,179,178,187,0,168,180,169],
[172,167,172,176,173,0,163,169],
[167,178,175,164,161,178,0,171],
[166,169,171,181,172,172,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1187, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,148,156,160,163,166,164],
[180,0,174,172,162,172,169,182],
[193,167,0,170,183,180,178,185],
[185,169,171,0,176,176,176,181],
[181,179,158,165,0,175,177,175],
[178,169,161,165,166,0,171,177],
[175,172,163,165,164,170,0,176],
[177,159,156,160,166,164,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1188, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,200,193,161,184,197,190],
[165,0,181,184,185,181,184,191],
[141,160,0,172,141,160,160,168],
[148,157,169,0,155,170,183,170],
[180,156,200,186,0,179,190,191],
[157,160,181,171,162,0,169,186],
[144,157,181,158,151,172,0,181],
[151,150,173,171,150,155,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1189, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,178,159,160,162,224,182],
[176,0,165,198,168,201,198,185],
[163,176,0,137,164,197,205,181],
[182,143,204,0,173,208,212,195],
[181,173,177,168,0,204,190,169],
[179,140,144,133,137,0,164,166],
[117,143,136,129,151,177,0,152],
[159,156,160,146,172,175,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1190, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,174,175,165,177,173,168],
[165,0,164,171,148,161,166,164],
[167,177,0,187,170,177,176,172],
[166,170,154,0,174,167,172,171],
[176,193,171,167,0,161,174,189],
[164,180,164,174,180,0,160,178],
[168,175,165,169,167,181,0,189],
[173,177,169,170,152,163,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1191, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,157,167,187,184,184,191],
[165,0,157,167,182,171,193,179],
[184,184,0,191,199,177,186,168],
[174,174,150,0,182,184,192,171],
[154,159,142,159,0,166,179,148],
[157,170,164,157,175,0,183,180],
[157,148,155,149,162,158,0,156],
[150,162,173,170,193,161,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1192, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,162,129,169,173,131,120],
[171,0,145,125,154,149,125,120],
[179,196,0,182,217,185,171,155],
[212,216,159,0,206,207,174,185],
[172,187,124,135,0,171,138,131],
[168,192,156,134,170,0,149,139],
[210,216,170,167,203,192,0,169],
[221,221,186,156,210,202,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1193, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,150,171,160,188,176,184,178],
[191,0,194,170,176,173,192,179],
[170,147,0,168,151,160,160,172],
[181,171,173,0,163,164,168,171],
[153,165,190,178,0,180,182,193],
[165,168,181,177,161,0,176,165],
[157,149,181,173,159,165,0,156],
[163,162,169,170,148,176,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1194, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,158,122,158,172,154,134],
[153,0,155,133,149,142,154,156],
[183,186,0,163,168,161,163,172],
[219,208,178,0,170,186,173,196],
[183,192,173,171,0,182,168,159],
[169,199,180,155,159,0,177,166],
[187,187,178,168,173,164,0,151],
[207,185,169,145,182,175,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1195, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,181,173,186,182,186,170],
[157,0,164,163,163,176,154,152],
[160,177,0,173,168,172,173,159],
[168,178,168,0,165,177,171,158],
[155,178,173,176,0,171,174,163],
[159,165,169,164,170,0,161,146],
[155,187,168,170,167,180,0,175],
[171,189,182,183,178,195,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1196, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,181,169,161,173,176,175],
[174,0,158,164,158,172,174,182],
[160,183,0,169,167,186,191,158],
[172,177,172,0,155,193,174,170],
[180,183,174,186,0,190,177,164],
[168,169,155,148,151,0,162,162],
[165,167,150,167,164,179,0,159],
[166,159,183,171,177,179,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1197, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,175,155,183,149,171,183],
[165,0,151,176,158,153,164,195],
[166,190,0,178,173,172,178,180],
[186,165,163,0,181,187,191,192],
[158,183,168,160,0,184,166,197],
[192,188,169,154,157,0,146,194],
[170,177,163,150,175,195,0,198],
[158,146,161,149,144,147,143,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1198, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,166,191,182,179,173,164],
[180,0,167,186,182,180,171,176],
[175,174,0,182,174,182,179,165],
[150,155,159,0,161,160,154,150],
[159,159,167,180,0,176,168,160],
[162,161,159,181,165,0,170,166],
[168,170,162,187,173,171,0,169],
[177,165,176,191,181,175,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1199, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,133,91,189,119,172,128,173],
[208,0,201,191,200,219,138,221],
[250,140,0,211,171,176,189,212],
[152,150,130,0,131,168,168,190],
[222,141,170,210,0,204,149,203],
[169,122,165,173,137,0,133,201],
[213,203,152,173,192,208,0,192],
[168,120,129,151,138,140,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1200, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,195,174,180,180,191,174],
[172,0,185,161,162,167,160,174],
[146,156,0,145,162,174,175,152],
[167,180,196,0,170,184,157,170],
[161,179,179,171,0,193,180,201],
[161,174,167,157,148,0,157,181],
[150,181,166,184,161,184,0,158],
[167,167,189,171,140,160,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1201, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,164,163,156,173,161,168],
[171,0,152,161,155,187,161,185],
[177,189,0,161,166,187,180,176],
[178,180,180,0,186,186,163,170],
[185,186,175,155,0,175,167,187],
[168,154,154,155,166,0,148,164],
[180,180,161,178,174,193,0,184],
[173,156,165,171,154,177,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1202, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,165,154,160,163,171,167],
[167,0,149,154,154,149,147,176],
[176,192,0,169,181,171,192,193],
[187,187,172,0,162,184,179,182],
[181,187,160,179,0,158,175,169],
[178,192,170,157,183,0,174,163],
[170,194,149,162,166,167,0,158],
[174,165,148,159,172,178,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1203, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,171,188,182,173,181,149],
[163,0,165,173,168,153,185,145],
[170,176,0,155,172,149,171,174],
[153,168,186,0,161,152,166,163],
[159,173,169,180,0,166,168,157],
[168,188,192,189,175,0,176,171],
[160,156,170,175,173,165,0,162],
[192,196,167,178,184,170,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1204, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,142,164,163,166,202,139,125],
[199,0,204,162,181,180,141,184],
[177,137,0,138,178,97,116,141],
[178,179,203,0,160,241,118,164],
[175,160,163,181,0,199,159,122],
[139,161,244,100,142,0,98,102],
[202,200,225,223,182,243,0,163],
[216,157,200,177,219,239,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1205, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,153,165,161,148,152,149],
[179,0,180,173,165,171,158,182],
[188,161,0,196,175,146,182,165],
[176,168,145,0,161,163,154,153],
[180,176,166,180,0,185,179,166],
[193,170,195,178,156,0,165,188],
[189,183,159,187,162,176,0,161],
[192,159,176,188,175,153,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1206, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,180,177,204,173,174,190],
[177,0,179,170,180,187,175,205],
[161,162,0,158,173,187,159,182],
[164,171,183,0,200,182,179,187],
[137,161,168,141,0,169,166,166],
[168,154,154,159,172,0,144,163],
[167,166,182,162,175,197,0,184],
[151,136,159,154,175,178,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1207, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,141,161,150,187,170,161],
[189,0,168,172,172,170,162,174],
[200,173,0,180,173,187,168,179],
[180,169,161,0,193,204,168,175],
[191,169,168,148,0,184,171,192],
[154,171,154,137,157,0,149,155],
[171,179,173,173,170,192,0,163],
[180,167,162,166,149,186,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1208, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,148,172,193,164,181,166],
[150,0,155,165,149,163,157,150],
[193,186,0,195,179,175,179,160],
[169,176,146,0,167,159,183,176],
[148,192,162,174,0,154,172,173],
[177,178,166,182,187,0,179,160],
[160,184,162,158,169,162,0,127],
[175,191,181,165,168,181,214,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1209, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,180,173,160,171,174,176],
[169,0,166,177,164,175,165,171],
[161,175,0,169,161,180,170,186],
[168,164,172,0,156,164,162,176],
[181,177,180,185,0,179,162,178],
[170,166,161,177,162,0,158,166],
[167,176,171,179,179,183,0,170],
[165,170,155,165,163,175,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1210, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,173,176,165,174,172,168],
[161,0,155,168,165,168,170,161],
[168,186,0,175,154,180,161,154],
[165,173,166,0,163,170,174,165],
[176,176,187,178,0,166,165,167],
[167,173,161,171,175,0,161,161],
[169,171,180,167,176,180,0,171],
[173,180,187,176,174,180,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1211, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,165,167,170,173,146,181],
[182,0,162,156,178,158,142,185],
[176,179,0,185,148,191,169,184],
[174,185,156,0,199,189,174,186],
[171,163,193,142,0,194,168,160],
[168,183,150,152,147,0,147,139],
[195,199,172,167,173,194,0,175],
[160,156,157,155,181,202,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1212, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,169,180,172,191,172,183],
[166,0,179,163,176,179,168,146],
[172,162,0,168,179,183,161,159],
[161,178,173,0,190,199,183,163],
[169,165,162,151,0,173,169,157],
[150,162,158,142,168,0,160,169],
[169,173,180,158,172,181,0,155],
[158,195,182,178,184,172,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1213, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,140,145,131,134,168,154,168],
[201,0,205,167,174,201,189,180],
[196,136,0,150,143,203,184,158],
[210,174,191,0,144,176,189,185],
[207,167,198,197,0,200,207,179],
[173,140,138,165,141,0,167,130],
[187,152,157,152,134,174,0,162],
[173,161,183,156,162,211,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1214, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,189,178,180,170,169,184],
[166,0,174,178,183,172,179,175],
[152,167,0,169,180,159,160,164],
[163,163,172,0,176,167,164,164],
[161,158,161,165,0,166,162,153],
[171,169,182,174,175,0,169,161],
[172,162,181,177,179,172,0,170],
[157,166,177,177,188,180,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1215, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,168,143,226,158,243,155],
[156,0,171,141,181,160,185,126],
[173,170,0,186,170,144,200,171],
[198,200,155,0,242,187,214,171],
[115,160,171,99,0,118,188,142],
[183,181,197,154,223,0,198,168],
[98,156,141,127,153,143,0,114],
[186,215,170,170,199,173,227,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1216, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,169,169,165,155,164,161],
[168,0,162,185,171,174,173,167],
[172,179,0,160,163,156,173,152],
[172,156,181,0,162,170,179,149],
[176,170,178,179,0,170,187,176],
[186,167,185,171,171,0,188,162],
[177,168,168,162,154,153,0,157],
[180,174,189,192,165,179,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1217, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,168,176,160,173,164,188],
[176,0,181,164,180,160,176,183],
[173,160,0,180,181,167,170,192],
[165,177,161,0,172,160,170,189],
[181,161,160,169,0,152,172,178],
[168,181,174,181,189,0,163,185],
[177,165,171,171,169,178,0,175],
[153,158,149,152,163,156,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1218, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,196,186,171,166,165,190,201],
[145,0,156,144,143,163,158,176],
[155,185,0,193,173,183,181,191],
[170,197,148,0,168,169,189,198],
[175,198,168,173,0,179,176,209],
[176,178,158,172,162,0,188,181],
[151,183,160,152,165,153,0,188],
[140,165,150,143,132,160,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1219, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,193,205,180,185,165,175,184],
[148,0,172,170,150,149,184,159],
[136,169,0,146,167,162,170,104],
[161,171,195,0,150,144,151,173],
[156,191,174,191,0,203,172,183],
[176,192,179,197,138,0,161,145],
[166,157,171,190,169,180,0,127],
[157,182,237,168,158,196,214,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1220, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,162,173,164,171,172,171],
[165,0,171,179,168,164,177,173],
[179,170,0,154,161,171,165,190],
[168,162,187,0,165,153,149,171],
[177,173,180,176,0,164,165,185],
[170,177,170,188,177,0,180,173],
[169,164,176,192,176,161,0,173],
[170,168,151,170,156,168,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1221, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,179,169,170,193,196,178],
[166,0,184,174,158,176,170,170],
[162,157,0,168,176,176,169,175],
[172,167,173,0,170,166,171,161],
[171,183,165,171,0,166,181,177],
[148,165,165,175,175,0,168,172],
[145,171,172,170,160,173,0,163],
[163,171,166,180,164,169,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1222, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,167,177,174,179,175,192],
[157,0,166,167,164,159,168,171],
[174,175,0,179,158,162,181,169],
[164,174,162,0,147,163,173,158],
[167,177,183,194,0,187,185,188],
[162,182,179,178,154,0,178,163],
[166,173,160,168,156,163,0,156],
[149,170,172,183,153,178,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1223, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,142,156,166,142,165,137,161],
[199,0,126,154,131,169,145,154],
[185,215,0,139,146,167,182,146],
[175,187,202,0,186,163,176,149],
[199,210,195,155,0,187,169,203],
[176,172,174,178,154,0,181,172],
[204,196,159,165,172,160,0,149],
[180,187,195,192,138,169,192,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1224, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,158,157,165,144,177,156],
[185,0,179,170,189,172,186,179],
[183,162,0,161,181,162,159,158],
[184,171,180,0,195,162,177,181],
[176,152,160,146,0,144,162,146],
[197,169,179,179,197,0,188,180],
[164,155,182,164,179,153,0,158],
[185,162,183,160,195,161,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1225, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,147,156,154,177,153,183,190],
[194,0,175,170,194,179,194,180],
[185,166,0,173,172,155,183,168],
[187,171,168,0,183,175,171,175],
[164,147,169,158,0,157,176,175],
[188,162,186,166,184,0,174,179],
[158,147,158,170,165,167,0,143],
[151,161,173,166,166,162,198,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1226, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,177,178,168,169,171,175],
[171,0,171,158,157,167,174,168],
[164,170,0,162,161,160,170,169],
[163,183,179,0,175,176,173,186],
[173,184,180,166,0,180,180,180],
[172,174,181,165,161,0,177,172],
[170,167,171,168,161,164,0,176],
[166,173,172,155,161,169,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1227, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,149,141,156,154,150,162,142],
[192,0,162,182,175,171,177,157],
[200,179,0,195,187,165,175,171],
[185,159,146,0,171,165,188,167],
[187,166,154,170,0,164,173,161],
[191,170,176,176,177,0,188,176],
[179,164,166,153,168,153,0,154],
[199,184,170,174,180,165,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1228, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,169,184,165,169,170,175],
[172,0,175,177,176,170,182,182],
[172,166,0,182,164,193,156,182],
[157,164,159,0,156,152,147,173],
[176,165,177,185,0,185,157,177],
[172,171,148,189,156,0,141,183],
[171,159,185,194,184,200,0,196],
[166,159,159,168,164,158,145,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1229, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,172,165,184,179,159,162],
[170,0,175,166,174,161,171,169],
[169,166,0,167,160,174,183,177],
[176,175,174,0,170,164,170,164],
[157,167,181,171,0,173,169,176],
[162,180,167,177,168,0,163,176],
[182,170,158,171,172,178,0,170],
[179,172,164,177,165,165,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1230, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,174,172,164,179,161,169],
[170,0,168,178,174,168,176,169],
[167,173,0,180,176,167,175,172],
[169,163,161,0,173,154,162,162],
[177,167,165,168,0,165,167,160],
[162,173,174,187,176,0,167,187],
[180,165,166,179,174,174,0,173],
[172,172,169,179,181,154,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1231, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,152,180,163,177,172,159],
[179,0,166,179,180,179,183,177],
[189,175,0,163,168,190,199,187],
[161,162,178,0,161,173,179,180],
[178,161,173,180,0,180,205,170],
[164,162,151,168,161,0,177,156],
[169,158,142,162,136,164,0,160],
[182,164,154,161,171,185,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1232, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,183,178,176,176,173,179],
[179,0,174,182,156,170,162,162],
[158,167,0,169,158,163,158,172],
[163,159,172,0,164,158,156,173],
[165,185,183,177,0,170,165,184],
[165,171,178,183,171,0,162,169],
[168,179,183,185,176,179,0,176],
[162,179,169,168,157,172,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1233, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,145,154,158,210,161,159,178],
[196,0,213,195,172,179,197,143],
[187,128,0,147,211,149,161,93],
[183,146,194,0,212,131,162,162],
[131,169,130,129,0,79,110,95],
[180,162,192,210,262,0,177,138],
[182,144,180,179,231,164,0,110],
[163,198,248,179,246,203,231,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1234, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,173,187,166,209,170,201],
[172,0,175,174,178,189,155,196],
[168,166,0,165,164,175,160,177],
[154,167,176,0,161,176,151,185],
[175,163,177,180,0,221,194,200],
[132,152,166,165,120,0,157,170],
[171,186,181,190,147,184,0,194],
[140,145,164,156,141,171,147,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1235, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,128,128,155,127,128,205,125],
[213,0,178,229,192,186,216,160],
[213,163,0,176,168,120,217,185],
[186,112,165,0,153,132,190,132],
[214,149,173,188,0,146,186,145],
[213,155,221,209,195,0,230,178],
[136,125,124,151,155,111,0,136],
[216,181,156,209,196,163,205,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1236, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,143,164,159,150,166,186,163],
[198,0,180,176,168,196,187,197],
[177,161,0,167,164,177,171,177],
[182,165,174,0,176,181,181,186],
[191,173,177,165,0,187,193,183],
[175,145,164,160,154,0,181,175],
[155,154,170,160,148,160,0,168],
[178,144,164,155,158,166,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1237, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,151,161,165,170,162,204],
[156,0,130,181,164,148,155,190],
[190,211,0,188,198,161,175,209],
[180,160,153,0,185,135,158,172],
[176,177,143,156,0,123,150,178],
[171,193,180,206,218,0,163,193],
[179,186,166,183,191,178,0,170],
[137,151,132,169,163,148,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1238, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,169,164,176,179,172,176],
[182,0,174,185,191,189,169,191],
[172,167,0,171,180,184,157,187],
[177,156,170,0,186,181,171,177],
[165,150,161,155,0,163,152,181],
[162,152,157,160,178,0,168,163],
[169,172,184,170,189,173,0,175],
[165,150,154,164,160,178,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1239, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,160,140,144,159,175,175],
[159,0,157,150,136,148,171,167],
[181,184,0,163,161,176,186,207],
[201,191,178,0,156,170,170,181],
[197,205,180,185,0,169,196,188],
[182,193,165,171,172,0,188,193],
[166,170,155,171,145,153,0,184],
[166,174,134,160,153,148,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1240, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,136,178,155,137,168,179,180],
[205,0,188,180,190,166,188,196],
[163,153,0,138,139,156,161,171],
[186,161,203,0,152,164,157,193],
[204,151,202,189,0,184,189,208],
[173,175,185,177,157,0,171,159],
[162,153,180,184,152,170,0,160],
[161,145,170,148,133,182,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1241, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,175,160,164,149,163,172],
[176,0,184,169,191,172,178,181],
[166,157,0,170,159,161,155,165],
[181,172,171,0,180,155,172,173],
[177,150,182,161,0,177,170,191],
[192,169,180,186,164,0,186,180],
[178,163,186,169,171,155,0,172],
[169,160,176,168,150,161,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1242, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,160,150,146,136,154,158],
[176,0,176,186,150,151,167,158],
[181,165,0,199,169,180,151,173],
[191,155,142,0,138,163,147,141],
[195,191,172,203,0,169,173,176],
[205,190,161,178,172,0,166,163],
[187,174,190,194,168,175,0,168],
[183,183,168,200,165,178,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1243, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,176,173,173,179,170,169],
[171,0,157,163,163,164,174,160],
[165,184,0,175,172,179,174,175],
[168,178,166,0,172,181,164,177],
[168,178,169,169,0,177,183,166],
[162,177,162,160,164,0,163,157],
[171,167,167,177,158,178,0,169],
[172,181,166,164,175,184,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1244, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,260,156,237,207,155,206,210],
[81,0,158,132,158,132,157,185],
[185,183,0,237,211,208,157,236],
[104,209,104,0,131,102,131,131],
[134,183,130,210,0,182,131,185],
[186,209,133,239,159,0,184,239],
[135,184,184,210,210,157,0,214],
[131,156,105,210,156,102,127,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1245, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,172,151,171,169,176,157],
[157,0,162,172,161,162,151,161],
[169,179,0,170,174,146,164,159],
[190,169,171,0,168,181,153,163],
[170,180,167,173,0,148,156,157],
[172,179,195,160,193,0,173,156],
[165,190,177,188,185,168,0,181],
[184,180,182,178,184,185,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1246, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,208,163,189,183,202,207],
[161,0,199,205,175,195,190,180],
[133,142,0,178,164,169,143,150],
[178,136,163,0,169,167,169,169],
[152,166,177,172,0,179,155,180],
[158,146,172,174,162,0,169,146],
[139,151,198,172,186,172,0,171],
[134,161,191,172,161,195,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1247, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,168,161,157,164,181,149],
[181,0,177,175,169,174,186,161],
[173,164,0,169,169,173,175,155],
[180,166,172,0,173,171,171,175],
[184,172,172,168,0,182,174,157],
[177,167,168,170,159,0,181,149],
[160,155,166,170,167,160,0,149],
[192,180,186,166,184,192,192,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1248, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,159,142,171,175,165,182],
[154,0,166,192,166,166,161,196],
[182,175,0,188,164,184,184,187],
[199,149,153,0,154,146,176,182],
[170,175,177,187,0,186,176,167],
[166,175,157,195,155,0,155,167],
[176,180,157,165,165,186,0,162],
[159,145,154,159,174,174,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1249, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,156,166,158,177,161,161],
[162,0,162,176,157,182,158,146],
[185,179,0,179,151,187,177,175],
[175,165,162,0,164,192,151,172],
[183,184,190,177,0,194,164,172],
[164,159,154,149,147,0,162,167],
[180,183,164,190,177,179,0,200],
[180,195,166,169,169,174,141,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1250, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,183,186,168,177,169,181],
[157,0,159,163,168,171,164,156],
[158,182,0,177,180,169,176,184],
[155,178,164,0,168,157,164,169],
[173,173,161,173,0,170,172,170],
[164,170,172,184,171,0,174,170],
[172,177,165,177,169,167,0,167],
[160,185,157,172,171,171,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1251, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,164,168,177,169,162,159],
[171,0,180,158,157,163,177,156],
[177,161,0,179,164,171,167,152],
[173,183,162,0,181,186,192,174],
[164,184,177,160,0,189,171,164],
[172,178,170,155,152,0,185,156],
[179,164,174,149,170,156,0,166],
[182,185,189,167,177,185,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1252, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,151,167,124,162,210,186],
[190,0,183,174,193,128,172,202],
[190,158,0,200,165,173,178,197],
[174,167,141,0,174,152,143,173],
[217,148,176,167,0,149,203,193],
[179,213,168,189,192,0,180,198],
[131,169,163,198,138,161,0,162],
[155,139,144,168,148,143,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1253, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,177,207,181,171,163,168],
[184,0,186,174,188,157,183,178],
[164,155,0,161,191,153,173,161],
[134,167,180,0,175,163,160,176],
[160,153,150,166,0,130,166,155],
[170,184,188,178,211,0,173,182],
[178,158,168,181,175,168,0,144],
[173,163,180,165,186,159,197,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1254, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,161,183,152,179,163,158],
[186,0,173,190,162,170,171,179],
[180,168,0,189,167,184,177,175],
[158,151,152,0,146,164,157,166],
[189,179,174,195,0,179,158,170],
[162,171,157,177,162,0,160,153],
[178,170,164,184,183,181,0,168],
[183,162,166,175,171,188,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1255, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,158,158,171,162,178,167],
[167,0,152,173,181,178,164,180],
[183,189,0,181,188,178,194,163],
[183,168,160,0,172,165,179,164],
[170,160,153,169,0,155,158,150],
[179,163,163,176,186,0,165,178],
[163,177,147,162,183,176,0,166],
[174,161,178,177,191,163,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1256, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,166,162,199,143,171,154],
[185,0,155,156,173,157,193,149],
[175,186,0,147,177,153,174,176],
[179,185,194,0,191,147,178,182],
[142,168,164,150,0,130,162,146],
[198,184,188,194,211,0,195,157],
[170,148,167,163,179,146,0,158],
[187,192,165,159,195,184,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1257, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,172,166,163,153,182,162],
[173,0,165,168,165,172,176,171],
[169,176,0,176,156,171,182,169],
[175,173,165,0,158,174,169,166],
[178,176,185,183,0,163,184,165],
[188,169,170,167,178,0,185,171],
[159,165,159,172,157,156,0,154],
[179,170,172,175,176,170,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1258, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,177,182,174,175,162,181],
[161,0,171,166,163,170,163,172],
[164,170,0,171,163,168,164,177],
[159,175,170,0,167,179,163,176],
[167,178,178,174,0,187,185,178],
[166,171,173,162,154,0,156,166],
[179,178,177,178,156,185,0,184],
[160,169,164,165,163,175,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1259, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,169,169,174,178,168,190],
[165,0,170,186,166,165,170,173],
[172,171,0,167,175,169,168,186],
[172,155,174,0,170,165,158,194],
[167,175,166,171,0,162,182,169],
[163,176,172,176,179,0,167,178],
[173,171,173,183,159,174,0,167],
[151,168,155,147,172,163,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1260, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,178,181,178,185,162,166],
[180,0,176,156,176,184,187,177],
[163,165,0,164,150,182,155,169],
[160,185,177,0,180,176,193,188],
[163,165,191,161,0,172,186,180],
[156,157,159,165,169,0,156,163],
[179,154,186,148,155,185,0,188],
[175,164,172,153,161,178,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1261, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,168,172,152,174,154,164],
[169,0,180,183,173,164,176,174],
[173,161,0,172,152,175,163,161],
[169,158,169,0,163,156,166,173],
[189,168,189,178,0,168,185,176],
[167,177,166,185,173,0,165,174],
[187,165,178,175,156,176,0,156],
[177,167,180,168,165,167,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1262, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,200,158,143,175,192,174],
[155,0,182,160,139,179,182,189],
[141,159,0,148,122,128,165,170],
[183,181,193,0,187,155,163,174],
[198,202,219,154,0,189,175,177],
[166,162,213,186,152,0,186,183],
[149,159,176,178,166,155,0,196],
[167,152,171,167,164,158,145,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1263, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,85,0,87,87,0,173,0],
[256,0,169,173,87,169,173,0],
[341,172,0,87,172,255,173,172],
[254,168,254,0,168,168,169,168],
[254,254,169,173,0,254,256,83],
[341,172,86,173,87,0,173,0],
[168,168,168,172,85,168,0,168],
[341,341,169,173,258,341,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1264, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,170,180,168,189,179,171],
[170,0,169,169,163,169,184,170],
[171,172,0,170,174,184,176,188],
[161,172,171,0,153,160,155,163],
[173,178,167,188,0,157,173,171],
[152,172,157,181,184,0,157,186],
[162,157,165,186,168,184,0,185],
[170,171,153,178,170,155,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1265, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,167,175,169,188,179,176],
[153,0,147,167,150,176,167,174],
[174,194,0,177,177,166,178,185],
[166,174,164,0,163,184,172,157],
[172,191,164,178,0,191,169,178],
[153,165,175,157,150,0,165,168],
[162,174,163,169,172,176,0,180],
[165,167,156,184,163,173,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1266, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,195,194,180,176,180,187,168],
[146,0,162,167,165,184,172,138],
[147,179,0,151,153,190,179,134],
[161,174,190,0,175,211,170,178],
[165,176,188,166,0,171,177,159],
[161,157,151,130,170,0,173,146],
[154,169,162,171,164,168,0,149],
[173,203,207,163,182,195,192,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1267, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,157,174,162,166,145,181],
[172,0,154,171,167,161,166,174],
[184,187,0,176,176,166,182,196],
[167,170,165,0,190,164,162,165],
[179,174,165,151,0,145,136,168],
[175,180,175,177,196,0,166,187],
[196,175,159,179,205,175,0,194],
[160,167,145,176,173,154,147,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1268, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,187,163,171,192,180,184],
[164,0,166,157,164,162,174,173],
[154,175,0,146,157,180,165,159],
[178,184,195,0,169,175,191,177],
[170,177,184,172,0,183,184,173],
[149,179,161,166,158,0,165,161],
[161,167,176,150,157,176,0,172],
[157,168,182,164,168,180,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1269, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,177,169,162,170,157,170],
[164,0,172,156,163,157,160,169],
[164,169,0,169,170,175,152,161],
[172,185,172,0,174,166,164,173],
[179,178,171,167,0,170,174,175],
[171,184,166,175,171,0,172,174],
[184,181,189,177,167,169,0,185],
[171,172,180,168,166,167,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1270, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,174,164,169,162,186,173],
[174,0,166,176,178,175,196,184],
[167,175,0,161,187,166,185,172],
[177,165,180,0,182,175,195,179],
[172,163,154,159,0,158,171,163],
[179,166,175,166,183,0,178,167],
[155,145,156,146,170,163,0,156],
[168,157,169,162,178,174,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1271, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,179,167,173,175,158,184],
[165,0,175,160,172,157,150,155],
[162,166,0,152,179,169,157,165],
[174,181,189,0,181,165,174,177],
[168,169,162,160,0,158,155,160],
[166,184,172,176,183,0,161,179],
[183,191,184,167,186,180,0,183],
[157,186,176,164,181,162,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1272, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,205,168,172,187,185,197],
[160,0,184,175,171,163,182,188],
[136,157,0,176,159,192,151,152],
[173,166,165,0,158,173,146,180],
[169,170,182,183,0,216,173,211],
[154,178,149,168,125,0,205,184],
[156,159,190,195,168,136,0,192],
[144,153,189,161,130,157,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1273, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,194,185,194,173,180,170,188],
[147,0,168,156,167,179,175,163],
[156,173,0,178,167,176,160,171],
[147,185,163,0,178,168,176,157],
[168,174,174,163,0,169,166,156],
[161,162,165,173,172,0,159,164],
[171,166,181,165,175,182,0,171],
[153,178,170,184,185,177,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1274, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,159,176,185,190,176,184],
[152,0,149,162,150,164,148,163],
[182,192,0,180,185,187,155,184],
[165,179,161,0,180,182,155,178],
[156,191,156,161,0,157,158,172],
[151,177,154,159,184,0,151,170],
[165,193,186,186,183,190,0,193],
[157,178,157,163,169,171,148,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1275, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,159,176,201,164,177,157],
[180,0,175,163,201,173,177,170],
[182,166,0,172,205,155,171,172],
[165,178,169,0,204,159,170,162],
[140,140,136,137,0,150,144,137],
[177,168,186,182,191,0,183,170],
[164,164,170,171,197,158,0,181],
[184,171,169,179,204,171,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1276, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,69,69,137,67,69,69,136],
[272,0,68,136,135,69,69,135],
[272,273,0,137,135,204,204,135],
[204,205,204,0,136,136,136,67],
[274,206,206,205,0,206,138,204],
[272,272,137,205,135,0,0,135],
[272,272,137,205,203,341,0,135],
[205,206,206,274,137,206,206,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1277, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,184,189,164,169,177,176],
[158,0,184,192,181,170,178,179],
[157,157,0,166,177,172,166,162],
[152,149,175,0,149,159,151,155],
[177,160,164,192,0,181,176,179],
[172,171,169,182,160,0,175,175],
[164,163,175,190,165,166,0,173],
[165,162,179,186,162,166,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1278, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,200,166,175,177,171,191],
[173,0,160,146,175,168,153,163],
[141,181,0,145,198,176,153,155],
[175,195,196,0,203,182,157,170],
[166,166,143,138,0,174,156,145],
[164,173,165,159,167,0,137,135],
[170,188,188,184,185,204,0,180],
[150,178,186,171,196,206,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1279, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,191,174,169,161,161,183],
[159,0,183,147,144,164,150,171],
[150,158,0,164,163,157,138,172],
[167,194,177,0,175,163,165,184],
[172,197,178,166,0,169,171,185],
[180,177,184,178,172,0,165,187],
[180,191,203,176,170,176,0,180],
[158,170,169,157,156,154,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1280, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,209,207,238,180,231,160],
[163,0,195,150,179,151,226,154],
[132,146,0,139,176,169,221,151],
[134,191,202,0,210,182,232,191],
[103,162,165,131,0,133,186,123],
[161,190,172,159,208,0,213,142],
[110,115,120,109,155,128,0,109],
[181,187,190,150,218,199,232,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1281, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,163,170,177,183,166,162],
[159,0,134,168,166,188,148,153],
[178,207,0,176,198,202,180,162],
[171,173,165,0,182,201,156,170],
[164,175,143,159,0,168,163,164],
[158,153,139,140,173,0,136,152],
[175,193,161,185,178,205,0,174],
[179,188,179,171,177,189,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1282, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,172,172,157,172,167,173],
[169,0,173,154,163,149,181,174],
[169,168,0,156,171,160,171,155],
[169,187,185,0,165,168,187,171],
[184,178,170,176,0,162,174,165],
[169,192,181,173,179,0,183,174],
[174,160,170,154,167,158,0,170],
[168,167,186,170,176,167,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1283, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,145,166,172,174,193,197],
[185,0,136,195,137,135,176,173],
[196,205,0,188,161,196,217,205],
[175,146,153,0,152,185,175,196],
[169,204,180,189,0,188,179,176],
[167,206,145,156,153,0,176,195],
[148,165,124,166,162,165,0,173],
[144,168,136,145,165,146,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1284, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,184,166,160,163,162,179],
[177,0,189,169,200,183,178,209],
[157,152,0,149,158,151,146,177],
[175,172,192,0,178,181,164,187],
[181,141,183,163,0,165,152,165],
[178,158,190,160,176,0,172,192],
[179,163,195,177,189,169,0,192],
[162,132,164,154,176,149,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1285, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,184,179,181,174,187,163],
[155,0,174,166,167,189,169,170],
[157,167,0,168,177,169,182,160],
[162,175,173,0,184,181,191,171],
[160,174,164,157,0,190,167,177],
[167,152,172,160,151,0,179,164],
[154,172,159,150,174,162,0,150],
[178,171,181,170,164,177,191,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1286, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,178,174,176,192,187,162],
[174,0,140,147,163,180,158,148],
[163,201,0,170,176,203,165,165],
[167,194,171,0,160,179,184,185],
[165,178,165,181,0,172,181,166],
[149,161,138,162,169,0,169,147],
[154,183,176,157,160,172,0,166],
[179,193,176,156,175,194,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1287, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,203,170,166,182,189,196],
[184,0,201,190,169,210,173,189],
[138,140,0,135,145,138,133,144],
[171,151,206,0,173,196,164,210],
[175,172,196,168,0,170,182,193],
[159,131,203,145,171,0,170,195],
[152,168,208,177,159,171,0,191],
[145,152,197,131,148,146,150,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1288, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,196,203,187,194,189,166,185],
[145,0,171,180,173,146,147,155],
[138,170,0,155,177,155,147,143],
[154,161,186,0,189,160,150,163],
[147,168,164,152,0,170,145,143],
[152,195,186,181,171,0,145,170],
[175,194,194,191,196,196,0,163],
[156,186,198,178,198,171,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1289, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,144,155,147,166,159,164,156],
[197,0,168,167,190,196,194,181],
[186,173,0,174,173,185,162,178],
[194,174,167,0,177,202,194,169],
[175,151,168,164,0,179,176,185],
[182,145,156,139,162,0,165,166],
[177,147,179,147,165,176,0,155],
[185,160,163,172,156,175,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1290, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,184,172,187,166,170,176],
[165,0,179,179,193,171,179,182],
[157,162,0,173,188,177,175,174],
[169,162,168,0,185,160,172,167],
[154,148,153,156,0,151,153,153],
[175,170,164,181,190,0,173,166],
[171,162,166,169,188,168,0,161],
[165,159,167,174,188,175,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1291, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,179,175,171,182,164,180],
[171,0,168,172,136,169,171,160],
[162,173,0,192,159,163,157,145],
[166,169,149,0,146,162,159,162],
[170,205,182,195,0,191,176,175],
[159,172,178,179,150,0,174,155],
[177,170,184,182,165,167,0,155],
[161,181,196,179,166,186,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1292, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,166,172,166,191,163,184],
[163,0,135,147,140,161,153,176],
[175,206,0,167,164,167,170,182],
[169,194,174,0,173,178,178,181],
[175,201,177,168,0,191,182,204],
[150,180,174,163,150,0,179,206],
[178,188,171,163,159,162,0,187],
[157,165,159,160,137,135,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1293, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,159,158,149,193,151,173],
[149,0,162,130,138,156,144,163],
[182,179,0,171,164,157,176,166],
[183,211,170,0,147,182,158,172],
[192,203,177,194,0,183,163,181],
[148,185,184,159,158,0,161,169],
[190,197,165,183,178,180,0,187],
[168,178,175,169,160,172,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1294, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,198,178,184,168,190,164],
[166,0,187,164,179,181,166,167],
[143,154,0,174,120,176,179,142],
[163,177,167,0,156,206,148,170],
[157,162,221,185,0,171,204,164],
[173,160,165,135,170,0,125,179],
[151,175,162,193,137,216,0,155],
[177,174,199,171,177,162,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1295, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,185,190,162,176,168,171],
[174,0,168,163,159,167,181,175],
[156,173,0,192,181,176,162,193],
[151,178,149,0,152,154,154,164],
[179,182,160,189,0,177,184,195],
[165,174,165,187,164,0,190,175],
[173,160,179,187,157,151,0,182],
[170,166,148,177,146,166,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1296, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,172,165,171,162,180,175],
[183,0,166,165,178,202,190,176],
[169,175,0,175,167,176,190,184],
[176,176,166,0,154,188,185,172],
[170,163,174,187,0,188,197,183],
[179,139,165,153,153,0,171,161],
[161,151,151,156,144,170,0,146],
[166,165,157,169,158,180,195,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1297, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,153,184,175,166,164,176],
[177,0,184,168,180,171,168,185],
[188,157,0,170,179,173,153,177],
[157,173,171,0,174,173,174,181],
[166,161,162,167,0,170,171,159],
[175,170,168,168,171,0,166,183],
[177,173,188,167,170,175,0,192],
[165,156,164,160,182,158,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1298, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,206,171,125,198,146,191],
[152,0,185,160,164,177,131,209],
[135,156,0,179,143,187,142,170],
[170,181,162,0,181,214,181,185],
[216,177,198,160,0,184,146,176],
[143,164,154,127,157,0,124,177],
[195,210,199,160,195,217,0,176],
[150,132,171,156,165,164,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1299, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,132,165,139,155,145,160,136],
[209,0,194,187,198,185,166,158],
[176,147,0,174,178,181,158,159],
[202,154,167,0,174,185,178,163],
[186,143,163,167,0,185,158,170],
[196,156,160,156,156,0,178,155],
[181,175,183,163,183,163,0,177],
[205,183,182,178,171,186,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1300, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,183,164,163,175,170,163],
[156,0,186,168,159,185,169,154],
[158,155,0,158,145,160,155,140],
[177,173,183,0,149,160,162,154],
[178,182,196,192,0,179,153,182],
[166,156,181,181,162,0,169,167],
[171,172,186,179,188,172,0,166],
[178,187,201,187,159,174,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1301, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,187,168,170,188,188,190],
[176,0,159,176,181,170,177,179],
[154,182,0,171,171,171,155,159],
[173,165,170,0,187,173,173,165],
[171,160,170,154,0,179,174,164],
[153,171,170,168,162,0,170,172],
[153,164,186,168,167,171,0,172],
[151,162,182,176,177,169,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1302, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,178,180,180,164,171,166],
[167,0,169,190,188,181,164,161],
[163,172,0,180,179,172,169,172],
[161,151,161,0,177,152,154,147],
[161,153,162,164,0,165,152,155],
[177,160,169,189,176,0,175,165],
[170,177,172,187,189,166,0,163],
[175,180,169,194,186,176,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1303, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,199,196,174,172,166,174,187],
[142,0,197,172,133,162,154,186],
[145,144,0,161,149,146,157,149],
[167,169,180,0,176,171,162,172],
[169,208,192,165,0,158,170,164],
[175,179,195,170,183,0,158,173],
[167,187,184,179,171,183,0,170],
[154,155,192,169,177,168,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1304, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,176,174,164,171,171,154],
[170,0,169,169,161,171,185,168],
[165,172,0,178,144,177,176,146],
[167,172,163,0,149,172,187,170],
[177,180,197,192,0,160,213,176],
[170,170,164,169,181,0,189,156],
[170,156,165,154,128,152,0,138],
[187,173,195,171,165,185,203,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1305, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,182,178,176,218,206,165],
[167,0,187,166,188,193,192,159],
[159,154,0,172,178,198,193,152],
[163,175,169,0,181,196,197,179],
[165,153,163,160,0,186,188,174],
[123,148,143,145,155,0,171,171],
[135,149,148,144,153,170,0,161],
[176,182,189,162,167,170,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1306, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,227,227,184,209,158,228,159],
[114,0,115,70,92,114,205,115],
[114,226,0,182,182,227,182,159],
[157,271,159,0,182,133,273,180],
[132,249,159,159,0,224,249,135],
[183,227,114,208,117,0,227,182],
[113,136,159,68,92,114,0,159],
[182,226,182,161,206,159,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1307, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,180,190,199,194,180,185],
[180,0,200,158,194,167,181,168],
[161,141,0,151,167,174,144,145],
[151,183,190,0,173,141,155,157],
[142,147,174,168,0,170,148,142],
[147,174,167,200,171,0,149,165],
[161,160,197,186,193,192,0,157],
[156,173,196,184,199,176,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1308, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,206,204,296,182,250,203],
[181,0,205,226,181,159,206,205],
[135,136,0,226,227,158,204,227],
[137,115,115,0,183,114,160,182],
[45,160,114,158,0,162,137,160],
[159,182,183,227,179,0,227,205],
[91,135,137,181,204,114,0,137],
[138,136,114,159,181,136,204,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1309, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,168,181,188,176,175,167],
[159,0,163,180,171,179,182,165],
[173,178,0,167,187,177,162,173],
[160,161,174,0,177,179,185,168],
[153,170,154,164,0,166,161,161],
[165,162,164,162,175,0,166,165],
[166,159,179,156,180,175,0,169],
[174,176,168,173,180,176,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1310, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,160,174,164,166,170,154],
[170,0,164,174,173,160,167,168],
[181,177,0,185,191,169,169,176],
[167,167,156,0,172,153,160,163],
[177,168,150,169,0,167,163,174],
[175,181,172,188,174,0,173,169],
[171,174,172,181,178,168,0,173],
[187,173,165,178,167,172,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1311, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,163,175,191,166,161,176],
[156,0,159,143,165,171,169,177],
[178,182,0,163,190,185,181,186],
[166,198,178,0,197,164,173,197],
[150,176,151,144,0,171,167,187],
[175,170,156,177,170,0,174,192],
[180,172,160,168,174,167,0,181],
[165,164,155,144,154,149,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1312, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,273,239,205,238,273,170,206],
[68,0,172,171,170,204,171,172],
[102,169,0,101,169,237,68,102],
[136,170,240,0,169,306,135,137],
[103,171,172,172,0,240,139,206],
[68,137,104,35,101,0,34,103],
[171,170,273,206,202,307,0,274],
[135,169,239,204,135,238,67,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1313, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,152,170,160,172,171,181],
[166,0,152,145,148,139,161,188],
[189,189,0,187,188,168,205,194],
[171,196,154,0,162,165,186,187],
[181,193,153,179,0,155,169,189],
[169,202,173,176,186,0,197,179],
[170,180,136,155,172,144,0,160],
[160,153,147,154,152,162,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1314, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,184,171,154,161,171,168],
[162,0,159,163,170,153,178,173],
[157,182,0,174,179,174,177,181],
[170,178,167,0,162,151,176,159],
[187,171,162,179,0,177,176,188],
[180,188,167,190,164,0,182,170],
[170,163,164,165,165,159,0,173],
[173,168,160,182,153,171,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1315, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,130,113,116,134,170,92],
[189,0,186,150,173,134,264,226],
[211,155,0,153,136,135,228,154],
[228,191,188,0,153,250,268,171],
[225,168,205,188,0,172,226,189],
[207,207,206,91,169,0,224,169],
[171,77,113,73,115,117,0,154],
[249,115,187,170,152,172,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1316, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,150,113,191,145,144,160,123],
[191,0,184,211,190,204,192,151],
[228,157,0,218,167,214,198,169],
[150,130,123,0,150,172,175,127],
[196,151,174,191,0,220,234,204],
[197,137,127,169,121,0,159,119],
[181,149,143,166,107,182,0,114],
[218,190,172,214,137,222,227,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1317, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,166,181,171,174,155,160],
[179,0,163,181,177,172,167,147],
[175,178,0,192,177,193,160,174],
[160,160,149,0,152,162,151,143],
[170,164,164,189,0,173,163,156],
[167,169,148,179,168,0,156,148],
[186,174,181,190,178,185,0,168],
[181,194,167,198,185,193,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1318, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,151,126,136,172,213,172],
[155,0,138,151,152,137,177,186],
[190,203,0,150,201,163,228,189],
[215,190,191,0,162,175,190,187],
[205,189,140,179,0,163,228,151],
[169,204,178,166,178,0,167,153],
[128,164,113,151,113,174,0,173],
[169,155,152,154,190,188,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1319, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,165,171,170,170,162,159],
[172,0,180,172,173,163,150,168],
[176,161,0,167,167,174,161,171],
[170,169,174,0,173,165,152,164],
[171,168,174,168,0,164,165,158],
[171,178,167,176,177,0,166,170],
[179,191,180,189,176,175,0,168],
[182,173,170,177,183,171,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1320, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,190,210,173,174,169,198],
[173,0,192,184,190,182,176,170],
[151,149,0,168,166,167,161,171],
[131,157,173,0,169,150,165,185],
[168,151,175,172,0,172,145,168],
[167,159,174,191,169,0,161,182],
[172,165,180,176,196,180,0,202],
[143,171,170,156,173,159,139,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1321, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,145,168,148,186,185,180],
[155,0,164,164,119,153,165,185],
[196,177,0,182,169,212,217,209],
[173,177,159,0,182,169,150,162],
[193,222,172,159,0,182,175,195],
[155,188,129,172,159,0,188,190],
[156,176,124,191,166,153,0,152],
[161,156,132,179,146,151,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1322, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,146,157,155,140,151,140],
[183,0,169,193,179,161,179,170],
[195,172,0,184,166,147,179,173],
[184,148,157,0,178,146,152,146],
[186,162,175,163,0,138,155,165],
[201,180,194,195,203,0,166,189],
[190,162,162,189,186,175,0,171],
[201,171,168,195,176,152,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1323, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,195,177,158,181,185,181],
[167,0,190,176,154,185,181,153],
[146,151,0,164,155,168,158,150],
[164,165,177,0,147,152,156,160],
[183,187,186,194,0,153,187,185],
[160,156,173,189,188,0,173,195],
[156,160,183,185,154,168,0,175],
[160,188,191,181,156,146,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1324, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,209,178,223,181,189,133,208],
[132,0,133,145,147,114,175,206],
[163,208,0,179,162,145,175,207],
[118,196,162,0,192,162,102,208],
[160,194,179,149,0,116,133,236],
[152,227,196,179,225,0,210,238],
[208,166,166,239,208,131,0,220],
[133,135,134,133,105,103,121,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1325, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,164,153,159,145,163,160],
[183,0,176,173,178,152,165,170],
[177,165,0,154,152,147,173,171],
[188,168,187,0,159,151,169,162],
[182,163,189,182,0,161,178,187],
[196,189,194,190,180,0,165,185],
[178,176,168,172,163,176,0,167],
[181,171,170,179,154,156,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1326, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,161,148,183,179,164,179],
[182,0,157,172,183,168,160,175],
[180,184,0,177,171,191,167,192],
[193,169,164,0,185,161,154,179],
[158,158,170,156,0,160,148,175],
[162,173,150,180,181,0,157,194],
[177,181,174,187,193,184,0,168],
[162,166,149,162,166,147,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1327, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,274,274,273,273,341,137,206],
[67,0,69,67,67,136,69,69],
[67,272,0,67,67,204,135,135],
[68,274,274,0,68,341,205,137],
[68,274,274,273,0,341,205,205],
[0,205,137,0,0,0,137,68],
[204,272,206,136,136,204,0,137],
[135,272,206,204,136,273,204,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1328, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,172,188,175,178,184,158],
[166,0,165,184,174,173,179,171],
[169,176,0,199,180,180,193,169],
[153,157,142,0,164,180,169,163],
[166,167,161,177,0,176,170,182],
[163,168,161,161,165,0,175,160],
[157,162,148,172,171,166,0,160],
[183,170,172,178,159,181,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1329, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,155,216,186,186,248,218],
[155,0,154,124,156,216,186,126],
[186,187,0,185,156,186,249,187],
[125,217,156,0,124,186,155,124],
[155,185,185,217,0,217,217,154],
[155,125,155,155,124,0,188,157],
[93,155,92,186,124,153,0,156],
[123,215,154,217,187,184,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1330, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,147,160,145,152,162,158,143],
[194,0,170,159,163,148,167,160],
[181,171,0,175,165,181,179,178],
[196,182,166,0,187,167,158,175],
[189,178,176,154,0,165,179,158],
[179,193,160,174,176,0,167,175],
[183,174,162,183,162,174,0,160],
[198,181,163,166,183,166,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1331, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,165,171,165,160,192,153],
[181,0,169,170,166,169,217,167],
[176,172,0,189,150,185,187,169],
[170,171,152,0,163,167,158,153],
[176,175,191,178,0,168,186,175],
[181,172,156,174,173,0,194,176],
[149,124,154,183,155,147,0,169],
[188,174,172,188,166,165,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1332, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,148,162,160,188,161,162],
[170,0,149,163,163,164,181,160],
[193,192,0,177,181,189,158,159],
[179,178,164,0,158,199,174,181],
[181,178,160,183,0,196,164,173],
[153,177,152,142,145,0,144,141],
[180,160,183,167,177,197,0,154],
[179,181,182,160,168,200,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1333, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,176,172,189,188,194,170],
[161,0,178,167,191,172,180,187],
[165,163,0,156,167,170,158,183],
[169,174,185,0,193,182,193,198],
[152,150,174,148,0,166,157,164],
[153,169,171,159,175,0,168,176],
[147,161,183,148,184,173,0,165],
[171,154,158,143,177,165,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1334, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,167,174,176,158,166,177],
[166,0,165,183,185,164,169,172],
[174,176,0,179,197,167,173,169],
[167,158,162,0,187,154,153,158],
[165,156,144,154,0,160,156,162],
[183,177,174,187,181,0,167,184],
[175,172,168,188,185,174,0,180],
[164,169,172,183,179,157,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1335, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,196,191,176,184,167,180],
[166,0,191,173,182,172,165,158],
[145,150,0,162,163,155,154,165],
[150,168,179,0,162,163,156,163],
[165,159,178,179,0,162,186,171],
[157,169,186,178,179,0,166,161],
[174,176,187,185,155,175,0,166],
[161,183,176,178,170,180,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1336, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,188,171,153,181,184,172],
[166,0,194,186,167,173,193,163],
[153,147,0,158,156,154,171,139],
[170,155,183,0,172,175,164,158],
[188,174,185,169,0,172,176,144],
[160,168,187,166,169,0,171,150],
[157,148,170,177,165,170,0,147],
[169,178,202,183,197,191,194,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1337, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,171,170,188,184,181,168],
[167,0,159,169,181,172,171,177],
[170,182,0,166,178,186,180,171],
[171,172,175,0,182,166,180,166],
[153,160,163,159,0,165,169,178],
[157,169,155,175,176,0,180,176],
[160,170,161,161,172,161,0,158],
[173,164,170,175,163,165,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1338, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,158,168,156,162,165,175],
[165,0,163,164,169,166,164,169],
[183,178,0,182,181,161,163,187],
[173,177,159,0,153,168,168,163],
[185,172,160,188,0,171,173,173],
[179,175,180,173,170,0,164,186],
[176,177,178,173,168,177,0,178],
[166,172,154,178,168,155,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1339, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,148,145,147,116,132,138,122],
[193,0,191,103,128,223,143,161],
[196,150,0,175,129,185,173,173],
[194,238,166,0,145,223,210,186],
[225,213,212,196,0,215,214,149],
[209,118,156,118,126,0,160,131],
[203,198,168,131,127,181,0,160],
[219,180,168,155,192,210,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1340, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,267,242,194,169,148,169,165],
[74,0,168,120,193,149,71,94],
[99,173,0,172,124,101,123,146],
[147,221,169,0,218,196,193,191],
[172,148,217,123,0,150,98,168],
[193,192,240,145,191,0,167,188],
[172,270,218,148,243,174,0,191],
[176,247,195,150,173,153,150,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1341, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,154,191,169,180,182,181],
[164,0,165,167,166,176,162,169],
[187,176,0,178,174,178,166,182],
[150,174,163,0,168,169,168,183],
[172,175,167,173,0,180,158,170],
[161,165,163,172,161,0,160,164],
[159,179,175,173,183,181,0,179],
[160,172,159,158,171,177,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1342, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,165,152,212,159,182,209],
[181,0,187,163,223,174,186,221],
[176,154,0,181,221,186,198,228],
[189,178,160,0,227,168,172,226],
[129,118,120,114,0,131,160,174],
[182,167,155,173,210,0,163,213],
[159,155,143,169,181,178,0,196],
[132,120,113,115,167,128,145,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1343, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,170,155,174,152,154,165],
[161,0,164,165,138,166,176,159],
[171,177,0,173,179,157,159,176],
[186,176,168,0,175,186,168,182],
[167,203,162,166,0,167,178,186],
[189,175,184,155,174,0,177,171],
[187,165,182,173,163,164,0,174],
[176,182,165,159,155,170,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1344, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,174,173,164,169,159,169],
[168,0,168,167,169,176,170,170],
[167,173,0,167,168,169,163,161],
[168,174,174,0,173,164,174,169],
[177,172,173,168,0,161,169,178],
[172,165,172,177,180,0,167,179],
[182,171,178,167,172,174,0,173],
[172,171,180,172,163,162,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1345, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,181,174,176,161,155,162],
[172,0,194,171,180,167,152,159],
[160,147,0,155,155,150,145,143],
[167,170,186,0,159,171,170,161],
[165,161,186,182,0,166,164,175],
[180,174,191,170,175,0,170,161],
[186,189,196,171,177,171,0,157],
[179,182,198,180,166,180,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1346, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,169,188,181,187,181,143],
[170,0,171,152,177,154,172,148],
[172,170,0,161,175,167,183,176],
[153,189,180,0,172,172,193,156],
[160,164,166,169,0,180,177,134],
[154,187,174,169,161,0,168,151],
[160,169,158,148,164,173,0,146],
[198,193,165,185,207,190,195,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1347, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,176,170,163,176,177,175],
[173,0,166,161,156,151,161,157],
[165,175,0,150,148,153,156,168],
[171,180,191,0,164,167,170,168],
[178,185,193,177,0,172,169,173],
[165,190,188,174,169,0,175,180],
[164,180,185,171,172,166,0,184],
[166,184,173,173,168,161,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1348, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,179,186,180,158,162,176],
[160,0,172,187,192,167,175,179],
[162,169,0,175,176,134,165,145],
[155,154,166,0,180,157,154,151],
[161,149,165,161,0,141,147,160],
[183,174,207,184,200,0,168,189],
[179,166,176,187,194,173,0,187],
[165,162,196,190,181,152,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1349, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,162,150,158,157,146,166],
[176,0,172,175,169,164,168,167],
[179,169,0,163,155,156,167,175],
[191,166,178,0,159,175,176,179],
[183,172,186,182,0,170,179,186],
[184,177,185,166,171,0,168,193],
[195,173,174,165,162,173,0,174],
[175,174,166,162,155,148,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1350, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,125,161,193,147,174,188],
[149,0,130,96,160,113,119,139],
[216,211,0,189,202,170,188,197],
[180,245,152,0,203,160,193,204],
[148,181,139,138,0,173,174,177],
[194,228,171,181,168,0,162,173],
[167,222,153,148,167,179,0,178],
[153,202,144,137,164,168,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1351, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,193,168,180,120,176,151,206],
[148,0,172,161,168,173,133,187],
[173,169,0,173,190,134,141,165],
[161,180,168,0,148,153,155,173],
[221,173,151,193,0,167,161,179],
[165,168,207,188,174,0,177,209],
[190,208,200,186,180,164,0,180],
[135,154,176,168,162,132,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1352, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,202,171,183,194,164,229,212],
[139,0,154,145,152,177,162,143],
[170,187,0,156,192,177,206,198],
[158,196,185,0,210,174,187,179],
[147,189,149,131,0,154,172,151],
[177,164,164,167,187,0,194,166],
[112,179,135,154,169,147,0,146],
[129,198,143,162,190,175,195,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1353, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,149,165,170,158,157,157],
[179,0,167,155,170,164,152,164],
[192,174,0,169,202,141,171,176],
[176,186,172,0,173,162,165,169],
[171,171,139,168,0,146,145,152],
[183,177,200,179,195,0,167,171],
[184,189,170,176,196,174,0,161],
[184,177,165,172,189,170,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1354, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,179,177,168,176,184,182],
[171,0,188,182,175,166,177,172],
[162,153,0,171,172,165,146,168],
[164,159,170,0,160,158,160,167],
[173,166,169,181,0,167,157,165],
[165,175,176,183,174,0,173,169],
[157,164,195,181,184,168,0,164],
[159,169,173,174,176,172,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1355, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,148,182,172,190,176,176],
[172,0,164,172,167,187,138,166],
[193,177,0,196,179,168,153,182],
[159,169,145,0,161,175,149,162],
[169,174,162,180,0,181,159,183],
[151,154,173,166,160,0,140,163],
[165,203,188,192,182,201,0,180],
[165,175,159,179,158,178,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1356, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,175,182,178,164,170,173],
[170,0,163,185,167,167,171,174],
[166,178,0,172,172,168,173,173],
[159,156,169,0,154,153,150,163],
[163,174,169,187,0,171,168,174],
[177,174,173,188,170,0,169,170],
[171,170,168,191,173,172,0,179],
[168,167,168,178,167,171,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1357, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,162,145,162,155,142,184],
[179,0,169,164,167,170,163,183],
[179,172,0,162,171,176,152,181],
[196,177,179,0,178,175,164,186],
[179,174,170,163,0,176,176,171],
[186,171,165,166,165,0,166,168],
[199,178,189,177,165,175,0,182],
[157,158,160,155,170,173,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1358, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,156,176,172,169,163,173],
[174,0,160,152,146,174,155,155],
[185,181,0,165,180,174,155,182],
[165,189,176,0,171,177,171,173],
[169,195,161,170,0,180,166,174],
[172,167,167,164,161,0,158,168],
[178,186,186,170,175,183,0,187],
[168,186,159,168,167,173,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1359, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,163,163,188,185,168,181],
[154,0,135,157,156,157,152,140],
[178,206,0,171,182,165,169,170],
[178,184,170,0,188,172,164,172],
[153,185,159,153,0,159,157,160],
[156,184,176,169,182,0,178,179],
[173,189,172,177,184,163,0,185],
[160,201,171,169,181,162,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1360, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,175,181,181,197,157,173],
[170,0,176,191,198,176,161,181],
[166,165,0,177,182,154,155,180],
[160,150,164,0,180,177,161,165],
[160,143,159,161,0,146,144,157],
[144,165,187,164,195,0,137,156],
[184,180,186,180,197,204,0,164],
[168,160,161,176,184,185,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1361, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,175,180,178,175,172,181],
[176,0,177,162,179,166,178,189],
[166,164,0,185,185,179,143,162],
[161,179,156,0,170,175,181,185],
[163,162,156,171,0,178,178,171],
[166,175,162,166,163,0,180,174],
[169,163,198,160,163,161,0,181],
[160,152,179,156,170,167,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1362, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,161,167,156,165,183,156],
[190,0,165,175,169,184,195,163],
[180,176,0,187,175,178,180,159],
[174,166,154,0,160,177,170,158],
[185,172,166,181,0,174,184,179],
[176,157,163,164,167,0,173,153],
[158,146,161,171,157,168,0,150],
[185,178,182,183,162,188,191,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1363, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,178,185,171,180,176,170],
[158,0,144,160,168,166,165,156],
[163,197,0,174,178,179,174,173],
[156,181,167,0,177,166,167,163],
[170,173,163,164,0,171,163,159],
[161,175,162,175,170,0,174,166],
[165,176,167,174,178,167,0,170],
[171,185,168,178,182,175,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1364, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,170,169,163,174,165,156],
[164,0,176,160,165,162,165,169],
[171,165,0,178,175,175,165,159],
[172,181,163,0,170,158,163,167],
[178,176,166,171,0,177,166,176],
[167,179,166,183,164,0,175,170],
[176,176,176,178,175,166,0,170],
[185,172,182,174,165,171,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1365, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,120,120,170,120,95,144,122],
[221,0,194,147,170,268,219,172],
[221,147,0,146,122,171,221,147],
[171,194,195,0,219,146,170,196],
[221,171,219,122,0,194,219,196],
[246,73,170,195,147,0,145,147],
[197,122,120,171,122,196,0,147],
[219,169,194,145,145,194,194,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1366, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,213,182,141,160,189,205,161],
[128,0,180,148,148,142,159,151],
[159,161,0,153,135,163,130,166],
[200,193,188,0,179,166,172,171],
[181,193,206,162,0,183,196,171],
[152,199,178,175,158,0,177,162],
[136,182,211,169,145,164,0,187],
[180,190,175,170,170,179,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1367, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,185,177,209,155,175,198],
[182,0,219,159,182,183,184,172],
[156,122,0,127,133,134,165,184],
[164,182,214,0,179,167,156,180],
[132,159,208,162,0,131,161,182],
[186,158,207,174,210,0,209,222],
[166,157,176,185,180,132,0,145],
[143,169,157,161,159,119,196,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1368, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,162,187,180,156,179,153],
[162,0,171,162,188,186,148,180],
[179,170,0,186,204,194,173,188],
[154,179,155,0,168,175,147,151],
[161,153,137,173,0,167,167,155],
[185,155,147,166,174,0,138,159],
[162,193,168,194,174,203,0,162],
[188,161,153,190,186,182,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1369, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,188,184,201,172,166,196],
[153,0,152,154,185,156,168,199],
[153,189,0,153,187,167,170,202],
[157,187,188,0,185,165,179,207],
[140,156,154,156,0,149,153,190],
[169,185,174,176,192,0,185,198],
[175,173,171,162,188,156,0,186],
[145,142,139,134,151,143,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1370, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,161,156,165,182,158,161],
[162,0,157,151,165,165,146,143],
[180,184,0,176,177,178,177,162],
[185,190,165,0,183,176,173,179],
[176,176,164,158,0,173,162,153],
[159,176,163,165,168,0,161,146],
[183,195,164,168,179,180,0,177],
[180,198,179,162,188,195,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1371, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,170,179,183,176,178,176],
[171,0,179,179,179,175,175,168],
[171,162,0,164,164,170,176,172],
[162,162,177,0,181,172,174,176],
[158,162,177,160,0,156,169,167],
[165,166,171,169,185,0,175,176],
[163,166,165,167,172,166,0,171],
[165,173,169,165,174,165,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1372, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,167,192,169,167,168,170],
[163,0,173,176,180,171,157,177],
[174,168,0,193,186,181,181,174],
[149,165,148,0,174,157,150,163],
[172,161,155,167,0,159,160,173],
[174,170,160,184,182,0,174,168],
[173,184,160,191,181,167,0,184],
[171,164,167,178,168,173,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1373, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,165,177,174,178,178,167],
[185,0,170,178,172,186,179,179],
[176,171,0,166,168,180,187,187],
[164,163,175,0,168,186,178,183],
[167,169,173,173,0,172,181,183],
[163,155,161,155,169,0,166,180],
[163,162,154,163,160,175,0,176],
[174,162,154,158,158,161,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1374, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,175,170,169,191,161,185],
[176,0,166,174,169,186,178,192],
[166,175,0,177,156,167,158,181],
[171,167,164,0,161,173,168,178],
[172,172,185,180,0,189,167,183],
[150,155,174,168,152,0,160,174],
[180,163,183,173,174,181,0,192],
[156,149,160,163,158,167,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1375, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,195,165,182,178,172,178],
[164,0,184,170,173,181,160,192],
[146,157,0,156,162,153,143,158],
[176,171,185,0,175,168,186,178],
[159,168,179,166,0,188,193,186],
[163,160,188,173,153,0,152,182],
[169,181,198,155,148,189,0,192],
[163,149,183,163,155,159,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1376, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,197,175,163,163,171,181,179],
[144,0,163,143,153,161,185,145],
[166,178,0,152,173,169,180,200],
[178,198,189,0,138,192,162,178],
[178,188,168,203,0,183,216,189],
[170,180,172,149,158,0,188,176],
[160,156,161,179,125,153,0,156],
[162,196,141,163,152,165,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1377, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,180,170,174,166,195,169],
[165,0,169,169,163,154,176,161],
[161,172,0,164,156,167,173,162],
[171,172,177,0,150,164,181,177],
[167,178,185,191,0,187,192,183],
[175,187,174,177,154,0,178,167],
[146,165,168,160,149,163,0,154],
[172,180,179,164,158,174,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1378, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,174,195,167,176,200,171],
[157,0,171,164,202,153,206,188],
[167,170,0,169,156,152,166,143],
[146,177,172,0,183,162,182,193],
[174,139,185,158,0,157,171,144],
[165,188,189,179,184,0,189,181],
[141,135,175,159,170,152,0,155],
[170,153,198,148,197,160,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1379, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,96,169,166,110,186,129,133],
[245,0,228,167,224,243,187,203],
[172,113,0,188,134,131,92,152],
[175,174,153,0,136,150,114,133],
[231,117,207,205,0,149,95,153],
[155,98,210,191,192,0,113,118],
[212,154,249,227,246,228,0,192],
[208,138,189,208,188,223,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1380, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,167,151,159,164,196,165],
[160,0,190,167,172,177,177,172],
[174,151,0,140,152,182,132,142],
[190,174,201,0,185,203,213,162],
[182,169,189,156,0,208,197,168],
[177,164,159,138,133,0,142,146],
[145,164,209,128,144,199,0,159],
[176,169,199,179,173,195,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1381, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,129,140,146,136,124,129,146],
[212,0,178,171,183,164,187,189],
[201,163,0,195,181,179,168,181],
[195,170,146,0,164,140,162,156],
[205,158,160,177,0,159,174,163],
[217,177,162,201,182,0,184,195],
[212,154,173,179,167,157,0,171],
[195,152,160,185,178,146,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1382, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,168,194,139,168,146,164],
[190,0,166,199,150,154,167,164],
[173,175,0,186,148,171,168,165],
[147,142,155,0,154,140,166,145],
[202,191,193,187,0,153,159,179],
[173,187,170,201,188,0,182,180],
[195,174,173,175,182,159,0,176],
[177,177,176,196,162,161,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1383, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,217,147,177,213,197,163,212],
[124,0,159,156,152,175,154,163],
[194,182,0,177,197,208,169,204],
[164,185,164,0,194,207,174,210],
[128,189,144,147,0,194,146,190],
[144,166,133,134,147,0,96,159],
[178,187,172,167,195,245,0,204],
[129,178,137,131,151,182,137,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1384, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,149,167,170,189,178,156,175],
[192,0,163,174,195,176,170,179],
[174,178,0,177,186,166,163,190],
[171,167,164,0,194,181,161,189],
[152,146,155,147,0,155,151,166],
[163,165,175,160,186,0,151,162],
[185,171,178,180,190,190,0,170],
[166,162,151,152,175,179,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1385, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,178,172,165,176,175,173],
[167,0,161,164,169,166,165,166],
[163,180,0,172,149,170,154,157],
[169,177,169,0,179,160,165,169],
[176,172,192,162,0,174,171,161],
[165,175,171,181,167,0,163,176],
[166,176,187,176,170,178,0,164],
[168,175,184,172,180,165,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1386, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,150,170,166,170,153,188],
[179,0,167,171,177,170,166,177],
[191,174,0,182,184,173,163,167],
[171,170,159,0,172,164,156,166],
[175,164,157,169,0,171,167,173],
[171,171,168,177,170,0,179,167],
[188,175,178,185,174,162,0,185],
[153,164,174,175,168,174,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1387, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,179,186,183,178,168,174],
[168,0,178,180,182,175,173,185],
[162,163,0,173,190,166,146,187],
[155,161,168,0,186,162,165,174],
[158,159,151,155,0,163,156,166],
[163,166,175,179,178,0,166,175],
[173,168,195,176,185,175,0,186],
[167,156,154,167,175,166,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1388, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,178,175,171,164,169,167],
[152,0,159,170,147,162,164,149],
[163,182,0,166,170,176,172,173],
[166,171,175,0,165,168,176,173],
[170,194,171,176,0,155,173,169],
[177,179,165,173,186,0,175,164],
[172,177,169,165,168,166,0,157],
[174,192,168,168,172,177,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1389, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,194,164,183,179,175,153,140],
[147,0,138,191,186,214,172,191],
[177,203,0,193,174,213,161,170],
[158,150,148,0,131,140,151,159],
[162,155,167,210,0,179,178,177],
[166,127,128,201,162,0,149,171],
[188,169,180,190,163,192,0,181],
[201,150,171,182,164,170,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1390, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,166,175,173,186,161,197],
[154,0,160,162,167,154,171,171],
[175,181,0,176,174,174,160,177],
[166,179,165,0,183,173,160,189],
[168,174,167,158,0,181,159,179],
[155,187,167,168,160,0,165,167],
[180,170,181,181,182,176,0,195],
[144,170,164,152,162,174,146,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1391, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,173,162,151,151,156,156],
[184,0,177,177,181,163,167,171],
[168,164,0,168,180,172,181,173],
[179,164,173,0,155,157,166,159],
[190,160,161,186,0,174,162,172],
[190,178,169,184,167,0,175,162],
[185,174,160,175,179,166,0,170],
[185,170,168,182,169,179,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1392, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,165,197,208,167,204,170],
[181,0,179,207,220,164,211,206],
[176,162,0,191,173,192,185,199],
[144,134,150,0,166,161,142,159],
[133,121,168,175,0,135,153,174],
[174,177,149,180,206,0,192,163],
[137,130,156,199,188,149,0,169],
[171,135,142,182,167,178,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1393, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,231,217,183,180,180,173,154],
[110,0,166,146,143,179,139,127],
[124,175,0,144,127,184,125,164],
[158,195,197,0,180,198,157,169],
[161,198,214,161,0,199,157,139],
[161,162,157,143,142,0,133,152],
[168,202,216,184,184,208,0,181],
[187,214,177,172,202,189,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1394, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,150,158,159,165,178,151],
[165,0,171,177,178,149,166,150],
[191,170,0,181,199,176,191,170],
[183,164,160,0,167,179,165,159],
[182,163,142,174,0,167,173,166],
[176,192,165,162,174,0,187,177],
[163,175,150,176,168,154,0,162],
[190,191,171,182,175,164,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1395, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,173,174,160,176,180,170],
[174,0,184,167,170,183,183,180],
[168,157,0,171,171,173,172,167],
[167,174,170,0,179,174,190,178],
[181,171,170,162,0,171,186,165],
[165,158,168,167,170,0,179,173],
[161,158,169,151,155,162,0,159],
[171,161,174,163,176,168,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1396, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,169,159,155,177,175,145],
[166,0,161,152,147,184,158,160],
[172,180,0,155,174,180,170,153],
[182,189,186,0,144,180,175,163],
[186,194,167,197,0,206,198,147],
[164,157,161,161,135,0,154,148],
[166,183,171,166,143,187,0,173],
[196,181,188,178,194,193,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1397, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,193,168,210,183,171,178,155],
[148,0,177,175,159,159,178,166],
[173,164,0,178,178,173,188,174],
[131,166,163,0,181,174,184,166],
[158,182,163,160,0,144,186,132],
[170,182,168,167,197,0,175,165],
[163,163,153,157,155,166,0,145],
[186,175,167,175,209,176,196,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1398, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,144,162,201,182,161,182],
[179,0,162,180,200,180,200,179],
[197,179,0,161,219,140,178,160],
[179,161,180,0,183,183,179,197],
[140,141,122,158,0,159,99,139],
[159,161,201,158,182,0,99,157],
[180,141,163,162,242,242,0,183],
[159,162,181,144,202,184,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1399, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,152,150,160,138,152,141],
[174,0,132,149,137,135,117,132],
[189,209,0,162,183,172,186,143],
[191,192,179,0,153,169,166,149],
[181,204,158,188,0,171,185,187],
[203,206,169,172,170,0,152,156],
[189,224,155,175,156,189,0,144],
[200,209,198,192,154,185,197,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1400, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,153,163,185,187,157,160],
[160,0,163,166,176,164,171,172],
[188,178,0,166,190,163,163,172],
[178,175,175,0,177,169,164,171],
[156,165,151,164,0,168,149,162],
[154,177,178,172,173,0,155,159],
[184,170,178,177,192,186,0,178],
[181,169,169,170,179,182,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1401, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,178,132,147,173,178,147],
[189,0,168,181,166,175,174,154],
[163,173,0,172,164,179,169,161],
[209,160,169,0,159,183,188,187],
[194,175,177,182,0,193,165,176],
[168,166,162,158,148,0,177,160],
[163,167,172,153,176,164,0,147],
[194,187,180,154,165,181,194,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1402, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,205,154,188,134,176,150],
[149,0,235,149,202,214,231,192],
[136,106,0,80,136,124,135,152],
[187,192,261,0,190,204,190,153],
[153,139,205,151,0,148,195,164],
[207,127,217,137,193,0,178,124],
[165,110,206,151,146,163,0,129],
[191,149,189,188,177,217,212,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1403, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,144,151,173,153,154,145],
[173,0,144,152,154,150,159,151],
[197,197,0,168,200,173,173,184],
[190,189,173,0,183,175,158,167],
[168,187,141,158,0,164,162,171],
[188,191,168,166,177,0,176,177],
[187,182,168,183,179,165,0,175],
[196,190,157,174,170,164,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1404, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,184,189,171,182,181,165],
[160,0,165,178,161,172,179,164],
[157,176,0,188,168,165,173,171],
[152,163,153,0,148,160,171,154],
[170,180,173,193,0,174,175,153],
[159,169,176,181,167,0,177,168],
[160,162,168,170,166,164,0,149],
[176,177,170,187,188,173,192,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1405, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,159,183,174,162,172,152],
[163,0,174,188,176,175,206,174],
[182,167,0,184,182,178,189,158],
[158,153,157,0,169,152,174,149],
[167,165,159,172,0,162,167,157],
[179,166,163,189,179,0,182,156],
[169,135,152,167,174,159,0,151],
[189,167,183,192,184,185,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1406, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,185,173,172,166,183,175],
[170,0,179,166,157,151,170,171],
[156,162,0,156,155,145,164,171],
[168,175,185,0,153,171,171,163],
[169,184,186,188,0,167,189,164],
[175,190,196,170,174,0,186,172],
[158,171,177,170,152,155,0,157],
[166,170,170,178,177,169,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1407, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,164,168,159,161,173,157],
[173,0,165,179,172,158,179,160],
[177,176,0,185,170,163,185,175],
[173,162,156,0,166,157,174,159],
[182,169,171,175,0,171,174,169],
[180,183,178,184,170,0,174,171],
[168,162,156,167,167,167,0,170],
[184,181,166,182,172,170,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1408, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,177,171,176,174,182,181],
[171,0,169,171,173,166,178,162],
[164,172,0,157,169,170,175,179],
[170,170,184,0,171,164,178,183],
[165,168,172,170,0,161,176,189],
[167,175,171,177,180,0,172,183],
[159,163,166,163,165,169,0,160],
[160,179,162,158,152,158,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1409, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,171,184,201,173,180,172],
[186,0,179,180,215,167,177,174],
[170,162,0,166,203,161,158,160],
[157,161,175,0,191,146,175,174],
[140,126,138,150,0,131,147,145],
[168,174,180,195,210,0,174,181],
[161,164,183,166,194,167,0,177],
[169,167,181,167,196,160,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1410, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,134,170,157,164,152,144,166],
[207,0,193,183,187,183,171,170],
[171,148,0,174,177,157,155,157],
[184,158,167,0,174,179,163,166],
[177,154,164,167,0,169,164,171],
[189,158,184,162,172,0,151,172],
[197,170,186,178,177,190,0,178],
[175,171,184,175,170,169,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1411, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,166,198,179,171,174,187],
[174,0,175,170,174,183,183,174],
[175,166,0,174,182,174,187,180],
[143,171,167,0,176,182,166,172],
[162,167,159,165,0,170,161,187],
[170,158,167,159,171,0,175,174],
[167,158,154,175,180,166,0,174],
[154,167,161,169,154,167,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1412, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,145,180,175,131,179,175,157],
[196,0,195,196,178,168,179,175],
[161,146,0,177,157,160,168,167],
[166,145,164,0,127,146,151,154],
[210,163,184,214,0,184,185,176],
[162,173,181,195,157,0,179,169],
[166,162,173,190,156,162,0,152],
[184,166,174,187,165,172,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1413, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,180,166,184,173,182,148],
[161,0,162,175,156,154,150,139],
[161,179,0,188,170,165,212,161],
[175,166,153,0,170,156,164,139],
[157,185,171,171,0,160,167,158],
[168,187,176,185,181,0,167,171],
[159,191,129,177,174,174,0,173],
[193,202,180,202,183,170,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1414, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,163,163,160,175,161,175],
[171,0,174,171,165,166,172,165],
[178,167,0,163,169,176,174,181],
[178,170,178,0,164,175,175,170],
[181,176,172,177,0,169,169,179],
[166,175,165,166,172,0,172,164],
[180,169,167,166,172,169,0,172],
[166,176,160,171,162,177,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1415, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,192,172,171,200,173,184],
[190,0,172,161,180,196,166,185],
[149,169,0,183,192,169,175,196],
[169,180,158,0,164,196,184,161],
[170,161,149,177,0,160,162,168],
[141,145,172,145,181,0,184,163],
[168,175,166,157,179,157,0,192],
[157,156,145,180,173,178,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1416, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,150,171,185,160,150,150],
[185,0,180,173,172,187,175,159],
[191,161,0,172,182,173,171,159],
[170,168,169,0,176,167,168,159],
[156,169,159,165,0,151,138,156],
[181,154,168,174,190,0,169,162],
[191,166,170,173,203,172,0,179],
[191,182,182,182,185,179,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1417, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,166,118,117,187,185,171],
[190,0,165,150,173,159,222,243],
[175,176,0,175,193,158,207,194],
[223,191,166,0,210,191,240,208],
[224,168,148,131,0,172,220,238],
[154,182,183,150,169,0,220,241],
[156,119,134,101,121,121,0,191],
[170,98,147,133,103,100,150,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1418, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,124,116,163,181,153,134,159],
[217,0,182,194,220,158,183,193],
[225,159,0,164,203,198,220,189],
[178,147,177,0,224,163,160,189],
[160,121,138,117,0,110,124,110],
[188,183,143,178,231,0,151,200],
[207,158,121,181,217,190,0,183],
[182,148,152,152,231,141,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1419, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,167,156,171,172,182,176],
[183,0,175,173,176,180,168,176],
[174,166,0,177,185,169,185,179],
[185,168,164,0,192,177,193,165],
[170,165,156,149,0,160,174,168],
[169,161,172,164,181,0,169,180],
[159,173,156,148,167,172,0,172],
[165,165,162,176,173,161,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1420, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,168,164,170,181,172,172],
[165,0,152,148,161,163,165,161],
[173,189,0,167,182,185,180,162],
[177,193,174,0,169,171,172,160],
[171,180,159,172,0,182,170,165],
[160,178,156,170,159,0,167,154],
[169,176,161,169,171,174,0,182],
[169,180,179,181,176,187,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1421, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,161,174,167,163,159,162],
[180,0,172,173,173,163,168,163],
[180,169,0,180,156,175,177,167],
[167,168,161,0,150,158,156,160],
[174,168,185,191,0,174,174,173],
[178,178,166,183,167,0,175,169],
[182,173,164,185,167,166,0,176],
[179,178,174,181,168,172,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1422, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,183,172,174,161,191,174],
[154,0,167,151,166,181,175,159],
[158,174,0,168,160,165,167,169],
[169,190,173,0,183,185,186,172],
[167,175,181,158,0,190,182,169],
[180,160,176,156,151,0,170,172],
[150,166,174,155,159,171,0,186],
[167,182,172,169,172,169,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1423, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,152,150,157,180,161,142],
[190,0,155,163,172,177,186,171],
[189,186,0,156,174,179,170,169],
[191,178,185,0,177,195,162,160],
[184,169,167,164,0,185,172,166],
[161,164,162,146,156,0,170,151],
[180,155,171,179,169,171,0,166],
[199,170,172,181,175,190,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1424, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,182,164,163,189,174,155],
[181,0,169,177,173,186,178,177],
[159,172,0,166,160,190,179,172],
[177,164,175,0,159,181,170,177],
[178,168,181,182,0,199,190,185],
[152,155,151,160,142,0,175,164],
[167,163,162,171,151,166,0,172],
[186,164,169,164,156,177,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1425, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,190,192,165,219,176,177,146],
[151,0,162,153,192,121,119,151],
[149,179,0,151,150,150,135,136],
[176,188,190,0,160,132,202,149],
[122,149,191,181,0,106,175,149],
[165,220,191,209,235,0,207,178],
[164,222,206,139,166,134,0,152],
[195,190,205,192,192,163,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1426, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,162,163,168,162,147,166],
[187,0,174,176,164,186,170,177],
[179,167,0,179,156,159,166,173],
[178,165,162,0,170,177,170,164],
[173,177,185,171,0,179,176,169],
[179,155,182,164,162,0,170,175],
[194,171,175,171,165,171,0,178],
[175,164,168,177,172,166,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1427, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,178,199,191,172,164,192],
[165,0,173,178,182,156,176,186],
[163,168,0,180,167,187,152,172],
[142,163,161,0,163,162,157,177],
[150,159,174,178,0,168,152,185],
[169,185,154,179,173,0,161,187],
[177,165,189,184,189,180,0,198],
[149,155,169,164,156,154,143,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1428, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,143,168,152,168,152,160],
[181,0,167,176,166,179,171,166],
[198,174,0,176,183,169,153,189],
[173,165,165,0,166,162,156,151],
[189,175,158,175,0,165,150,173],
[173,162,172,179,176,0,157,170],
[189,170,188,185,191,184,0,188],
[181,175,152,190,168,171,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1429, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,173,162,162,169,164,150],
[170,0,194,165,179,171,169,187],
[168,147,0,171,161,155,161,172],
[179,176,170,0,144,170,182,164],
[179,162,180,197,0,188,178,174],
[172,170,186,171,153,0,186,172],
[177,172,180,159,163,155,0,174],
[191,154,169,177,167,169,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1430, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,150,181,167,174,134,148],
[169,0,172,169,187,185,163,166],
[191,169,0,199,175,198,165,173],
[160,172,142,0,176,179,161,187],
[174,154,166,165,0,171,169,162],
[167,156,143,162,170,0,146,159],
[207,178,176,180,172,195,0,161],
[193,175,168,154,179,182,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1431, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,196,171,190,173,170,217,148],
[145,0,143,152,140,138,174,168],
[170,198,0,163,157,169,203,166],
[151,189,178,0,165,190,209,173],
[168,201,184,176,0,176,196,162],
[171,203,172,151,165,0,191,140],
[124,167,138,132,145,150,0,138],
[193,173,175,168,179,201,203,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1432, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,181,203,148,192,161,174],
[180,0,170,226,149,145,142,161],
[160,171,0,188,129,152,164,180],
[138,115,153,0,130,102,126,154],
[193,192,212,211,0,166,165,203],
[149,196,189,239,175,0,196,187],
[180,199,177,215,176,145,0,206],
[167,180,161,187,138,154,135,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1433, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,159,189,190,179,185,178],
[164,0,161,180,167,157,183,179],
[182,180,0,183,184,186,170,172],
[152,161,158,0,172,179,177,147],
[151,174,157,169,0,162,171,165],
[162,184,155,162,179,0,180,161],
[156,158,171,164,170,161,0,157],
[163,162,169,194,176,180,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1434, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,189,170,170,197,181,169],
[168,0,192,177,172,188,185,177],
[152,149,0,163,161,187,169,161],
[171,164,178,0,169,183,166,172],
[171,169,180,172,0,183,168,170],
[144,153,154,158,158,0,158,159],
[160,156,172,175,173,183,0,155],
[172,164,180,169,171,182,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1435, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,204,174,173,181,183,183,155],
[137,0,125,122,123,155,130,114],
[167,216,0,177,172,205,195,188],
[168,219,164,0,191,183,156,154],
[160,218,169,150,0,167,165,169],
[158,186,136,158,174,0,147,175],
[158,211,146,185,176,194,0,156],
[186,227,153,187,172,166,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1436, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,169,189,163,178,171,153],
[189,0,164,196,187,173,170,163],
[172,177,0,188,175,189,169,173],
[152,145,153,0,176,154,158,154],
[178,154,166,165,0,182,167,155],
[163,168,152,187,159,0,153,162],
[170,171,172,183,174,188,0,158],
[188,178,168,187,186,179,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1437, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,168,166,174,168,173,168],
[159,0,189,161,161,168,153,187],
[173,152,0,175,175,171,183,187],
[175,180,166,0,179,150,152,191],
[167,180,166,162,0,170,171,189],
[173,173,170,191,171,0,160,202],
[168,188,158,189,170,181,0,194],
[173,154,154,150,152,139,147,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1438, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,164,181,193,176,181,168],
[165,0,159,174,174,169,175,171],
[177,182,0,179,189,170,187,174],
[160,167,162,0,172,156,167,168],
[148,167,152,169,0,164,169,166],
[165,172,171,185,177,0,187,186],
[160,166,154,174,172,154,0,161],
[173,170,167,173,175,155,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1439, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,138,152,165,172,206,146],
[163,0,152,156,156,175,172,148],
[203,189,0,118,183,167,197,143],
[189,185,223,0,189,173,236,170],
[176,185,158,152,0,172,246,160],
[169,166,174,168,169,0,190,174],
[135,169,144,105,95,151,0,146],
[195,193,198,171,181,167,195,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1440, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,185,191,195,172,185,188],
[185,0,166,165,187,184,205,164],
[156,175,0,182,200,159,160,187],
[150,176,159,0,190,184,179,182],
[146,154,141,151,0,158,145,155],
[169,157,182,157,183,0,158,164],
[156,136,181,162,196,183,0,147],
[153,177,154,159,186,177,194,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1441, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,175,172,166,176,186,156],
[174,0,163,175,171,167,181,167],
[166,178,0,178,163,166,174,166],
[169,166,163,0,170,182,188,181],
[175,170,178,171,0,182,180,171],
[165,174,175,159,159,0,177,164],
[155,160,167,153,161,164,0,163],
[185,174,175,160,170,177,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1442, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,151,160,157,142,151,158],
[181,0,180,179,177,165,167,170],
[190,161,0,158,169,154,160,165],
[181,162,183,0,178,144,154,163],
[184,164,172,163,0,136,153,147],
[199,176,187,197,205,0,181,170],
[190,174,181,187,188,160,0,173],
[183,171,176,178,194,171,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1443, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,132,226,169,135,151,209,127],
[209,0,205,150,189,191,226,205],
[115,136,0,136,194,114,156,113],
[172,191,205,0,155,153,172,167],
[206,152,147,186,0,114,188,130],
[190,150,227,188,227,0,173,168],
[132,115,185,169,153,168,0,149],
[214,136,228,174,211,173,192,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1444, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,174,175,162,173,186,169],
[170,0,202,178,149,154,185,182],
[167,139,0,163,135,170,167,166],
[166,163,178,0,152,170,187,159],
[179,192,206,189,0,165,187,178],
[168,187,171,171,176,0,188,175],
[155,156,174,154,154,153,0,154],
[172,159,175,182,163,166,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1445, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,163,178,172,162,158,167],
[170,0,140,184,177,179,151,144],
[178,201,0,201,179,201,172,168],
[163,157,140,0,146,146,140,141],
[169,164,162,195,0,186,162,152],
[179,162,140,195,155,0,169,169],
[183,190,169,201,179,172,0,188],
[174,197,173,200,189,172,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1446, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,207,191,203,169,169,221,198],
[134,0,148,151,156,123,159,168],
[150,193,0,183,165,165,202,189],
[138,190,158,0,155,147,172,153],
[172,185,176,186,0,180,191,170],
[172,218,176,194,161,0,195,232],
[120,182,139,169,150,146,0,151],
[143,173,152,188,171,109,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1447, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,172,170,165,184,173,175],
[170,0,165,164,148,169,155,167],
[169,176,0,167,177,178,164,168],
[171,177,174,0,178,176,151,186],
[176,193,164,163,0,184,157,173],
[157,172,163,165,157,0,155,160],
[168,186,177,190,184,186,0,168],
[166,174,173,155,168,181,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1448, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,182,175,177,170,181,187],
[158,0,164,145,156,165,162,156],
[159,177,0,165,151,197,173,177],
[166,196,176,0,174,182,177,187],
[164,185,190,167,0,161,172,181],
[171,176,144,159,180,0,172,156],
[160,179,168,164,169,169,0,187],
[154,185,164,154,160,185,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1449, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,188,146,172,214,192,168],
[168,0,168,166,167,179,184,154],
[153,173,0,140,141,169,167,156],
[195,175,201,0,165,192,157,182],
[169,174,200,176,0,193,196,185],
[127,162,172,149,148,0,163,187],
[149,157,174,184,145,178,0,165],
[173,187,185,159,156,154,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1450, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,161,182,161,180,173,185],
[172,0,178,189,183,194,165,180],
[180,163,0,167,161,173,164,176],
[159,152,174,0,159,166,151,159],
[180,158,180,182,0,176,176,181],
[161,147,168,175,165,0,143,174],
[168,176,177,190,165,198,0,196],
[156,161,165,182,160,167,145,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1451, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,203,186,197,172,205,169,220],
[138,0,170,136,149,150,150,206],
[155,171,0,165,182,193,151,198],
[144,205,176,0,197,223,178,194],
[169,192,159,144,0,188,193,204],
[136,191,148,118,153,0,179,160],
[172,191,190,163,148,162,0,165],
[121,135,143,147,137,181,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1452, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,156,177,161,146,119,161],
[177,0,170,172,174,172,161,162],
[185,171,0,202,175,173,159,164],
[164,169,139,0,160,149,146,158],
[180,167,166,181,0,155,129,173],
[195,169,168,192,186,0,160,169],
[222,180,182,195,212,181,0,168],
[180,179,177,183,168,172,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1453, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,113,166,167,148,158,188,110],
[228,0,219,184,200,198,206,164],
[175,122,0,162,155,198,199,132],
[174,157,179,0,204,145,199,143],
[193,141,186,137,0,142,173,185],
[183,143,143,196,199,0,173,129],
[153,135,142,142,168,168,0,109],
[231,177,209,198,156,212,232,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1454, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,178,162,181,160,171,155],
[155,0,160,144,163,152,168,153],
[163,181,0,161,158,165,166,155],
[179,197,180,0,185,173,173,170],
[160,178,183,156,0,159,170,163],
[181,189,176,168,182,0,184,177],
[170,173,175,168,171,157,0,158],
[186,188,186,171,178,164,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1455, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,123,121,147,170,221,171,172],
[218,0,218,221,191,218,168,195],
[220,123,0,147,168,170,193,219],
[194,120,194,0,167,195,192,219],
[171,150,173,174,0,149,269,246],
[120,123,171,146,192,0,217,220],
[170,173,148,149,72,124,0,173],
[169,146,122,122,95,121,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1456, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,193,179,168,202,182,175],
[156,0,182,187,148,163,176,150],
[148,159,0,170,154,166,158,160],
[162,154,171,0,157,176,168,174],
[173,193,187,184,0,186,170,169],
[139,178,175,165,155,0,178,154],
[159,165,183,173,171,163,0,160],
[166,191,181,167,172,187,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1457, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,172,192,175,173,164,179],
[154,0,142,155,166,148,146,165],
[169,199,0,178,162,164,154,174],
[149,186,163,0,160,152,146,174],
[166,175,179,181,0,167,161,180],
[168,193,177,189,174,0,174,188],
[177,195,187,195,180,167,0,189],
[162,176,167,167,161,153,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1458, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,175,169,180,158,184,178],
[158,0,190,175,179,170,190,188],
[166,151,0,163,183,161,181,177],
[172,166,178,0,179,158,175,177],
[161,162,158,162,0,188,179,174],
[183,171,180,183,153,0,192,195],
[157,151,160,166,162,149,0,158],
[163,153,164,164,167,146,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1459, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,223,187,197,179,156,199,164],
[118,0,132,170,173,156,132,139],
[154,209,0,199,177,159,176,177],
[144,171,142,0,154,134,161,122],
[162,168,164,187,0,190,165,161],
[185,185,182,207,151,0,167,141],
[142,209,165,180,176,174,0,139],
[177,202,164,219,180,200,202,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1460, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,187,182,164,179,161,164],
[177,0,180,172,164,184,161,167],
[154,161,0,174,156,160,169,162],
[159,169,167,0,163,169,159,154],
[177,177,185,178,0,187,183,162],
[162,157,181,172,154,0,153,159],
[180,180,172,182,158,188,0,172],
[177,174,179,187,179,182,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1461, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,174,173,170,168,175,172],
[154,0,162,141,166,153,163,146],
[167,179,0,153,171,167,159,179],
[168,200,188,0,183,173,179,193],
[171,175,170,158,0,177,167,176],
[173,188,174,168,164,0,189,178],
[166,178,182,162,174,152,0,165],
[169,195,162,148,165,163,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1462, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,138,143,151,139,149,187],
[181,0,158,153,186,162,140,180],
[203,183,0,179,180,167,154,206],
[198,188,162,0,223,174,176,186],
[190,155,161,118,0,147,138,181],
[202,179,174,167,194,0,149,187],
[192,201,187,165,203,192,0,214],
[154,161,135,155,160,154,127,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1463, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,176,191,190,131,195,207],
[163,0,134,148,163,119,194,149],
[165,207,0,192,205,177,180,177],
[150,193,149,0,160,177,151,162],
[151,178,136,181,0,105,167,147],
[210,222,164,164,236,0,197,193],
[146,147,161,190,174,144,0,161],
[134,192,164,179,194,148,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1464, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,171,152,165,155,164,170],
[164,0,164,165,173,164,161,167],
[170,177,0,155,170,165,151,158],
[189,176,186,0,169,176,174,171],
[176,168,171,172,0,170,154,173],
[186,177,176,165,171,0,168,176],
[177,180,190,167,187,173,0,174],
[171,174,183,170,168,165,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1465, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,186,171,159,177,169,168],
[171,0,186,197,171,161,180,156],
[155,155,0,170,147,180,180,181],
[170,144,171,0,163,177,180,185],
[182,170,194,178,0,178,186,187],
[164,180,161,164,163,0,162,177],
[172,161,161,161,155,179,0,156],
[173,185,160,156,154,164,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1466, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,175,183,194,198,170,187],
[156,0,157,152,168,170,154,160],
[166,184,0,177,154,169,157,143],
[158,189,164,0,190,173,197,147],
[147,173,187,151,0,151,155,139],
[143,171,172,168,190,0,181,169],
[171,187,184,144,186,160,0,178],
[154,181,198,194,202,172,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1467, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,173,171,168,169,215,201],
[168,0,205,144,165,201,217,198],
[168,136,0,157,192,185,222,190],
[170,197,184,0,153,205,258,183],
[173,176,149,188,0,212,219,172],
[172,140,156,136,129,0,204,138],
[126,124,119,83,122,137,0,137],
[140,143,151,158,169,203,204,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1468, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,211,158,184,80,238,235,131],
[130,0,182,236,104,236,208,182],
[183,159,0,184,158,238,235,131],
[157,105,157,0,104,209,156,130],
[261,237,183,237,0,263,262,156],
[103,105,103,132,78,0,235,103],
[106,133,106,185,79,106,0,79],
[210,159,210,211,185,238,262,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1469, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,160,186,162,187,171,181],
[157,0,151,188,170,184,169,170],
[181,190,0,203,166,188,169,187],
[155,153,138,0,167,176,154,164],
[179,171,175,174,0,175,165,173],
[154,157,153,165,166,0,164,160],
[170,172,172,187,176,177,0,176],
[160,171,154,177,168,181,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1470, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,183,173,166,164,165,180],
[170,0,190,170,184,168,172,170],
[158,151,0,161,162,151,156,155],
[168,171,180,0,179,162,170,170],
[175,157,179,162,0,147,162,153],
[177,173,190,179,194,0,186,165],
[176,169,185,171,179,155,0,167],
[161,171,186,171,188,176,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1471, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,164,185,168,179,176,178],
[149,0,172,176,172,172,172,169],
[177,169,0,172,167,177,166,175],
[156,165,169,0,165,166,165,179],
[173,169,174,176,0,170,176,182],
[162,169,164,175,171,0,162,179],
[165,169,175,176,165,179,0,183],
[163,172,166,162,159,162,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1472, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,169,182,178,166,175,164],
[183,0,176,172,173,169,166,172],
[172,165,0,166,169,165,157,170],
[159,169,175,0,174,179,176,180],
[163,168,172,167,0,169,159,163],
[175,172,176,162,172,0,175,167],
[166,175,184,165,182,166,0,176],
[177,169,171,161,178,174,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1473, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,171,192,176,169,171,185],
[169,0,158,177,182,166,171,186],
[170,183,0,176,179,165,173,165],
[149,164,165,0,163,172,170,177],
[165,159,162,178,0,159,165,173],
[172,175,176,169,182,0,188,183],
[170,170,168,171,176,153,0,178],
[156,155,176,164,168,158,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1474, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,147,148,177,146,168,142],
[186,0,185,155,171,198,158,144],
[194,156,0,173,158,159,163,162],
[193,186,168,0,180,210,160,184],
[164,170,183,161,0,183,159,158],
[195,143,182,131,158,0,155,158],
[173,183,178,181,182,186,0,161],
[199,197,179,157,183,183,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1475, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,170,184,172,177,179,160],
[184,0,184,187,194,160,186,172],
[171,157,0,177,186,170,185,170],
[157,154,164,0,171,154,177,155],
[169,147,155,170,0,155,164,159],
[164,181,171,187,186,0,194,158],
[162,155,156,164,177,147,0,150],
[181,169,171,186,182,183,191,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1476, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,183,166,180,182,177,184],
[176,0,192,182,183,172,168,195],
[158,149,0,159,148,180,154,171],
[175,159,182,0,167,180,178,191],
[161,158,193,174,0,180,184,167],
[159,169,161,161,161,0,153,156],
[164,173,187,163,157,188,0,164],
[157,146,170,150,174,185,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1477, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,182,180,176,173,178,176],
[174,0,178,179,175,169,170,171],
[159,163,0,159,163,157,164,162],
[161,162,182,0,162,174,177,170],
[165,166,178,179,0,169,166,163],
[168,172,184,167,172,0,181,169],
[163,171,177,164,175,160,0,164],
[165,170,179,171,178,172,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1478, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,148,157,172,150,156,160,142],
[193,0,183,173,174,166,175,174],
[184,158,0,177,165,165,164,164],
[169,168,164,0,159,178,150,171],
[191,167,176,182,0,167,153,156],
[185,175,176,163,174,0,164,172],
[181,166,177,191,188,177,0,172],
[199,167,177,170,185,169,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1479, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,164,159,154,167,153,166],
[183,0,179,179,171,176,168,163],
[177,162,0,156,156,175,180,177],
[182,162,185,0,174,182,179,185],
[187,170,185,167,0,171,184,185],
[174,165,166,159,170,0,163,172],
[188,173,161,162,157,178,0,175],
[175,178,164,156,156,169,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1480, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,170,162,175,165,176,150],
[182,0,190,166,180,172,190,174],
[171,151,0,147,152,154,168,152],
[179,175,194,0,183,168,182,168],
[166,161,189,158,0,167,146,162],
[176,169,187,173,174,0,169,154],
[165,151,173,159,195,172,0,155],
[191,167,189,173,179,187,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1481, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,170,163,148,168,163,176],
[182,0,194,182,180,188,154,173],
[171,147,0,154,151,161,145,142],
[178,159,187,0,156,161,157,197],
[193,161,190,185,0,178,177,183],
[173,153,180,180,163,0,144,183],
[178,187,196,184,164,197,0,186],
[165,168,199,144,158,158,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1482, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,150,163,148,170,166,173,138],
[191,0,178,156,178,151,159,150],
[178,163,0,170,159,168,174,158],
[193,185,171,0,177,170,183,159],
[171,163,182,164,0,175,200,175],
[175,190,173,171,166,0,194,161],
[168,182,167,158,141,147,0,146],
[203,191,183,182,166,180,195,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1483, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,152,168,184,175,168,170],
[168,0,177,195,179,191,186,184],
[189,164,0,184,170,192,187,192],
[173,146,157,0,172,173,168,174],
[157,162,171,169,0,184,173,176],
[166,150,149,168,157,0,168,165],
[173,155,154,173,168,173,0,178],
[171,157,149,167,165,176,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1484, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,164,160,156,161,177,161],
[159,0,162,154,159,159,170,149],
[177,179,0,151,169,158,174,166],
[181,187,190,0,165,179,187,176],
[185,182,172,176,0,164,180,177],
[180,182,183,162,177,0,184,169],
[164,171,167,154,161,157,0,148],
[180,192,175,165,164,172,193,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1485, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,149,162,155,146,158,126,160],
[192,0,181,186,178,166,171,166],
[179,160,0,155,174,156,161,154],
[186,155,186,0,175,174,164,164],
[195,163,167,166,0,152,157,167],
[183,175,185,167,189,0,181,176],
[215,170,180,177,184,160,0,161],
[181,175,187,177,174,165,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1486, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,184,173,165,175,183,177],
[165,0,174,165,164,162,170,175],
[157,167,0,160,171,174,179,173],
[168,176,181,0,162,176,191,188],
[176,177,170,179,0,185,176,198],
[166,179,167,165,156,0,175,188],
[158,171,162,150,165,166,0,162],
[164,166,168,153,143,153,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1487, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,160,175,170,153,171,161],
[178,0,170,183,167,158,181,164],
[181,171,0,212,190,193,184,168],
[166,158,129,0,143,141,164,136],
[171,174,151,198,0,177,195,165],
[188,183,148,200,164,0,188,174],
[170,160,157,177,146,153,0,150],
[180,177,173,205,176,167,191,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1488, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,165,176,176,162,161,188],
[174,0,174,171,176,172,167,186],
[176,167,0,171,180,181,161,186],
[165,170,170,0,182,165,165,178],
[165,165,161,159,0,161,178,177],
[179,169,160,176,180,0,179,191],
[180,174,180,176,163,162,0,182],
[153,155,155,163,164,150,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1489, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,188,176,174,157,193,172],
[150,0,161,158,133,143,143,146],
[153,180,0,173,155,159,185,172],
[165,183,168,0,161,165,165,169],
[167,208,186,180,0,173,182,174],
[184,198,182,176,168,0,174,171],
[148,198,156,176,159,167,0,172],
[169,195,169,172,167,170,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1490, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,156,175,189,164,164,173],
[182,0,172,181,169,177,167,179],
[185,169,0,185,187,190,196,168],
[166,160,156,0,167,165,154,169],
[152,172,154,174,0,160,157,167],
[177,164,151,176,181,0,158,155],
[177,174,145,187,184,183,0,175],
[168,162,173,172,174,186,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1491, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,190,195,181,177,170,192],
[171,0,193,177,169,173,170,182],
[151,148,0,176,177,151,171,160],
[146,164,165,0,173,188,171,168],
[160,172,164,168,0,170,166,170],
[164,168,190,153,171,0,180,189],
[171,171,170,170,175,161,0,190],
[149,159,181,173,171,152,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1492, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,197,169,179,187,178,170],
[171,0,187,181,188,165,164,186],
[144,154,0,169,170,163,161,149],
[172,160,172,0,170,166,164,168],
[162,153,171,171,0,148,188,166],
[154,176,178,175,193,0,166,173],
[163,177,180,177,153,175,0,157],
[171,155,192,173,175,168,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1493, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,168,176,163,169,159,163],
[173,0,171,185,166,155,171,170],
[173,170,0,173,169,166,160,164],
[165,156,168,0,170,162,155,158],
[178,175,172,171,0,167,171,177],
[172,186,175,179,174,0,174,170],
[182,170,181,186,170,167,0,180],
[178,171,177,183,164,171,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1494, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,181,174,182,163,180,166],
[172,0,180,158,167,164,175,174],
[160,161,0,169,168,158,158,168],
[167,183,172,0,166,163,167,185],
[159,174,173,175,0,157,165,169],
[178,177,183,178,184,0,158,190],
[161,166,183,174,176,183,0,181],
[175,167,173,156,172,151,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1495, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,181,153,169,160,158,177],
[163,0,153,150,151,186,150,149],
[160,188,0,189,162,184,161,165],
[188,191,152,0,182,160,167,141],
[172,190,179,159,0,191,147,140],
[181,155,157,181,150,0,137,148],
[183,191,180,174,194,204,0,152],
[164,192,176,200,201,193,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1496, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,171,179,149,161,167,166],
[172,0,177,174,166,169,180,169],
[170,164,0,174,158,159,175,178],
[162,167,167,0,174,176,189,153],
[192,175,183,167,0,181,184,152],
[180,172,182,165,160,0,165,172],
[174,161,166,152,157,176,0,167],
[175,172,163,188,189,169,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1497, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,172,182,168,174,177,199],
[163,0,168,173,161,188,172,192],
[169,173,0,170,166,169,169,187],
[159,168,171,0,175,183,183,177],
[173,180,175,166,0,186,177,184],
[167,153,172,158,155,0,163,173],
[164,169,172,158,164,178,0,193],
[142,149,154,164,157,168,148,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1498, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,179,175,167,157,171,167],
[190,0,188,160,170,183,162,173],
[162,153,0,167,156,138,156,155],
[166,181,174,0,162,161,177,179],
[174,171,185,179,0,157,175,161],
[184,158,203,180,184,0,182,186],
[170,179,185,164,166,159,0,184],
[174,168,186,162,180,155,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1499, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,165,181,153,184,170,163],
[159,0,153,203,164,157,193,172],
[176,188,0,202,174,186,169,173],
[160,138,139,0,134,142,170,142],
[188,177,167,207,0,182,192,179],
[157,184,155,199,159,0,183,168],
[171,148,172,171,149,158,0,150],
[178,169,168,199,162,173,191,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1500, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,174,160,178,164,134,178],
[190,0,192,182,187,173,162,192],
[167,149,0,162,165,164,141,168],
[181,159,179,0,178,166,148,169],
[163,154,176,163,0,155,146,175],
[177,168,177,175,186,0,172,191],
[207,179,200,193,195,169,0,196],
[163,149,173,172,166,150,145,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1501, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,173,155,204,193,182,201],
[154,0,180,146,176,181,151,169],
[168,161,0,150,185,165,163,171],
[186,195,191,0,194,193,167,198],
[137,165,156,147,0,159,150,161],
[148,160,176,148,182,0,173,180],
[159,190,178,174,191,168,0,190],
[140,172,170,143,180,161,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1502, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,159,167,167,165,166,182],
[164,0,151,155,159,152,165,164],
[182,190,0,174,164,169,189,183],
[174,186,167,0,179,168,175,182],
[174,182,177,162,0,179,176,190],
[176,189,172,173,162,0,178,187],
[175,176,152,166,165,163,0,171],
[159,177,158,159,151,154,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1503, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,185,179,175,161,184,175],
[159,0,183,167,171,172,182,172],
[156,158,0,152,152,155,150,158],
[162,174,189,0,164,168,171,174],
[166,170,189,177,0,165,180,173],
[180,169,186,173,176,0,179,167],
[157,159,191,170,161,162,0,173],
[166,169,183,167,168,174,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1504, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,162,165,155,156,182,168],
[166,0,173,166,163,157,178,154],
[179,168,0,188,172,201,175,165],
[176,175,153,0,154,186,183,162],
[186,178,169,187,0,194,191,195],
[185,184,140,155,147,0,175,176],
[159,163,166,158,150,166,0,161],
[173,187,176,179,146,165,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1505, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,148,181,175,160,169,168,174],
[193,0,165,165,178,161,202,186],
[160,176,0,167,162,160,187,172],
[166,176,174,0,193,174,154,220],
[181,163,179,148,0,146,181,195],
[172,180,181,167,195,0,191,180],
[173,139,154,187,160,150,0,168],
[167,155,169,121,146,161,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1506, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,143,153,165,153,154,205],
[170,0,165,185,175,171,169,199],
[198,176,0,182,169,171,173,241],
[188,156,159,0,195,173,183,244],
[176,166,172,146,0,167,159,212],
[188,170,170,168,174,0,194,205],
[187,172,168,158,182,147,0,226],
[136,142,100,97,129,136,115,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1507, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,198,204,168,164,147,152,142],
[143,0,178,179,173,144,166,132],
[137,163,0,157,156,149,137,132],
[173,162,184,0,177,151,148,147],
[177,168,185,164,0,152,147,138],
[194,197,192,190,189,0,188,154],
[189,175,204,193,194,153,0,180],
[199,209,209,194,203,187,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1508, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,153,153,150,156,161,164],
[177,0,142,147,169,170,157,160],
[188,199,0,164,186,186,173,180],
[188,194,177,0,173,172,167,178],
[191,172,155,168,0,169,171,167],
[185,171,155,169,172,0,156,167],
[180,184,168,174,170,185,0,177],
[177,181,161,163,174,174,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1509, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,155,136,187,140,222,206],
[170,0,172,187,171,174,206,224],
[186,169,0,135,187,138,239,190],
[205,154,206,0,205,190,223,174],
[154,170,154,136,0,122,239,190],
[201,167,203,151,219,0,238,187],
[119,135,102,118,102,103,0,171],
[135,117,151,167,151,154,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1510, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,172,163,181,170,179,177],
[150,0,167,174,162,173,169,147],
[169,174,0,161,185,170,172,170],
[178,167,180,0,180,166,159,167],
[160,179,156,161,0,187,164,168],
[171,168,171,175,154,0,172,173],
[162,172,169,182,177,169,0,166],
[164,194,171,174,173,168,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1511, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,141,136,143,176,169,155,144],
[200,0,207,170,225,214,207,173],
[205,134,0,170,209,184,173,153],
[198,171,171,0,211,198,174,155],
[165,116,132,130,0,115,131,126],
[172,127,157,143,226,0,176,147],
[186,134,168,167,210,165,0,167],
[197,168,188,186,215,194,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1512, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,164,169,162,172,173,168],
[174,0,179,180,159,174,170,169],
[177,162,0,184,175,190,170,176],
[172,161,157,0,168,165,167,162],
[179,182,166,173,0,187,161,173],
[169,167,151,176,154,0,160,177],
[168,171,171,174,180,181,0,172],
[173,172,165,179,168,164,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1513, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,194,183,148,152,160,218,162],
[147,0,164,153,172,140,152,163],
[158,177,0,155,157,154,185,185],
[193,188,186,0,152,147,184,187],
[189,169,184,189,0,176,195,219],
[181,201,187,194,165,0,182,220],
[123,189,156,157,146,159,0,156],
[179,178,156,154,122,121,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1514, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,179,169,177,176,159,162],
[174,0,177,161,158,169,156,162],
[162,164,0,177,160,178,164,165],
[172,180,164,0,170,175,167,173],
[164,183,181,171,0,175,172,176],
[165,172,163,166,166,0,151,166],
[182,185,177,174,169,190,0,176],
[179,179,176,168,165,175,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1515, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,168,180,166,160,170,165],
[174,0,182,177,171,169,209,186],
[173,159,0,195,170,166,203,167],
[161,164,146,0,142,144,163,128],
[175,170,171,199,0,186,179,171],
[181,172,175,197,155,0,166,182],
[171,132,138,178,162,175,0,177],
[176,155,174,213,170,159,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1516, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,184,180,181,164,157,169],
[160,0,184,167,186,160,185,176],
[157,157,0,162,155,163,145,141],
[161,174,179,0,172,183,166,166],
[160,155,186,169,0,139,148,160],
[177,181,178,158,202,0,179,172],
[184,156,196,175,193,162,0,153],
[172,165,200,175,181,169,188,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1517, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,184,197,162,146,174,168],
[168,0,197,195,160,183,172,176],
[157,144,0,167,148,158,155,167],
[144,146,174,0,145,143,141,174],
[179,181,193,196,0,173,182,168],
[195,158,183,198,168,0,180,181],
[167,169,186,200,159,161,0,164],
[173,165,174,167,173,160,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1518, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,168,174,167,167,157,165],
[169,0,180,172,166,177,162,187],
[173,161,0,166,161,175,154,166],
[167,169,175,0,157,174,157,163],
[174,175,180,184,0,177,166,169],
[174,164,166,167,164,0,159,163],
[184,179,187,184,175,182,0,166],
[176,154,175,178,172,178,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1519, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,177,187,158,164,176,172],
[172,0,174,173,172,164,167,191],
[164,167,0,176,167,171,156,176],
[154,168,165,0,153,158,170,168],
[183,169,174,188,0,168,176,185],
[177,177,170,183,173,0,177,185],
[165,174,185,171,165,164,0,178],
[169,150,165,173,156,156,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1520, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,169,174,173,170,180,173],
[166,0,165,171,173,175,181,166],
[172,176,0,172,161,174,179,160],
[167,170,169,0,176,168,173,173],
[168,168,180,165,0,174,180,166],
[171,166,167,173,167,0,168,157],
[161,160,162,168,161,173,0,175],
[168,175,181,168,175,184,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1521, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,154,172,165,158,179,172],
[170,0,155,173,154,169,172,174],
[187,186,0,186,178,168,187,184],
[169,168,155,0,158,158,164,172],
[176,187,163,183,0,171,184,190],
[183,172,173,183,170,0,183,184],
[162,169,154,177,157,158,0,165],
[169,167,157,169,151,157,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1522, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,165,175,183,193,170,175],
[178,0,155,179,190,173,161,174],
[176,186,0,170,198,176,176,177],
[166,162,171,0,179,172,167,160],
[158,151,143,162,0,163,153,156],
[148,168,165,169,178,0,169,162],
[171,180,165,174,188,172,0,176],
[166,167,164,181,185,179,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1523, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,105,132,182,208,158,132,133],
[236,0,185,209,232,236,211,158],
[209,156,0,208,288,185,185,184],
[159,132,133,0,260,211,213,160],
[133,109,53,81,0,157,107,161],
[183,105,156,130,184,0,210,210],
[209,130,156,128,234,131,0,235],
[208,183,157,181,180,131,106,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1524, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,184,170,179,176,167,179],
[166,0,187,176,172,178,180,167],
[157,154,0,166,157,170,156,154],
[171,165,175,0,182,159,169,178],
[162,169,184,159,0,167,165,169],
[165,163,171,182,174,0,168,173],
[174,161,185,172,176,173,0,177],
[162,174,187,163,172,168,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1525, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,192,180,196,181,185,170],
[183,0,176,182,190,168,180,166],
[149,165,0,172,186,152,178,155],
[161,159,169,0,196,152,163,161],
[145,151,155,145,0,145,164,151],
[160,173,189,189,196,0,187,176],
[156,161,163,178,177,154,0,151],
[171,175,186,180,190,165,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1526, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,170,179,183,195,196,212],
[152,0,142,138,188,187,129,172],
[171,199,0,181,200,160,191,190],
[162,203,160,0,176,178,185,170],
[158,153,141,165,0,201,172,157],
[146,154,181,163,140,0,145,193],
[145,212,150,156,169,196,0,203],
[129,169,151,171,184,148,138,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1527, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,203,187,203,181,185,170,212],
[138,0,173,170,156,186,168,185],
[154,168,0,190,145,169,167,146],
[138,171,151,0,151,173,127,176],
[160,185,196,190,0,173,188,206],
[156,155,172,168,168,0,152,151],
[171,173,174,214,153,189,0,195],
[129,156,195,165,135,190,146,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1528, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,185,156,227,189,220,193],
[168,0,177,176,203,183,189,191],
[156,164,0,161,202,184,173,178],
[185,165,180,0,180,183,186,202],
[114,138,139,161,0,136,155,149],
[152,158,157,158,205,0,172,168],
[121,152,168,155,186,169,0,156],
[148,150,163,139,192,173,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1529, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,179,180,167,177,166,157],
[177,0,180,162,174,174,161,176],
[162,161,0,167,153,165,170,148],
[161,179,174,0,160,178,163,161],
[174,167,188,181,0,193,174,167],
[164,167,176,163,148,0,172,146],
[175,180,171,178,167,169,0,159],
[184,165,193,180,174,195,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1530, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,155,161,151,169,154,166],
[177,0,168,161,174,161,161,169],
[186,173,0,168,178,166,167,171],
[180,180,173,0,168,179,169,165],
[190,167,163,173,0,183,174,176],
[172,180,175,162,158,0,169,161],
[187,180,174,172,167,172,0,173],
[175,172,170,176,165,180,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1531, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,162,152,160,153,162,158],
[180,0,181,165,164,170,171,165],
[179,160,0,161,162,154,160,151],
[189,176,180,0,170,172,162,166],
[181,177,179,171,0,178,156,153],
[188,171,187,169,163,0,156,162],
[179,170,181,179,185,185,0,179],
[183,176,190,175,188,179,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1532, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,167,155,197,158,183,165],
[187,0,163,166,186,162,169,158],
[174,178,0,173,177,163,193,159],
[186,175,168,0,171,169,166,145],
[144,155,164,170,0,160,159,148],
[183,179,178,172,181,0,170,176],
[158,172,148,175,182,171,0,155],
[176,183,182,196,193,165,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1533, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,152,147,144,172,154,158],
[184,0,167,193,145,174,191,182],
[189,174,0,191,134,179,166,174],
[194,148,150,0,137,158,154,145],
[197,196,207,204,0,170,189,187],
[169,167,162,183,171,0,178,160],
[187,150,175,187,152,163,0,191],
[183,159,167,196,154,181,150,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1534, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,152,164,182,166,165,175],
[174,0,165,171,178,178,182,167],
[189,176,0,163,167,168,176,181],
[177,170,178,0,178,186,172,185],
[159,163,174,163,0,170,173,181],
[175,163,173,155,171,0,172,163],
[176,159,165,169,168,169,0,177],
[166,174,160,156,160,178,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1535, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,225,169,182,184,194,176,174],
[116,0,159,181,177,165,159,180],
[172,182,0,159,202,149,194,179],
[159,160,182,0,174,174,161,160],
[157,164,139,167,0,178,155,174],
[147,176,192,167,163,0,149,163],
[165,182,147,180,186,192,0,204],
[167,161,162,181,167,178,137,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1536, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,175,166,194,180,163,169],
[160,0,187,179,196,183,180,176],
[166,154,0,172,184,190,164,177],
[175,162,169,0,198,182,167,172],
[147,145,157,143,0,173,152,162],
[161,158,151,159,168,0,158,165],
[178,161,177,174,189,183,0,170],
[172,165,164,169,179,176,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1537, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,218,250,219,189,124,220,158],
[123,0,190,94,121,60,64,153],
[91,151,0,155,121,120,155,121],
[122,247,186,0,156,217,185,152],
[152,220,220,185,0,124,186,186],
[217,281,221,124,217,0,188,247],
[121,277,186,156,155,153,0,155],
[183,188,220,189,155,94,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1538, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,181,185,181,187,170,182],
[186,0,164,169,193,181,163,172],
[160,177,0,158,181,181,171,154],
[156,172,183,0,178,159,163,169],
[160,148,160,163,0,167,166,148],
[154,160,160,182,174,0,173,157],
[171,178,170,178,175,168,0,174],
[159,169,187,172,193,184,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1539, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,185,154,187,199,171,169],
[153,0,169,153,138,168,187,139],
[156,172,0,156,154,169,187,171],
[187,188,185,0,110,171,156,203],
[154,203,187,231,0,187,219,248],
[142,173,172,170,154,0,171,168],
[170,154,154,185,122,170,0,185],
[172,202,170,138,93,173,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1540, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,205,183,180,175,195,164,181],
[136,0,154,166,174,185,134,168],
[158,187,0,175,170,189,165,175],
[161,175,166,0,170,170,144,175],
[166,167,171,171,0,178,173,177],
[146,156,152,171,163,0,142,160],
[177,207,176,197,168,199,0,171],
[160,173,166,166,164,181,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1541, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,168,161,151,162,150,156],
[167,0,169,162,162,162,179,158],
[173,172,0,170,167,172,162,166],
[180,179,171,0,165,168,181,167],
[190,179,174,176,0,169,187,177],
[179,179,169,173,172,0,172,168],
[191,162,179,160,154,169,0,156],
[185,183,175,174,164,173,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1542, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,156,161,179,155,178,165],
[173,0,171,169,171,160,169,174],
[185,170,0,171,166,167,170,179],
[180,172,170,0,174,157,182,168],
[162,170,175,167,0,159,187,165],
[186,181,174,184,182,0,184,165],
[163,172,171,159,154,157,0,158],
[176,167,162,173,176,176,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1543, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,198,171,189,188,165,161,181],
[143,0,149,150,179,147,159,155],
[170,192,0,181,172,172,173,189],
[152,191,160,0,177,171,152,170],
[153,162,169,164,0,164,165,163],
[176,194,169,170,177,0,183,198],
[180,182,168,189,176,158,0,195],
[160,186,152,171,178,143,146,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1544, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,182,167,163,182,156,171],
[168,0,186,165,177,180,178,179],
[159,155,0,162,157,173,159,186],
[174,176,179,0,152,188,176,174],
[178,164,184,189,0,184,163,183],
[159,161,168,153,157,0,167,160],
[185,163,182,165,178,174,0,174],
[170,162,155,167,158,181,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1545, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,194,190,169,168,186,178,181],
[147,0,165,154,136,158,148,154],
[151,176,0,159,148,153,152,154],
[172,187,182,0,160,174,175,164],
[173,205,193,181,0,190,189,158],
[155,183,188,167,151,0,170,157],
[163,193,189,166,152,171,0,169],
[160,187,187,177,183,184,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1546, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,128,152,157,138,151,188],
[175,0,177,174,202,186,164,228],
[213,164,0,177,189,189,217,149],
[189,167,164,0,143,186,179,163],
[184,139,152,198,0,223,175,187],
[203,155,152,155,118,0,168,178],
[190,177,124,162,166,173,0,140],
[153,113,192,178,154,163,201,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1547, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,154,173,166,162,151,168],
[176,0,165,143,168,199,151,176],
[187,176,0,173,186,167,182,170],
[168,198,168,0,189,185,174,181],
[175,173,155,152,0,169,165,165],
[179,142,174,156,172,0,173,173],
[190,190,159,167,176,168,0,172],
[173,165,171,160,176,168,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1548, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,180,174,148,209,191,160],
[164,0,169,204,146,185,159,151],
[161,172,0,171,156,168,152,174],
[167,137,170,0,164,175,146,161],
[193,195,185,177,0,202,169,172],
[132,156,173,166,139,0,163,169],
[150,182,189,195,172,178,0,181],
[181,190,167,180,169,172,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1549, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,182,184,171,192,156,163],
[168,0,174,176,164,175,158,153],
[159,167,0,178,175,170,161,159],
[157,165,163,0,160,177,154,152],
[170,177,166,181,0,169,173,171],
[149,166,171,164,172,0,160,161],
[185,183,180,187,168,181,0,167],
[178,188,182,189,170,180,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1550, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,163,166,168,181,170,164],
[187,0,186,163,168,185,172,179],
[178,155,0,163,177,177,164,179],
[175,178,178,0,172,167,196,207],
[173,173,164,169,0,159,174,178],
[160,156,164,174,182,0,184,172],
[171,169,177,145,167,157,0,171],
[177,162,162,134,163,169,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1551, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,146,184,180,174,184,169],
[188,0,178,179,198,197,180,166],
[195,163,0,186,188,167,188,170],
[157,162,155,0,169,153,172,144],
[161,143,153,172,0,164,157,169],
[167,144,174,188,177,0,181,181],
[157,161,153,169,184,160,0,145],
[172,175,171,197,172,160,196,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1552, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,132,140,125,156,147,170,147],
[209,0,180,151,172,173,197,160],
[201,161,0,162,149,149,160,157],
[216,190,179,0,184,159,169,190],
[185,169,192,157,0,153,180,177],
[194,168,192,182,188,0,187,173],
[171,144,181,172,161,154,0,187],
[194,181,184,151,164,168,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1553, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,161,164,145,173,184,138],
[177,0,159,168,182,194,176,134],
[180,182,0,151,144,176,176,150],
[177,173,190,0,128,177,179,166],
[196,159,197,213,0,189,179,172],
[168,147,165,164,152,0,169,143],
[157,165,165,162,162,172,0,100],
[203,207,191,175,169,198,241,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1554, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,148,182,151,172,193,162,199],
[193,0,188,176,184,183,164,194],
[159,153,0,183,178,191,173,188],
[190,165,158,0,174,205,167,207],
[169,157,163,167,0,195,161,181],
[148,158,150,136,146,0,161,181],
[179,177,168,174,180,180,0,179],
[142,147,153,134,160,160,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1555, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,160,169,167,151,162,163],
[185,0,158,168,154,164,156,161],
[181,183,0,193,163,172,171,164],
[172,173,148,0,166,155,147,158],
[174,187,178,175,0,170,161,157],
[190,177,169,186,171,0,167,173],
[179,185,170,194,180,174,0,170],
[178,180,177,183,184,168,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1556, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,149,161,168,158,139,173,169],
[192,0,186,168,152,158,168,176],
[180,155,0,180,170,179,163,173],
[173,173,161,0,173,153,139,160],
[183,189,171,168,0,164,156,178],
[202,183,162,188,177,0,180,187],
[168,173,178,202,185,161,0,190],
[172,165,168,181,163,154,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1557, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,187,177,192,182,166,185],
[172,0,178,168,199,186,161,177],
[154,163,0,154,183,158,158,159],
[164,173,187,0,184,181,156,167],
[149,142,158,157,0,153,149,148],
[159,155,183,160,188,0,161,169],
[175,180,183,185,192,180,0,168],
[156,164,182,174,193,172,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1558, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,182,190,196,189,165,173],
[170,0,174,181,219,178,174,181],
[159,167,0,192,204,186,173,159],
[151,160,149,0,185,178,176,155],
[145,122,137,156,0,132,143,125],
[152,163,155,163,209,0,175,147],
[176,167,168,165,198,166,0,161],
[168,160,182,186,216,194,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1559, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,181,168,160,161,167,176],
[172,0,150,165,127,179,174,184],
[160,191,0,201,174,216,190,211],
[173,176,140,0,181,226,165,214],
[181,214,167,160,0,220,192,210],
[180,162,125,115,121,0,170,167],
[174,167,151,176,149,171,0,194],
[165,157,130,127,131,174,147,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1560, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,228,141,154,183,218,109,139],
[113,0,94,110,109,144,98,95],
[200,247,0,202,154,189,174,188],
[187,231,139,0,200,142,126,172],
[158,232,187,141,0,187,141,174],
[123,197,152,199,154,0,124,170],
[232,243,167,215,200,217,0,216],
[202,246,153,169,167,171,125,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1561, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,177,160,187,177,176,167],
[167,0,182,166,176,173,164,168],
[164,159,0,162,165,183,153,170],
[181,175,179,0,182,172,169,166],
[154,165,176,159,0,176,170,164],
[164,168,158,169,165,0,181,168],
[165,177,188,172,171,160,0,176],
[174,173,171,175,177,173,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1562, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,176,175,212,179,190,183],
[175,0,152,184,219,147,201,194],
[165,189,0,146,187,170,172,142],
[166,157,195,0,177,167,156,177],
[129,122,154,164,0,156,222,174],
[162,194,171,174,185,0,179,219],
[151,140,169,185,119,162,0,161],
[158,147,199,164,167,122,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1563, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,93,124,93,125,122,125,155],
[248,0,60,123,123,123,155,151],
[217,281,0,216,249,155,249,214],
[248,218,125,0,154,154,249,153],
[216,218,92,187,0,216,281,152],
[219,218,186,187,125,0,249,184],
[216,186,92,92,60,92,0,120],
[186,190,127,188,189,157,221,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1564, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,166,179,160,157,171,167],
[182,0,181,171,173,174,178,170],
[175,160,0,164,164,166,167,167],
[162,170,177,0,165,179,180,176],
[181,168,177,176,0,174,172,175],
[184,167,175,162,167,0,165,166],
[170,163,174,161,169,176,0,163],
[174,171,174,165,166,175,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1565, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,145,152,140,153,154,146,156],
[196,0,186,167,167,161,175,175],
[189,155,0,180,181,169,159,183],
[201,174,161,0,165,171,168,193],
[188,174,160,176,0,142,165,191],
[187,180,172,170,199,0,169,189],
[195,166,182,173,176,172,0,187],
[185,166,158,148,150,152,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1566, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,166,188,179,168,189,184],
[158,0,156,179,156,174,172,170],
[175,185,0,175,173,196,186,165],
[153,162,166,0,169,163,176,166],
[162,185,168,172,0,157,187,173],
[173,167,145,178,184,0,172,162],
[152,169,155,165,154,169,0,166],
[157,171,176,175,168,179,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1567, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,178,155,182,187,176,185],
[172,0,178,157,177,201,191,182],
[163,163,0,167,171,184,172,189],
[186,184,174,0,189,188,193,168],
[159,164,170,152,0,165,162,165],
[154,140,157,153,176,0,161,173],
[165,150,169,148,179,180,0,167],
[156,159,152,173,176,168,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1568, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,156,185,182,173,180,197],
[159,0,150,170,160,178,148,175],
[185,191,0,197,177,197,166,188],
[156,171,144,0,157,161,153,168],
[159,181,164,184,0,184,162,180],
[168,163,144,180,157,0,160,179],
[161,193,175,188,179,181,0,198],
[144,166,153,173,161,162,143,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1569, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,167,140,161,154,171,137],
[188,0,159,184,168,147,184,205],
[174,182,0,161,199,160,184,195],
[201,157,180,0,174,160,196,190],
[180,173,142,167,0,179,183,167],
[187,194,181,181,162,0,173,183],
[170,157,157,145,158,168,0,157],
[204,136,146,151,174,158,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1570, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,167,189,158,176,206,179],
[154,0,170,166,171,175,187,172],
[174,171,0,188,183,183,203,163],
[152,175,153,0,154,164,171,160],
[183,170,158,187,0,179,195,144],
[165,166,158,177,162,0,198,143],
[135,154,138,170,146,143,0,158],
[162,169,178,181,197,198,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1571, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,156,153,151,158,158,157],
[177,0,168,173,163,171,178,177],
[185,173,0,172,164,175,187,173],
[188,168,169,0,175,180,170,182],
[190,178,177,166,0,182,174,170],
[183,170,166,161,159,0,171,175],
[183,163,154,171,167,170,0,167],
[184,164,168,159,171,166,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1572, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,180,166,170,150,158,159],
[183,0,181,169,174,166,180,172],
[161,160,0,164,158,161,164,180],
[175,172,177,0,162,172,177,186],
[171,167,183,179,0,173,167,179],
[191,175,180,169,168,0,177,171],
[183,161,177,164,174,164,0,174],
[182,169,161,155,162,170,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1573, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,194,163,172,160,161,183],
[149,0,178,169,167,160,141,154],
[147,163,0,131,151,149,125,152],
[178,172,210,0,175,157,177,177],
[169,174,190,166,0,164,148,155],
[181,181,192,184,177,0,168,165],
[180,200,216,164,193,173,0,186],
[158,187,189,164,186,176,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1574, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,183,182,176,188,175,167],
[174,0,175,179,163,171,175,170],
[158,166,0,182,169,165,175,170],
[159,162,159,0,153,171,172,160],
[165,178,172,188,0,191,185,185],
[153,170,176,170,150,0,167,166],
[166,166,166,169,156,174,0,169],
[174,171,171,181,156,175,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1575, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,146,179,190,177,149,136,154],
[195,0,176,178,196,175,149,195],
[162,165,0,167,178,170,137,176],
[151,163,174,0,194,159,174,165],
[164,145,163,147,0,162,171,195],
[192,166,171,182,179,0,148,179],
[205,192,204,167,170,193,0,184],
[187,146,165,176,146,162,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1576, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,144,148,166,183,159,172,169],
[197,0,171,190,188,166,228,191],
[193,170,0,185,203,185,216,212],
[175,151,156,0,188,160,179,190],
[158,153,138,153,0,152,171,158],
[182,175,156,181,189,0,203,171],
[169,113,125,162,170,138,0,161],
[172,150,129,151,183,170,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1577, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,180,155,189,172,156,165],
[167,0,190,167,198,187,165,183],
[161,151,0,169,190,151,169,166],
[186,174,172,0,196,174,174,148],
[152,143,151,145,0,156,148,149],
[169,154,190,167,185,0,176,158],
[185,176,172,167,193,165,0,176],
[176,158,175,193,192,183,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1578, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,139,165,171,161,167,152,198],
[202,0,174,181,159,192,179,194],
[176,167,0,176,161,173,173,197],
[170,160,165,0,152,173,173,197],
[180,182,180,189,0,188,167,192],
[174,149,168,168,153,0,159,196],
[189,162,168,168,174,182,0,186],
[143,147,144,144,149,145,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1579, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,171,168,180,163,160,169],
[178,0,171,156,186,173,177,167],
[170,170,0,184,189,164,175,177],
[173,185,157,0,183,161,169,174],
[161,155,152,158,0,170,168,161],
[178,168,177,180,171,0,185,165],
[181,164,166,172,173,156,0,164],
[172,174,164,167,180,176,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1580, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,193,171,170,171,173,168,168],
[148,0,153,165,157,155,167,138],
[170,188,0,182,168,168,194,170],
[171,176,159,0,162,156,167,153],
[170,184,173,179,0,164,179,169],
[168,186,173,185,177,0,176,189],
[173,174,147,174,162,165,0,152],
[173,203,171,188,172,152,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1581, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,243,245,196,149,196,149,196],
[98,0,198,149,198,145,149,145],
[96,143,0,196,49,96,98,96],
[145,192,145,0,98,145,98,145],
[192,143,292,243,0,192,243,143],
[145,196,245,196,149,0,245,147],
[192,192,243,243,98,96,0,143],
[145,196,245,196,198,194,198,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1582, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,158,178,171,184,181,171],
[169,0,143,170,155,201,190,170],
[183,198,0,179,157,201,209,191],
[163,171,162,0,143,185,188,184],
[170,186,184,198,0,222,201,175],
[157,140,140,156,119,0,150,145],
[160,151,132,153,140,191,0,154],
[170,171,150,157,166,196,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1583, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,205,205,136,205,137,272,205],
[136,0,204,203,272,204,272,68],
[136,137,0,135,137,67,272,68],
[205,138,206,0,138,138,272,69],
[136,69,204,203,0,136,272,137],
[204,137,274,203,205,0,272,68],
[69,69,69,69,69,69,0,69],
[136,273,273,272,204,273,272,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1584, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,182,170,200,177,192,179],
[166,0,162,152,193,193,157,176],
[159,179,0,164,201,165,167,181],
[171,189,177,0,187,164,187,188],
[141,148,140,154,0,162,154,150],
[164,148,176,177,179,0,167,173],
[149,184,174,154,187,174,0,160],
[162,165,160,153,191,168,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1585, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,129,195,154,161,163,160],
[173,0,176,191,174,158,142,188],
[212,165,0,192,181,161,177,180],
[146,150,149,0,142,153,134,169],
[187,167,160,199,0,164,178,189],
[180,183,180,188,177,0,163,188],
[178,199,164,207,163,178,0,179],
[181,153,161,172,152,153,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1586, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,169,158,167,171,164,172],
[173,0,175,175,169,176,175,183],
[172,166,0,165,170,165,158,166],
[183,166,176,0,181,178,176,176],
[174,172,171,160,0,175,175,186],
[170,165,176,163,166,0,163,178],
[177,166,183,165,166,178,0,181],
[169,158,175,165,155,163,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1587, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,110,109,158,110,147,130],
[183,0,150,125,170,138,85,136],
[231,191,0,157,228,151,177,146],
[232,216,184,0,219,162,179,182],
[183,171,113,122,0,89,138,134],
[231,203,190,179,252,0,204,168],
[194,256,164,162,203,137,0,146],
[211,205,195,159,207,173,195,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1588, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,161,160,157,162,163,157],
[186,0,162,180,179,172,173,172],
[180,179,0,159,189,159,162,164],
[181,161,182,0,174,159,180,161],
[184,162,152,167,0,171,152,155],
[179,169,182,182,170,0,180,162],
[178,168,179,161,189,161,0,154],
[184,169,177,180,186,179,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1589, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,184,182,202,201,202,147],
[150,0,130,153,162,130,167,130],
[157,211,0,190,193,193,221,178],
[159,188,151,0,210,155,184,163],
[139,179,148,131,0,152,159,135],
[140,211,148,186,189,0,162,147],
[139,174,120,157,182,179,0,137],
[194,211,163,178,206,194,204,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1590, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,191,185,182,178,157,156],
[165,0,177,176,186,183,165,178],
[150,164,0,165,154,156,141,146],
[156,165,176,0,167,168,164,162],
[159,155,187,174,0,172,167,169],
[163,158,185,173,169,0,170,152],
[184,176,200,177,174,171,0,167],
[185,163,195,179,172,189,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1591, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,167,178,172,190,192,177],
[179,0,164,173,169,179,179,163],
[174,177,0,175,157,178,181,171],
[163,168,166,0,176,165,174,163],
[169,172,184,165,0,171,184,177],
[151,162,163,176,170,0,165,164],
[149,162,160,167,157,176,0,165],
[164,178,170,178,164,177,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1592, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,179,173,170,169,180,175],
[158,0,168,180,167,160,162,159],
[162,173,0,171,173,163,176,170],
[168,161,170,0,173,155,175,161],
[171,174,168,168,0,154,181,167],
[172,181,178,186,187,0,187,170],
[161,179,165,166,160,154,0,158],
[166,182,171,180,174,171,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1593, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,174,152,168,164,164,173],
[188,0,191,169,174,182,184,182],
[167,150,0,162,142,167,175,154],
[189,172,179,0,150,176,191,168],
[173,167,199,191,0,183,186,189],
[177,159,174,165,158,0,184,176],
[177,157,166,150,155,157,0,154],
[168,159,187,173,152,165,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1594, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,187,181,166,187,177,189],
[163,0,178,164,184,186,164,170],
[154,163,0,148,168,160,158,158],
[160,177,193,0,186,173,173,173],
[175,157,173,155,0,168,173,160],
[154,155,181,168,173,0,173,173],
[164,177,183,168,168,168,0,176],
[152,171,183,168,181,168,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1595, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,189,171,172,190,205,192],
[173,0,199,179,170,217,193,195],
[152,142,0,144,154,170,164,188],
[170,162,197,0,187,202,193,223],
[169,171,187,154,0,207,176,174],
[151,124,171,139,134,0,153,200],
[136,148,177,148,165,188,0,200],
[149,146,153,118,167,141,141,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1596, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,188,175,188,196,178,168],
[164,0,176,179,162,184,173,151],
[153,165,0,155,140,157,172,129],
[166,162,186,0,163,165,183,141],
[153,179,201,178,0,203,200,174],
[145,157,184,176,138,0,179,164],
[163,168,169,158,141,162,0,165],
[173,190,212,200,167,177,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1597, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,149,130,164,188,196,161,175],
[192,0,153,171,208,167,145,172],
[211,188,0,181,227,194,160,178],
[177,170,160,0,187,169,173,153],
[153,133,114,154,0,160,152,115],
[145,174,147,172,181,0,127,161],
[180,196,181,168,189,214,0,201],
[166,169,163,188,226,180,140,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1598, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,153,151,190,151,190,114],
[190,0,77,114,152,190,115,152],
[188,264,0,226,190,189,114,189],
[190,227,115,0,190,266,115,228],
[151,189,151,151,0,151,76,227],
[190,151,152,75,190,0,113,151],
[151,226,227,226,265,228,0,265],
[227,189,152,113,114,190,76,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1599, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,175,186,154,183,161,149],
[167,0,167,186,154,168,176,172],
[166,174,0,183,167,171,168,145],
[155,155,158,0,149,160,163,134],
[187,187,174,192,0,196,182,159],
[158,173,170,181,145,0,165,133],
[180,165,173,178,159,176,0,151],
[192,169,196,207,182,208,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1600, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,170,180,168,184,175,167],
[161,0,153,167,164,166,163,167],
[171,188,0,176,168,178,173,182],
[161,174,165,0,175,178,169,164],
[173,177,173,166,0,187,173,174],
[157,175,163,163,154,0,163,171],
[166,178,168,172,168,178,0,186],
[174,174,159,177,167,170,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1601, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,175,181,174,181,160,194],
[166,0,166,171,163,172,154,177],
[166,175,0,167,162,168,160,183],
[160,170,174,0,163,178,145,174],
[167,178,179,178,0,177,179,177],
[160,169,173,163,164,0,156,169],
[181,187,181,196,162,185,0,208],
[147,164,158,167,164,172,133,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1602, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,151,173,159,177,149,165],
[173,0,150,161,171,193,164,168],
[190,191,0,158,187,198,181,179],
[168,180,183,0,186,179,174,168],
[182,170,154,155,0,197,161,163],
[164,148,143,162,144,0,140,175],
[192,177,160,167,180,201,0,194],
[176,173,162,173,178,166,147,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1603, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,201,185,187,176,191,175,170],
[140,0,143,154,156,153,152,145],
[156,198,0,156,167,179,161,149],
[154,187,185,0,160,173,163,155],
[165,185,174,181,0,191,178,172],
[150,188,162,168,150,0,183,154],
[166,189,180,178,163,158,0,152],
[171,196,192,186,169,187,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1604, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,140,163,170,164,169,169,152],
[201,0,169,184,186,186,187,179],
[178,172,0,165,170,165,173,154],
[171,157,176,0,179,164,167,166],
[177,155,171,162,0,163,180,163],
[172,155,176,177,178,0,159,172],
[172,154,168,174,161,182,0,183],
[189,162,187,175,178,169,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1605, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,166,138,187,194,173,141],
[174,0,170,175,191,189,178,171],
[175,171,0,143,193,186,173,149],
[203,166,198,0,220,182,194,179],
[154,150,148,121,0,156,161,136],
[147,152,155,159,185,0,172,138],
[168,163,168,147,180,169,0,166],
[200,170,192,162,205,203,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1606, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,177,170,173,187,167,185],
[155,0,187,163,154,180,154,156],
[164,154,0,158,140,177,159,157],
[171,178,183,0,167,180,175,167],
[168,187,201,174,0,183,167,173],
[154,161,164,161,158,0,149,162],
[174,187,182,166,174,192,0,176],
[156,185,184,174,168,179,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1607, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,170,173,174,149,154,158],
[167,0,166,160,164,139,163,148],
[171,175,0,166,179,163,173,177],
[168,181,175,0,196,166,162,184],
[167,177,162,145,0,148,156,168],
[192,202,178,175,193,0,168,176],
[187,178,168,179,185,173,0,170],
[183,193,164,157,173,165,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1608, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,168,158,168,171,151,176],
[158,0,167,160,176,167,162,160],
[173,174,0,171,162,176,172,174],
[183,181,170,0,184,174,169,171],
[173,165,179,157,0,173,165,163],
[170,174,165,167,168,0,163,173],
[190,179,169,172,176,178,0,181],
[165,181,167,170,178,168,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1609, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,174,181,188,184,182,165],
[156,0,171,174,184,170,165,145],
[167,170,0,180,163,172,183,146],
[160,167,161,0,178,157,175,149],
[153,157,178,163,0,167,171,169],
[157,171,169,184,174,0,165,161],
[159,176,158,166,170,176,0,180],
[176,196,195,192,172,180,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1610, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,161,167,163,161,172,166],
[173,0,166,179,162,175,172,173],
[180,175,0,182,169,159,177,167],
[174,162,159,0,170,155,155,166],
[178,179,172,171,0,177,166,179],
[180,166,182,186,164,0,176,177],
[169,169,164,186,175,165,0,176],
[175,168,174,175,162,164,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1611, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,217,188,178,163,193,166,195],
[124,0,145,141,125,170,142,172],
[153,196,0,174,153,194,202,173],
[163,200,167,0,177,188,168,199],
[178,216,188,164,0,188,192,196],
[148,171,147,153,153,0,156,179],
[175,199,139,173,149,185,0,168],
[146,169,168,142,145,162,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1612, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,170,190,146,161,176,161],
[186,0,187,180,185,167,162,185],
[171,154,0,167,152,157,151,161],
[151,161,174,0,147,164,157,162],
[195,156,189,194,0,183,174,175],
[180,174,184,177,158,0,172,157],
[165,179,190,184,167,169,0,173],
[180,156,180,179,166,184,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1613, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,180,183,194,125,178,161],
[162,0,154,174,176,134,176,151],
[161,187,0,184,159,171,197,136],
[158,167,157,0,176,129,178,156],
[147,165,182,165,0,161,172,157],
[216,207,170,212,180,0,182,184],
[163,165,144,163,169,159,0,153],
[180,190,205,185,184,157,188,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1614, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,182,191,166,185,172,167],
[177,0,172,171,163,163,181,160],
[159,169,0,177,180,179,182,157],
[150,170,164,0,149,175,168,149],
[175,178,161,192,0,172,180,173],
[156,178,162,166,169,0,176,160],
[169,160,159,173,161,165,0,178],
[174,181,184,192,168,181,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1615, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,163,167,152,140,169,176],
[187,0,165,187,154,172,186,193],
[178,176,0,193,166,157,176,188],
[174,154,148,0,152,160,175,196],
[189,187,175,189,0,165,181,196],
[201,169,184,181,176,0,171,218],
[172,155,165,166,160,170,0,174],
[165,148,153,145,145,123,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1616, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,179,175,190,160,156,166],
[172,0,175,177,186,195,176,153],
[162,166,0,181,159,176,157,168],
[166,164,160,0,155,172,144,161],
[151,155,182,186,0,168,144,147],
[181,146,165,169,173,0,149,164],
[185,165,184,197,197,192,0,174],
[175,188,173,180,194,177,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1617, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,187,171,168,161,193,196],
[168,0,179,169,175,168,172,191],
[154,162,0,164,151,170,180,187],
[170,172,177,0,171,186,189,188],
[173,166,190,170,0,175,186,186],
[180,173,171,155,166,0,181,183],
[148,169,161,152,155,160,0,154],
[145,150,154,153,155,158,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1618, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,161,168,168,181,160,167],
[168,0,174,182,175,190,176,178],
[180,167,0,172,163,174,163,159],
[173,159,169,0,164,177,162,157],
[173,166,178,177,0,180,178,162],
[160,151,167,164,161,0,174,148],
[181,165,178,179,163,167,0,156],
[174,163,182,184,179,193,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1619, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,176,177,180,148,161,175],
[179,0,178,188,185,168,174,171],
[165,163,0,169,185,156,175,158],
[164,153,172,0,182,160,158,173],
[161,156,156,159,0,171,155,165],
[193,173,185,181,170,0,173,153],
[180,167,166,183,186,168,0,154],
[166,170,183,168,176,188,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1620, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,122,144,159,176,157,153,164],
[219,0,191,205,139,213,197,180],
[197,150,0,195,188,187,184,178],
[182,136,146,0,167,163,189,184],
[165,202,153,174,0,179,179,174],
[184,128,154,178,162,0,165,170],
[188,144,157,152,162,176,0,160],
[177,161,163,157,167,171,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1621, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,149,182,169,182,213,162],
[177,0,155,168,178,185,202,151],
[192,186,0,189,197,189,201,163],
[159,173,152,0,154,155,191,166],
[172,163,144,187,0,178,200,172],
[159,156,152,186,163,0,213,168],
[128,139,140,150,141,128,0,138],
[179,190,178,175,169,173,203,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1622, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,193,180,167,170,188,173],
[154,0,167,154,146,153,167,155],
[148,174,0,151,151,151,172,152],
[161,187,190,0,176,173,185,166],
[174,195,190,165,0,180,176,175],
[171,188,190,168,161,0,182,155],
[153,174,169,156,165,159,0,157],
[168,186,189,175,166,186,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1623, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,172,170,168,161,159,164],
[164,0,167,164,167,159,158,150],
[169,174,0,170,164,165,155,165],
[171,177,171,0,177,173,169,156],
[173,174,177,164,0,166,165,176],
[180,182,176,168,175,0,177,172],
[182,183,186,172,176,164,0,164],
[177,191,176,185,165,169,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1624, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,141,189,193,190,177,215,158],
[200,0,202,195,215,159,243,206],
[152,139,0,144,192,160,194,124],
[148,146,197,0,211,206,200,180],
[151,126,149,130,0,160,178,128],
[164,182,181,135,181,0,179,159],
[126,98,147,141,163,162,0,135],
[183,135,217,161,213,182,206,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1625, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,165,192,173,164,183,178],
[169,0,174,183,158,171,180,174],
[176,167,0,180,170,178,170,185],
[149,158,161,0,159,166,160,146],
[168,183,171,182,0,168,173,160],
[177,170,163,175,173,0,162,184],
[158,161,171,181,168,179,0,180],
[163,167,156,195,181,157,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1626, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,200,199,174,163,214,152,184],
[141,0,171,190,159,175,138,151],
[142,170,0,132,176,157,151,129],
[167,151,209,0,183,182,185,190],
[178,182,165,158,0,181,161,149],
[127,166,184,159,160,0,181,147],
[189,203,190,156,180,160,0,164],
[157,190,212,151,192,194,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1627, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,142,189,177,172,172,169,162],
[199,0,204,191,183,172,176,162],
[152,137,0,161,159,154,150,159],
[164,150,180,0,168,168,171,157],
[169,158,182,173,0,169,175,172],
[169,169,187,173,172,0,165,178],
[172,165,191,170,166,176,0,174],
[179,179,182,184,169,163,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1628, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,164,186,196,186,213,177],
[150,0,179,165,178,193,199,177],
[177,162,0,168,179,186,181,167],
[155,176,173,0,173,181,186,153],
[145,163,162,168,0,179,181,167],
[155,148,155,160,162,0,168,176],
[128,142,160,155,160,173,0,143],
[164,164,174,188,174,165,198,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1629, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,172,161,179,156,175,181],
[187,0,176,166,208,156,175,193],
[169,165,0,159,198,163,172,170],
[180,175,182,0,191,155,188,180],
[162,133,143,150,0,145,157,159],
[185,185,178,186,196,0,165,178],
[166,166,169,153,184,176,0,183],
[160,148,171,161,182,163,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1630, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,172,165,198,171,172,175],
[161,0,166,155,195,164,167,163],
[169,175,0,155,193,159,151,158],
[176,186,186,0,205,177,169,179],
[143,146,148,136,0,149,129,150],
[170,177,182,164,192,0,167,163],
[169,174,190,172,212,174,0,161],
[166,178,183,162,191,178,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1631, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,173,186,162,191,178,192],
[149,0,151,178,162,164,172,155],
[168,190,0,179,165,179,182,178],
[155,163,162,0,140,143,166,158],
[179,179,176,201,0,168,182,181],
[150,177,162,198,173,0,167,162],
[163,169,159,175,159,174,0,181],
[149,186,163,183,160,179,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1632, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,186,202,175,193,181,179],
[179,0,189,196,178,194,170,179],
[155,152,0,199,180,176,161,156],
[139,145,142,0,158,158,144,162],
[166,163,161,183,0,178,160,161],
[148,147,165,183,163,0,155,169],
[160,171,180,197,181,186,0,181],
[162,162,185,179,180,172,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1633, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,168,220,187,204,185,187],
[174,0,190,206,188,188,169,223],
[173,151,0,204,153,153,132,171],
[121,135,137,0,172,155,121,187],
[154,153,188,169,0,157,169,190],
[137,153,188,186,184,0,199,170],
[156,172,209,220,172,142,0,189],
[154,118,170,154,151,171,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1634, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,145,166,175,177,172,169,191],
[196,0,190,164,192,204,178,211],
[175,151,0,174,150,161,158,222],
[166,177,167,0,187,228,135,216],
[164,149,191,154,0,194,166,224],
[169,137,180,113,147,0,146,160],
[172,163,183,206,175,195,0,208],
[150,130,119,125,117,181,133,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1635, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,148,160,143,210,161,208,161],
[193,0,146,176,195,180,212,179],
[181,195,0,150,196,146,232,161],
[198,165,191,0,210,180,161,145],
[131,146,145,131,0,145,198,159],
[180,161,195,161,196,0,213,164],
[133,129,109,180,143,128,0,143],
[180,162,180,196,182,177,198,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1636, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,175,174,187,188,162,177],
[166,0,159,158,159,172,162,171],
[166,182,0,162,182,177,169,183],
[167,183,179,0,185,169,174,183],
[154,182,159,156,0,160,147,165],
[153,169,164,172,181,0,185,176],
[179,179,172,167,194,156,0,195],
[164,170,158,158,176,165,146,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1637, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,169,155,187,179,164,174],
[189,0,163,167,184,173,153,166],
[172,178,0,179,189,175,166,182],
[186,174,162,0,181,171,167,160],
[154,157,152,160,0,161,165,151],
[162,168,166,170,180,0,161,179],
[177,188,175,174,176,180,0,167],
[167,175,159,181,190,162,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1638, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,160,163,174,171,177,165],
[173,0,157,169,168,178,177,174],
[181,184,0,181,183,179,184,166],
[178,172,160,0,170,174,179,162],
[167,173,158,171,0,170,177,164],
[170,163,162,167,171,0,171,165],
[164,164,157,162,164,170,0,161],
[176,167,175,179,177,176,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1639, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,155,179,178,168,175,185],
[171,0,150,160,178,169,175,181],
[186,191,0,186,196,180,169,189],
[162,181,155,0,168,173,152,176],
[163,163,145,173,0,145,158,167],
[173,172,161,168,196,0,167,187],
[166,166,172,189,183,174,0,181],
[156,160,152,165,174,154,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1640, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,163,198,166,175,178,198],
[150,0,168,158,169,174,167,175],
[178,173,0,185,174,160,165,187],
[143,183,156,0,174,163,168,183],
[175,172,167,167,0,163,161,189],
[166,167,181,178,178,0,156,175],
[163,174,176,173,180,185,0,180],
[143,166,154,158,152,166,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1641, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,174,168,192,174,172,182],
[171,0,173,167,190,167,175,175],
[167,168,0,175,174,172,171,175],
[173,174,166,0,180,161,151,183],
[149,151,167,161,0,150,153,157],
[167,174,169,180,191,0,170,178],
[169,166,170,190,188,171,0,160],
[159,166,166,158,184,163,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1642, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,152,180,184,194,190,215],
[162,0,178,198,197,205,189,181],
[189,163,0,200,194,182,187,178],
[161,143,141,0,186,172,171,178],
[157,144,147,155,0,184,171,173],
[147,136,159,169,157,0,163,162],
[151,152,154,170,170,178,0,150],
[126,160,163,163,168,179,191,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1643, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,182,198,160,202,199,189],
[150,0,189,198,182,193,199,208],
[159,152,0,199,165,203,217,207],
[143,143,142,0,128,146,155,156],
[181,159,176,213,0,186,197,194],
[139,148,138,195,155,0,176,179],
[142,142,124,186,144,165,0,172],
[152,133,134,185,147,162,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1644, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,189,159,175,171,182,183],
[153,0,180,172,160,173,178,197],
[152,161,0,145,147,173,178,174],
[182,169,196,0,162,195,194,173],
[166,181,194,179,0,183,188,187],
[170,168,168,146,158,0,181,167],
[159,163,163,147,153,160,0,161],
[158,144,167,168,154,174,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1645, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,175,187,185,183,162,208],
[160,0,165,167,170,164,169,178],
[166,176,0,174,160,166,182,177],
[154,174,167,0,170,165,178,178],
[156,171,181,171,0,187,183,182],
[158,177,175,176,154,0,160,171],
[179,172,159,163,158,181,0,192],
[133,163,164,163,159,170,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1646, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,192,177,146,174,146,182],
[157,0,215,150,169,176,193,160],
[149,126,0,156,131,133,124,137],
[164,191,185,0,161,160,207,174],
[195,172,210,180,0,184,164,179],
[167,165,208,181,157,0,151,173],
[195,148,217,134,177,190,0,192],
[159,181,204,167,162,168,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1647, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,166,183,157,156,178,178],
[184,0,164,194,183,182,158,178],
[175,177,0,156,180,176,163,182],
[158,147,185,0,193,160,172,177],
[184,158,161,148,0,137,143,177],
[185,159,165,181,204,0,183,183],
[163,183,178,169,198,158,0,183],
[163,163,159,164,164,158,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1648, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,144,187,156,175,163,171,150],
[197,0,196,163,188,180,177,163],
[154,145,0,147,184,157,153,147],
[185,178,194,0,197,184,180,165],
[166,153,157,144,0,159,152,129],
[178,161,184,157,182,0,177,172],
[170,164,188,161,189,164,0,149],
[191,178,194,176,212,169,192,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1649, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,75,179,183,164,145,143,126],
[266,0,213,194,192,146,153,234],
[162,128,0,140,161,163,123,163],
[158,147,201,0,141,109,143,131],
[177,149,180,200,0,128,157,186],
[196,195,178,232,213,0,156,220],
[198,188,218,198,184,185,0,149],
[215,107,178,210,155,121,192,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1650, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,169,166,187,172,158,152],
[164,0,162,163,184,164,161,167],
[172,179,0,161,178,174,162,159],
[175,178,180,0,191,165,171,177],
[154,157,163,150,0,157,151,154],
[169,177,167,176,184,0,163,164],
[183,180,179,170,190,178,0,171],
[189,174,182,164,187,177,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1651, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,171,179,183,170,187,171],
[174,0,176,170,202,176,175,180],
[170,165,0,184,166,162,183,181],
[162,171,157,0,188,161,172,186],
[158,139,175,153,0,156,168,172],
[171,165,179,180,185,0,193,172],
[154,166,158,169,173,148,0,182],
[170,161,160,155,169,169,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1652, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,175,160,170,178,171,187],
[166,0,192,177,163,174,176,179],
[166,149,0,161,164,157,160,168],
[181,164,180,0,172,165,172,174],
[171,178,177,169,0,154,165,177],
[163,167,184,176,187,0,170,180],
[170,165,181,169,176,171,0,169],
[154,162,173,167,164,161,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1653, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,159,152,188,194,151,177],
[183,0,177,180,197,182,193,152],
[182,164,0,162,196,181,160,198],
[189,161,179,0,185,176,202,183],
[153,144,145,156,0,153,165,165],
[147,159,160,165,188,0,172,175],
[190,148,181,139,176,169,0,164],
[164,189,143,158,176,166,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1654, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,192,173,190,192,200,177],
[178,0,166,158,201,185,189,147],
[149,175,0,180,168,182,208,170],
[168,183,161,0,169,163,188,153],
[151,140,173,172,0,165,170,150],
[149,156,159,178,176,0,168,171],
[141,152,133,153,171,173,0,135],
[164,194,171,188,191,170,206,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1655, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,190,168,161,160,170,154],
[190,0,197,181,175,164,179,163],
[151,144,0,149,156,144,161,152],
[173,160,192,0,172,166,174,164],
[180,166,185,169,0,172,165,179],
[181,177,197,175,169,0,170,158],
[171,162,180,167,176,171,0,161],
[187,178,189,177,162,183,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1656, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,265,158,262,241,184,237],
[152,0,180,151,231,180,151,128],
[76,161,0,128,179,132,75,157],
[183,190,213,0,184,133,80,157],
[79,110,162,157,0,110,79,134],
[100,161,209,208,231,0,151,159],
[157,190,266,261,262,190,0,238],
[104,213,184,184,207,182,103,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1657, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,173,161,172,175,166,169],
[169,0,170,170,174,178,178,170],
[168,171,0,165,161,165,177,167],
[180,171,176,0,167,170,175,169],
[169,167,180,174,0,174,175,178],
[166,163,176,171,167,0,166,171],
[175,163,164,166,166,175,0,165],
[172,171,174,172,163,170,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1658, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,183,179,160,175,195,171],
[175,0,180,186,154,171,177,164],
[158,161,0,163,156,163,183,167],
[162,155,178,0,152,166,172,160],
[181,187,185,189,0,154,181,178],
[166,170,178,175,187,0,182,169],
[146,164,158,169,160,159,0,169],
[170,177,174,181,163,172,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1659, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,174,176,175,181,183,167],
[170,0,133,154,150,170,156,161],
[167,208,0,181,187,177,181,166],
[165,187,160,0,171,188,173,172],
[166,191,154,170,0,175,164,153],
[160,171,164,153,166,0,173,167],
[158,185,160,168,177,168,0,169],
[174,180,175,169,188,174,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1660, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,202,101,101,167,202,169,135],
[139,0,101,136,168,168,100,100],
[240,240,0,203,237,238,240,167],
[240,205,138,0,272,101,204,170],
[174,173,104,69,0,101,204,105],
[139,173,103,240,240,0,137,172],
[172,241,101,137,137,204,0,102],
[206,241,174,171,236,169,239,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1661, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,160,157,169,173,173,169],
[167,0,155,157,178,184,167,161],
[181,186,0,170,195,175,184,167],
[184,184,171,0,184,162,184,180],
[172,163,146,157,0,178,169,165],
[168,157,166,179,163,0,155,162],
[168,174,157,157,172,186,0,167],
[172,180,174,161,176,179,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1662, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,215,300,128,172,172,172],
[170,0,255,298,168,170,213,213],
[126,86,0,211,127,170,84,41],
[41,43,130,0,0,86,41,44],
[213,173,214,341,0,170,128,171],
[169,171,171,255,171,0,212,128],
[169,128,257,300,213,129,0,214],
[169,128,300,297,170,213,127,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1663, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,172,185,168,163,167,166],
[163,0,183,169,161,148,159,171],
[169,158,0,165,169,151,156,160],
[156,172,176,0,171,154,159,175],
[173,180,172,170,0,171,168,168],
[178,193,190,187,170,0,162,174],
[174,182,185,182,173,179,0,168],
[175,170,181,166,173,167,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1664, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,169,171,168,185,178,169],
[178,0,192,177,182,172,186,169],
[172,149,0,152,172,178,166,166],
[170,164,189,0,179,183,177,175],
[173,159,169,162,0,178,174,161],
[156,169,163,158,163,0,162,157],
[163,155,175,164,167,179,0,148],
[172,172,175,166,180,184,193,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1665, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,142,146,154,158,165,148,150],
[199,0,166,167,179,169,165,188],
[195,175,0,172,169,177,156,178],
[187,174,169,0,159,172,162,163],
[183,162,172,182,0,177,176,179],
[176,172,164,169,164,0,156,173],
[193,176,185,179,165,185,0,183],
[191,153,163,178,162,168,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1666, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,151,172,157,171,174,156],
[164,0,167,169,167,167,169,168],
[190,174,0,191,177,170,180,171],
[169,172,150,0,174,149,169,157],
[184,174,164,167,0,174,166,171],
[170,174,171,192,167,0,171,167],
[167,172,161,172,175,170,0,164],
[185,173,170,184,170,174,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1667, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,175,152,166,164,172,165],
[163,0,176,167,178,196,175,166],
[166,165,0,156,167,154,165,151],
[189,174,185,0,177,162,179,168],
[175,163,174,164,0,159,175,171],
[177,145,187,179,182,0,171,175],
[169,166,176,162,166,170,0,166],
[176,175,190,173,170,166,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1668, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,184,174,175,168,195,173],
[164,0,166,180,176,184,173,163],
[157,175,0,168,175,171,179,171],
[167,161,173,0,167,170,175,161],
[166,165,166,174,0,156,179,175],
[173,157,170,171,185,0,172,174],
[146,168,162,166,162,169,0,155],
[168,178,170,180,166,167,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1669, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,181,176,172,172,173,165],
[163,0,166,180,164,165,173,163],
[160,175,0,183,163,168,174,168],
[165,161,158,0,158,162,168,171],
[169,177,178,183,0,180,181,164],
[169,176,173,179,161,0,172,167],
[168,168,167,173,160,169,0,158],
[176,178,173,170,177,174,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1670, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,185,181,165,166,176,169],
[188,0,183,207,187,169,192,173],
[156,158,0,184,173,151,156,166],
[160,134,157,0,171,162,150,146],
[176,154,168,170,0,159,161,158],
[175,172,190,179,182,0,176,165],
[165,149,185,191,180,165,0,166],
[172,168,175,195,183,176,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1671, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,171,176,187,173,167,155],
[182,0,164,180,168,179,160,180],
[170,177,0,206,187,187,183,174],
[165,161,135,0,171,154,158,174],
[154,173,154,170,0,167,168,163],
[168,162,154,187,174,0,167,175],
[174,181,158,183,173,174,0,188],
[186,161,167,167,178,166,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1672, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,140,146,158,132,138,144,159],
[201,0,193,166,176,176,186,186],
[195,148,0,150,147,153,170,193],
[183,175,191,0,177,166,197,194],
[209,165,194,164,0,159,186,175],
[203,165,188,175,182,0,169,189],
[197,155,171,144,155,172,0,173],
[182,155,148,147,166,152,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1673, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,181,180,161,176,173,177],
[162,0,176,154,165,165,171,162],
[160,165,0,160,148,163,164,155],
[161,187,181,0,163,178,158,159],
[180,176,193,178,0,162,165,170],
[165,176,178,163,179,0,173,171],
[168,170,177,183,176,168,0,177],
[164,179,186,182,171,170,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1674, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,169,168,203,171,176,182],
[180,0,170,178,201,176,175,201],
[172,171,0,168,170,169,179,187],
[173,163,173,0,177,186,169,191],
[138,140,171,164,0,162,164,162],
[170,165,172,155,179,0,184,198],
[165,166,162,172,177,157,0,189],
[159,140,154,150,179,143,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1675, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,161,181,146,168,161,179],
[178,0,161,177,153,155,169,182],
[180,180,0,182,181,152,159,184],
[160,164,159,0,152,175,152,183],
[195,188,160,189,0,167,193,205],
[173,186,189,166,174,0,165,192],
[180,172,182,189,148,176,0,186],
[162,159,157,158,136,149,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1676, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,156,160,163,157,183,164],
[182,0,174,163,194,180,187,179],
[185,167,0,194,190,178,195,193],
[181,178,147,0,174,164,178,178],
[178,147,151,167,0,171,165,176],
[184,161,163,177,170,0,171,175],
[158,154,146,163,176,170,0,157],
[177,162,148,163,165,166,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1677, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,137,227,212,213,194,154,136],
[204,0,127,187,193,192,149,129],
[114,214,0,211,212,232,171,173],
[129,154,130,0,154,153,95,150],
[128,148,129,187,0,188,205,148],
[147,149,109,188,153,0,109,93],
[187,192,170,246,136,232,0,169],
[205,212,168,191,193,248,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1678, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,151,165,156,141,159,155],
[184,0,176,185,170,173,170,166],
[190,165,0,188,163,154,182,176],
[176,156,153,0,160,153,160,175],
[185,171,178,181,0,159,173,170],
[200,168,187,188,182,0,180,177],
[182,171,159,181,168,161,0,169],
[186,175,165,166,171,164,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1679, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,151,153,153,161,160,152],
[174,0,169,165,160,165,161,155],
[190,172,0,180,158,170,158,166],
[188,176,161,0,165,163,161,168],
[188,181,183,176,0,177,158,182],
[180,176,171,178,164,0,171,175],
[181,180,183,180,183,170,0,168],
[189,186,175,173,159,166,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1680, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,162,154,167,143,146,167],
[180,0,167,164,186,146,173,182],
[179,174,0,147,169,164,172,174],
[187,177,194,0,179,170,173,188],
[174,155,172,162,0,167,161,163],
[198,195,177,171,174,0,170,169],
[195,168,169,168,180,171,0,186],
[174,159,167,153,178,172,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1681, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,149,137,152,184,176,169],
[174,0,157,166,168,186,171,165],
[192,184,0,164,165,188,181,171],
[204,175,177,0,162,197,168,177],
[189,173,176,179,0,188,184,169],
[157,155,153,144,153,0,168,153],
[165,170,160,173,157,173,0,171],
[172,176,170,164,172,188,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1682, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,177,177,170,175,173,185],
[163,0,170,165,159,167,159,166],
[164,171,0,160,159,172,163,175],
[164,176,181,0,173,178,171,174],
[171,182,182,168,0,164,170,188],
[166,174,169,163,177,0,161,171],
[168,182,178,170,171,180,0,184],
[156,175,166,167,153,170,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1683, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,179,177,170,174,182,173],
[163,0,165,184,164,163,174,163],
[162,176,0,178,154,137,174,175],
[164,157,163,0,164,159,154,160],
[171,177,187,177,0,154,180,170],
[167,178,204,182,187,0,178,194],
[159,167,167,187,161,163,0,148],
[168,178,166,181,171,147,193,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1684, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,171,218,203,154,187,158],
[183,0,153,211,153,140,199,140],
[170,188,0,199,154,156,203,170],
[123,130,142,0,77,111,80,141],
[138,188,187,264,0,140,154,202],
[187,201,185,230,201,0,201,157],
[154,142,138,261,187,140,0,186],
[183,201,171,200,139,184,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1685, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,188,176,186,170,161,169],
[164,0,170,169,167,167,146,142],
[153,171,0,167,187,197,195,147],
[165,172,174,0,167,182,157,175],
[155,174,154,174,0,172,178,185],
[171,174,144,159,169,0,161,158],
[180,195,146,184,163,180,0,174],
[172,199,194,166,156,183,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1686, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,192,191,176,173,177,157],
[154,0,170,191,167,167,180,190],
[149,171,0,180,173,162,162,163],
[150,150,161,0,151,136,159,179],
[165,174,168,190,0,175,145,163],
[168,174,179,205,166,0,162,174],
[164,161,179,182,196,179,0,170],
[184,151,178,162,178,167,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1687, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,161,204,177,181,189,201],
[156,0,160,186,187,167,174,210],
[180,181,0,175,181,165,169,194],
[137,155,166,0,147,158,161,174],
[164,154,160,194,0,159,157,176],
[160,174,176,183,182,0,183,165],
[152,167,172,180,184,158,0,196],
[140,131,147,167,165,176,145,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1688, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,187,177,169,153,178,180],
[171,0,177,159,172,173,181,173],
[154,164,0,166,185,163,174,168],
[164,182,175,0,176,155,180,163],
[172,169,156,165,0,153,165,174],
[188,168,178,186,188,0,179,163],
[163,160,167,161,176,162,0,154],
[161,168,173,178,167,178,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1689, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,208,201,175,147,156,164,177],
[133,0,147,103,130,151,140,145],
[140,194,0,146,164,163,160,164],
[166,238,195,0,190,187,204,208],
[194,211,177,151,0,191,212,197],
[185,190,178,154,150,0,161,187],
[177,201,181,137,129,180,0,185],
[164,196,177,133,144,154,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1690, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,173,167,187,188,169,192],
[163,0,155,166,179,163,167,177],
[168,186,0,181,168,177,168,188],
[174,175,160,0,164,182,176,166],
[154,162,173,177,0,164,160,183],
[153,178,164,159,177,0,182,192],
[172,174,173,165,181,159,0,182],
[149,164,153,175,158,149,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1691, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,159,169,153,162,159,163],
[177,0,170,180,180,171,171,178],
[182,171,0,171,180,175,167,161],
[172,161,170,0,171,187,156,170],
[188,161,161,170,0,174,161,163],
[179,170,166,154,167,0,158,176],
[182,170,174,185,180,183,0,173],
[178,163,180,171,178,165,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1692, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,156,145,150,150,158,130],
[180,0,155,144,137,149,167,144],
[185,186,0,153,170,158,169,170],
[196,197,188,0,163,176,177,173],
[191,204,171,178,0,167,176,173],
[191,192,183,165,174,0,168,168],
[183,174,172,164,165,173,0,170],
[211,197,171,168,168,173,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1693, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,172,161,162,165,185,166],
[160,0,158,154,163,157,171,158],
[169,183,0,166,164,175,181,174],
[180,187,175,0,183,182,177,169],
[179,178,177,158,0,170,179,162],
[176,184,166,159,171,0,170,164],
[156,170,160,164,162,171,0,163],
[175,183,167,172,179,177,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1694, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,169,171,167,164,155,154],
[183,0,188,167,178,201,178,174],
[172,153,0,167,161,165,160,140],
[170,174,174,0,181,165,168,145],
[174,163,180,160,0,174,158,155],
[177,140,176,176,167,0,161,151],
[186,163,181,173,183,180,0,152],
[187,167,201,196,186,190,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1695, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,170,195,177,186,183,174],
[164,0,164,170,158,170,169,173],
[171,177,0,183,171,180,195,164],
[146,171,158,0,162,165,158,143],
[164,183,170,179,0,151,172,166],
[155,171,161,176,190,0,166,157],
[158,172,146,183,169,175,0,148],
[167,168,177,198,175,184,193,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1696, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,159,179,185,194,180,167],
[169,0,166,163,169,187,182,161],
[182,175,0,183,181,184,190,158],
[162,178,158,0,181,179,173,159],
[156,172,160,160,0,171,185,182],
[147,154,157,162,170,0,173,145],
[161,159,151,168,156,168,0,164],
[174,180,183,182,159,196,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1697, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,139,177,161,156,169,156,156],
[202,0,168,183,168,180,181,163],
[164,173,0,170,162,161,167,172],
[180,158,171,0,170,178,155,165],
[185,173,179,171,0,173,169,155],
[172,161,180,163,168,0,161,163],
[185,160,174,186,172,180,0,171],
[185,178,169,176,186,178,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1698, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,165,173,163,176,184,151],
[178,0,175,171,187,168,183,145],
[176,166,0,164,175,175,166,170],
[168,170,177,0,190,173,187,166],
[178,154,166,151,0,156,179,160],
[165,173,166,168,185,0,181,171],
[157,158,175,154,162,160,0,156],
[190,196,171,175,181,170,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1699, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,165,177,165,176,170,155],
[182,0,163,187,169,175,169,190],
[176,178,0,193,160,167,159,181],
[164,154,148,0,161,166,146,166],
[176,172,181,180,0,169,172,187],
[165,166,174,175,172,0,166,154],
[171,172,182,195,169,175,0,185],
[186,151,160,175,154,187,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1700, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,182,170,186,190,192,181],
[156,0,189,172,155,166,152,165],
[159,152,0,148,146,163,147,137],
[171,169,193,0,164,163,171,166],
[155,186,195,177,0,177,180,176],
[151,175,178,178,164,0,182,137],
[149,189,194,170,161,159,0,150],
[160,176,204,175,165,204,191,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1701, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,191,156,214,225,166,196],
[160,0,215,192,200,190,218,183],
[150,126,0,146,169,158,154,131],
[185,149,195,0,185,158,173,194],
[127,141,172,156,0,155,153,185],
[116,151,183,183,186,0,173,182],
[175,123,187,168,188,168,0,196],
[145,158,210,147,156,159,145,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1702, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,200,178,223,161,175,179],
[162,0,168,151,188,154,169,153],
[141,173,0,130,198,143,142,167],
[163,190,211,0,205,196,199,172],
[118,153,143,136,0,145,135,145],
[180,187,198,145,196,0,181,185],
[166,172,199,142,206,160,0,168],
[162,188,174,169,196,156,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1703, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,160,163,175,168,164,187],
[175,0,149,160,171,167,170,179],
[181,192,0,163,177,182,170,177],
[178,181,178,0,185,180,170,189],
[166,170,164,156,0,167,175,167],
[173,174,159,161,174,0,153,168],
[177,171,171,171,166,188,0,184],
[154,162,164,152,174,173,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1704, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,182,164,164,162,161,183],
[176,0,180,164,152,158,156,185],
[159,161,0,164,169,153,162,183],
[177,177,177,0,166,168,158,196],
[177,189,172,175,0,180,170,194],
[179,183,188,173,161,0,173,185],
[180,185,179,183,171,168,0,202],
[158,156,158,145,147,156,139,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1705, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,186,171,176,192,167,179],
[152,0,182,188,170,183,170,180],
[155,159,0,169,178,175,157,170],
[170,153,172,0,174,168,153,172],
[165,171,163,167,0,169,175,170],
[149,158,166,173,172,0,162,184],
[174,171,184,188,166,179,0,175],
[162,161,171,169,171,157,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1706, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,183,164,175,184,164,165],
[170,0,173,195,185,188,176,183],
[158,168,0,168,160,154,152,162],
[177,146,173,0,177,170,150,154],
[166,156,181,164,0,175,153,179],
[157,153,187,171,166,0,171,165],
[177,165,189,191,188,170,0,169],
[176,158,179,187,162,176,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1707, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,139,114,160,93,159,202,135],
[202,0,202,225,114,180,224,178],
[227,139,0,202,181,206,246,203],
[181,116,139,0,159,207,112,159],
[248,227,160,182,0,249,225,248],
[182,161,135,134,92,0,156,179],
[139,117,95,229,116,185,0,182],
[206,163,138,182,93,162,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1708, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,173,170,166,177,163,173],
[177,0,175,172,170,173,169,181],
[168,166,0,172,161,169,173,175],
[171,169,169,0,168,169,162,174],
[175,171,180,173,0,174,169,182],
[164,168,172,172,167,0,175,173],
[178,172,168,179,172,166,0,170],
[168,160,166,167,159,168,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1709, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,173,169,167,171,183,172],
[178,0,179,157,150,152,174,171],
[168,162,0,166,155,157,175,161],
[172,184,175,0,171,159,179,176],
[174,191,186,170,0,170,201,176],
[170,189,184,182,171,0,185,169],
[158,167,166,162,140,156,0,146],
[169,170,180,165,165,172,195,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1710, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,189,181,187,154,183,123],
[187,0,250,214,214,215,217,153],
[152,91,0,182,90,120,150,121],
[160,127,159,0,189,187,157,127],
[154,127,251,152,0,93,154,185],
[187,126,221,154,248,0,217,187],
[158,124,191,184,187,124,0,186],
[218,188,220,214,156,154,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1711, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,136,139,130,185,162,140],
[167,0,160,168,161,147,169,137],
[205,181,0,174,167,187,188,170],
[202,173,167,0,185,204,162,190],
[211,180,174,156,0,196,190,162],
[156,194,154,137,145,0,170,141],
[179,172,153,179,151,171,0,135],
[201,204,171,151,179,200,206,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1712, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,173,172,166,147,161,185],
[185,0,177,173,175,172,174,167],
[168,164,0,168,159,174,160,169],
[169,168,173,0,159,161,167,181],
[175,166,182,182,0,179,181,179],
[194,169,167,180,162,0,190,166],
[180,167,181,174,160,151,0,174],
[156,174,172,160,162,175,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1713, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,166,159,180,172,177,164],
[171,0,175,173,170,165,177,169],
[175,166,0,165,169,172,163,173],
[182,168,176,0,189,176,178,182],
[161,171,172,152,0,163,165,168],
[169,176,169,165,178,0,174,170],
[164,164,178,163,176,167,0,172],
[177,172,168,159,173,171,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1714, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,199,123,135,199,184,181,170],
[142,0,125,136,166,137,196,122],
[218,216,0,152,153,187,216,185],
[206,205,189,0,201,158,186,203],
[142,175,188,140,0,141,174,138],
[157,204,154,183,200,0,168,169],
[160,145,125,155,167,173,0,123],
[171,219,156,138,203,172,218,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1715, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,162,172,168,154,162,166],
[176,0,169,156,183,156,157,163],
[179,172,0,159,183,161,172,171],
[169,185,182,0,170,169,160,174],
[173,158,158,171,0,162,156,167],
[187,185,180,172,179,0,172,170],
[179,184,169,181,185,169,0,185],
[175,178,170,167,174,171,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1716, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,177,167,178,172,182,183],
[178,0,168,178,184,172,181,179],
[164,173,0,174,164,160,176,175],
[174,163,167,0,160,153,167,169],
[163,157,177,181,0,158,175,169],
[169,169,181,188,183,0,169,173],
[159,160,165,174,166,172,0,161],
[158,162,166,172,172,168,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1717, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,175,175,176,170,178,158],
[159,0,172,177,176,176,175,154],
[166,169,0,195,194,189,177,168],
[166,164,146,0,163,160,166,146],
[165,165,147,178,0,152,144,159],
[171,165,152,181,189,0,175,192],
[163,166,164,175,197,166,0,164],
[183,187,173,195,182,149,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1718, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,120,211,174,214,144,193],
[173,0,185,143,172,189,133,165],
[221,156,0,213,205,250,194,229],
[130,198,128,0,150,186,134,168],
[167,169,136,191,0,175,169,163],
[127,152,91,155,166,0,126,148],
[197,208,147,207,172,215,0,205],
[148,176,112,173,178,193,136,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1719, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,177,175,180,168,177,173],
[176,0,167,178,164,166,177,170],
[164,174,0,182,183,175,170,192],
[166,163,159,0,173,166,161,174],
[161,177,158,168,0,165,177,179],
[173,175,166,175,176,0,179,195],
[164,164,171,180,164,162,0,176],
[168,171,149,167,162,146,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1720, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,180,194,194,183,176,164],
[166,0,178,193,162,165,152,160],
[161,163,0,179,176,157,164,158],
[147,148,162,0,171,156,154,148],
[147,179,165,170,0,160,160,166],
[158,176,184,185,181,0,177,169],
[165,189,177,187,181,164,0,176],
[177,181,183,193,175,172,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1721, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,161,153,169,158,160,164],
[176,0,173,174,183,170,176,180],
[180,168,0,165,175,177,172,166],
[188,167,176,0,195,176,176,177],
[172,158,166,146,0,177,175,166],
[183,171,164,165,164,0,165,171],
[181,165,169,165,166,176,0,182],
[177,161,175,164,175,170,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1722, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,156,193,180,179,176,176],
[182,0,185,178,183,192,187,170],
[185,156,0,187,204,193,200,197],
[148,163,154,0,178,169,181,168],
[161,158,137,163,0,152,145,165],
[162,149,148,172,189,0,175,165],
[165,154,141,160,196,166,0,166],
[165,171,144,173,176,176,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1723, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,171,169,163,189,158,174],
[176,0,155,166,163,169,156,165],
[170,186,0,171,183,186,173,178],
[172,175,170,0,177,202,168,181],
[178,178,158,164,0,185,157,194],
[152,172,155,139,156,0,148,174],
[183,185,168,173,184,193,0,179],
[167,176,163,160,147,167,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1724, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,202,196,195,187,200,202],
[173,0,201,202,163,187,194,195],
[139,140,0,177,161,177,175,178],
[145,139,164,0,141,182,161,155],
[146,178,180,200,0,181,197,201],
[154,154,164,159,160,0,170,176],
[141,147,166,180,144,171,0,186],
[139,146,163,186,140,165,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1725, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,183,165,201,173,179,182],
[170,0,167,174,181,168,171,201],
[158,174,0,182,188,174,198,174],
[176,167,159,0,182,167,194,189],
[140,160,153,159,0,150,166,184],
[168,173,167,174,191,0,177,187],
[162,170,143,147,175,164,0,189],
[159,140,167,152,157,154,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1726, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,150,178,141,167,186,171],
[189,0,171,186,160,179,196,174],
[191,170,0,163,177,151,206,186],
[163,155,178,0,136,163,191,171],
[200,181,164,205,0,177,219,210],
[174,162,190,178,164,0,192,180],
[155,145,135,150,122,149,0,157],
[170,167,155,170,131,161,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1727, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,159,170,173,160,158,164],
[185,0,179,173,178,168,172,169],
[182,162,0,172,188,178,171,175],
[171,168,169,0,171,179,162,165],
[168,163,153,170,0,169,166,165],
[181,173,163,162,172,0,175,176],
[183,169,170,179,175,166,0,169],
[177,172,166,176,176,165,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1728, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,193,180,179,172,175,180,170],
[148,0,159,168,159,168,183,158],
[161,182,0,175,174,170,184,167],
[162,173,166,0,162,170,164,166],
[169,182,167,179,0,187,177,182],
[166,173,171,171,154,0,168,156],
[161,158,157,177,164,173,0,150],
[171,183,174,175,159,185,191,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1729, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,137,89,157,163,182,207],
[185,0,184,136,228,185,183,255],
[204,157,0,226,204,227,204,206],
[252,205,115,0,249,206,251,208],
[184,113,137,92,0,160,157,162],
[178,156,114,135,181,0,206,162],
[159,158,137,90,184,135,0,182],
[134,86,135,133,179,179,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1730, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,156,180,162,186,168,179],
[171,0,171,168,164,180,172,176],
[185,170,0,180,177,189,180,185],
[161,173,161,0,153,183,184,177],
[179,177,164,188,0,189,169,185],
[155,161,152,158,152,0,153,169],
[173,169,161,157,172,188,0,179],
[162,165,156,164,156,172,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1731, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,141,169,164,169,179,175,167],
[200,0,215,192,178,195,189,162],
[172,126,0,173,161,158,139,158],
[177,149,168,0,163,177,161,147],
[172,163,180,178,0,170,169,155],
[162,146,183,164,171,0,171,175],
[166,152,202,180,172,170,0,168],
[174,179,183,194,186,166,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1732, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,176,163,164,170,168,185],
[175,0,168,163,182,171,160,171],
[165,173,0,172,174,170,161,162],
[178,178,169,0,178,172,154,169],
[177,159,167,163,0,171,158,167],
[171,170,171,169,170,0,172,179],
[173,181,180,187,183,169,0,190],
[156,170,179,172,174,162,151,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1733, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,174,173,174,177,164,166],
[149,0,168,173,176,159,178,171],
[167,173,0,179,183,181,179,179],
[168,168,162,0,172,167,166,186],
[167,165,158,169,0,181,182,184],
[164,182,160,174,160,0,162,156],
[177,163,162,175,159,179,0,166],
[175,170,162,155,157,185,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1734, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,172,183,153,168,182,184],
[179,0,171,181,174,170,159,165],
[169,170,0,189,174,174,162,179],
[158,160,152,0,161,163,158,164],
[188,167,167,180,0,176,157,177],
[173,171,167,178,165,0,163,167],
[159,182,179,183,184,178,0,178],
[157,176,162,177,164,174,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1735, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,171,183,187,148,161,177],
[187,0,184,185,194,155,183,175],
[170,157,0,179,177,155,172,164],
[158,156,162,0,173,171,163,174],
[154,147,164,168,0,163,166,172],
[193,186,186,170,178,0,183,191],
[180,158,169,178,175,158,0,173],
[164,166,177,167,169,150,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1736, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,162,168,179,173,189,182],
[176,0,180,168,179,170,190,168],
[179,161,0,166,169,167,164,170],
[173,173,175,0,159,181,188,171],
[162,162,172,182,0,170,181,187],
[168,171,174,160,171,0,193,167],
[152,151,177,153,160,148,0,159],
[159,173,171,170,154,174,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1737, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,175,168,172,162,164,183],
[177,0,185,179,172,167,186,185],
[166,156,0,175,166,162,171,184],
[173,162,166,0,170,162,167,177],
[169,169,175,171,0,175,164,182],
[179,174,179,179,166,0,195,182],
[177,155,170,174,177,146,0,178],
[158,156,157,164,159,159,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1738, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,142,162,136,168,169,137,151],
[199,0,198,187,205,212,168,163],
[179,143,0,154,196,195,175,187],
[205,154,187,0,203,212,169,177],
[173,136,145,138,0,162,164,160],
[172,129,146,129,179,0,157,142],
[204,173,166,172,177,184,0,185],
[190,178,154,164,181,199,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1739, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,150,138,153,175,171,156,152],
[191,0,170,155,191,186,190,172],
[203,171,0,182,188,188,170,174],
[188,186,159,0,187,182,180,167],
[166,150,153,154,0,173,169,141],
[170,155,153,159,168,0,181,149],
[185,151,171,161,172,160,0,158],
[189,169,167,174,200,192,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1740, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,176,176,179,180,175,169],
[169,0,176,176,172,178,160,159],
[165,165,0,169,171,178,169,166],
[165,165,172,0,167,174,164,156],
[162,169,170,174,0,174,168,170],
[161,163,163,167,167,0,154,159],
[166,181,172,177,173,187,0,175],
[172,182,175,185,171,182,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1741, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,152,204,160,165,182,151],
[190,0,158,226,157,204,234,178],
[189,183,0,195,153,202,207,151],
[137,115,146,0,130,139,167,142],
[181,184,188,211,0,191,224,166],
[176,137,139,202,150,0,205,140],
[159,107,134,174,117,136,0,158],
[190,163,190,199,175,201,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1742, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,189,179,167,177,151,181],
[164,0,163,168,164,156,170,181],
[152,178,0,159,162,171,160,167],
[162,173,182,0,172,169,184,193],
[174,177,179,169,0,167,163,185],
[164,185,170,172,174,0,174,183],
[190,171,181,157,178,167,0,181],
[160,160,174,148,156,158,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1743, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,185,194,179,180,184,183],
[173,0,172,178,167,157,157,160],
[156,169,0,183,163,159,162,164],
[147,163,158,0,166,149,162,144],
[162,174,178,175,0,152,166,170],
[161,184,182,192,189,0,199,172],
[157,184,179,179,175,142,0,166],
[158,181,177,197,171,169,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1744, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,115,146,139,149,168,155],
[185,0,169,203,179,207,211,203],
[226,172,0,187,146,203,180,162],
[195,138,154,0,162,156,167,154],
[202,162,195,179,0,183,177,154],
[192,134,138,185,158,0,165,158],
[173,130,161,174,164,176,0,163],
[186,138,179,187,187,183,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1745, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,172,170,147,151,145,152],
[189,0,159,177,169,172,166,157],
[169,182,0,159,160,156,148,165],
[171,164,182,0,179,163,173,185],
[194,172,181,162,0,169,158,168],
[190,169,185,178,172,0,170,164],
[196,175,193,168,183,171,0,173],
[189,184,176,156,173,177,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1746, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,206,171,135,191,206,153,147],
[135,0,211,154,191,208,190,150],
[170,130,0,171,167,206,186,90],
[206,187,170,0,187,186,131,129],
[150,150,174,154,0,152,136,130],
[135,133,135,155,189,0,192,131],
[188,151,155,210,205,149,0,185],
[194,191,251,212,211,210,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1747, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,196,184,170,179,185,165,181],
[145,0,162,170,152,158,153,172],
[157,179,0,172,167,169,161,176],
[171,171,169,0,131,156,161,174],
[162,189,174,210,0,172,188,176],
[156,183,172,185,169,0,184,183],
[176,188,180,180,153,157,0,177],
[160,169,165,167,165,158,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1748, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,153,137,176,150,162,136],
[155,0,166,172,187,180,203,174],
[188,175,0,161,194,155,179,132],
[204,169,180,0,194,191,169,174],
[165,154,147,147,0,186,160,131],
[191,161,186,150,155,0,141,142],
[179,138,162,172,181,200,0,157],
[205,167,209,167,210,199,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1749, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,144,160,178,168,190,170,188],
[197,0,167,180,179,196,192,186],
[181,174,0,168,190,198,183,184],
[163,161,173,0,184,186,172,180],
[173,162,151,157,0,192,183,169],
[151,145,143,155,149,0,162,176],
[171,149,158,169,158,179,0,184],
[153,155,157,161,172,165,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1750, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,165,169,185,179,180,154],
[179,0,166,170,180,180,175,168],
[176,175,0,172,191,172,173,150],
[172,171,169,0,199,181,174,172],
[156,161,150,142,0,153,174,140],
[162,161,169,160,188,0,191,171],
[161,166,168,167,167,150,0,156],
[187,173,191,169,201,170,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1751, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,147,162,171,150,196,148,148],
[194,0,167,160,158,203,178,166],
[179,174,0,190,165,197,153,170],
[170,181,151,0,118,185,159,144],
[191,183,176,223,0,212,175,168],
[145,138,144,156,129,0,126,126],
[193,163,188,182,166,215,0,176],
[193,175,171,197,173,215,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1752, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,166,177,154,170,174,166],
[160,0,155,165,175,161,167,157],
[175,186,0,173,184,174,165,181],
[164,176,168,0,164,175,174,181],
[187,166,157,177,0,179,181,178],
[171,180,167,166,162,0,185,184],
[167,174,176,167,160,156,0,174],
[175,184,160,160,163,157,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1753, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,168,175,181,175,181,169],
[164,0,162,171,177,169,181,171],
[173,179,0,167,166,179,194,160],
[166,170,174,0,175,172,188,166],
[160,164,175,166,0,168,181,173],
[166,172,162,169,173,0,172,158],
[160,160,147,153,160,169,0,157],
[172,170,181,175,168,183,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1754, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,147,167,180,185,172,169],
[182,0,161,165,177,166,159,158],
[194,180,0,165,176,188,180,178],
[174,176,176,0,177,182,175,160],
[161,164,165,164,0,178,186,166],
[156,175,153,159,163,0,173,144],
[169,182,161,166,155,168,0,162],
[172,183,163,181,175,197,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1755, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,168,158,167,176,163,157],
[177,0,171,172,163,181,180,160],
[173,170,0,182,178,170,180,170],
[183,169,159,0,177,176,177,173],
[174,178,163,164,0,173,176,172],
[165,160,171,165,168,0,161,151],
[178,161,161,164,165,180,0,160],
[184,181,171,168,169,190,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1756, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,191,169,189,180,170,192],
[160,0,163,185,185,171,172,185],
[150,178,0,158,166,168,181,172],
[172,156,183,0,195,167,172,162],
[152,156,175,146,0,156,172,164],
[161,170,173,174,185,0,169,166],
[171,169,160,169,169,172,0,165],
[149,156,169,179,177,175,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1757, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,150,150,172,169,140,163],
[183,0,163,146,209,212,170,204],
[191,178,0,184,173,196,143,182],
[191,195,157,0,202,187,172,207],
[169,132,168,139,0,185,145,178],
[172,129,145,154,156,0,156,188],
[201,171,198,169,196,185,0,203],
[178,137,159,134,163,153,138,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1758, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,155,166,168,163,167,170,172],
[186,0,164,178,161,166,168,181],
[175,177,0,180,177,163,176,173],
[173,163,161,0,181,168,182,169],
[178,180,164,160,0,174,175,163],
[174,175,178,173,167,0,175,172],
[171,173,165,159,166,166,0,161],
[169,160,168,172,178,169,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1759, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,165,182,191,179,173,182],
[160,0,173,186,181,175,168,178],
[176,168,0,180,186,181,176,168],
[159,155,161,0,167,164,147,167],
[150,160,155,174,0,167,159,162],
[162,166,160,177,174,0,160,167],
[168,173,165,194,182,181,0,172],
[159,163,173,174,179,174,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1760, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,174,176,169,181,177,186],
[162,0,177,159,156,183,167,184],
[167,164,0,172,164,177,174,181],
[165,182,169,0,165,171,185,186],
[172,185,177,176,0,185,169,184],
[160,158,164,170,156,0,172,178],
[164,174,167,156,172,169,0,184],
[155,157,160,155,157,163,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1761, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,170,171,190,157,139,148],
[173,0,183,175,181,140,167,157],
[171,158,0,176,195,155,148,141],
[170,166,165,0,169,167,141,154],
[151,160,146,172,0,126,138,159],
[184,201,186,174,215,0,172,149],
[202,174,193,200,203,169,0,189],
[193,184,200,187,182,192,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1762, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,174,168,139,163,167,165],
[187,0,163,147,145,181,181,174],
[167,178,0,185,165,167,181,166],
[173,194,156,0,142,170,194,187],
[202,196,176,199,0,175,202,166],
[178,160,174,171,166,0,175,161],
[174,160,160,147,139,166,0,140],
[176,167,175,154,175,180,201,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1763, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,170,179,167,178,166,159],
[172,0,178,173,179,166,166,150],
[171,163,0,167,164,168,166,142],
[162,168,174,0,161,152,173,142],
[174,162,177,180,0,169,165,134],
[163,175,173,189,172,0,155,174],
[175,175,175,168,176,186,0,160],
[182,191,199,199,207,167,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1764, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,150,182,177,185,176,176],
[176,0,175,185,171,185,192,169],
[191,166,0,177,178,177,186,182],
[159,156,164,0,183,180,183,169],
[164,170,163,158,0,167,167,185],
[156,156,164,161,174,0,176,166],
[165,149,155,158,174,165,0,167],
[165,172,159,172,156,175,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1765, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,172,166,151,185,164,178],
[159,0,187,174,176,186,167,173],
[169,154,0,163,168,179,173,176],
[175,167,178,0,167,182,165,162],
[190,165,173,174,0,197,172,175],
[156,155,162,159,144,0,164,148],
[177,174,168,176,169,177,0,165],
[163,168,165,179,166,193,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1766, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,151,164,149,168,155,161],
[187,0,159,165,165,166,163,175],
[190,182,0,176,168,187,184,176],
[177,176,165,0,175,181,167,174],
[192,176,173,166,0,185,162,179],
[173,175,154,160,156,0,167,170],
[186,178,157,174,179,174,0,169],
[180,166,165,167,162,171,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1767, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,181,177,171,167,203,172],
[157,0,173,162,150,154,176,145],
[160,168,0,165,164,170,178,154],
[164,179,176,0,162,163,176,163],
[170,191,177,179,0,165,190,144],
[174,187,171,178,176,0,190,158],
[138,165,163,165,151,151,0,150],
[169,196,187,178,197,183,191,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1768, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,174,177,190,173,201,180],
[173,0,169,185,180,181,173,190],
[167,172,0,183,165,176,187,177],
[164,156,158,0,166,156,165,167],
[151,161,176,175,0,172,170,179],
[168,160,165,185,169,0,175,184],
[140,168,154,176,171,166,0,180],
[161,151,164,174,162,157,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1769, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,198,181,173,185,188,173],
[175,0,187,166,179,207,164,174],
[143,154,0,166,159,169,154,157],
[160,175,175,0,168,184,159,146],
[168,162,182,173,0,194,182,175],
[156,134,172,157,147,0,162,157],
[153,177,187,182,159,179,0,167],
[168,167,184,195,166,184,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1770, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,173,164,154,154,161,176],
[169,0,162,173,166,153,156,155],
[168,179,0,174,164,159,171,177],
[177,168,167,0,172,175,186,176],
[187,175,177,169,0,172,182,161],
[187,188,182,166,169,0,160,162],
[180,185,170,155,159,181,0,152],
[165,186,164,165,180,179,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1771, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,174,174,170,198,179,179],
[162,0,151,182,173,196,180,183],
[167,190,0,188,173,210,189,205],
[167,159,153,0,148,155,173,166],
[171,168,168,193,0,195,165,183],
[143,145,131,186,146,0,170,176],
[162,161,152,168,176,171,0,181],
[162,158,136,175,158,165,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1772, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,192,182,172,180,169,188],
[162,0,183,197,173,170,180,184],
[149,158,0,185,177,162,149,186],
[159,144,156,0,145,165,150,179],
[169,168,164,196,0,175,154,174],
[161,171,179,176,166,0,162,169],
[172,161,192,191,187,179,0,192],
[153,157,155,162,167,172,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1773, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,156,156,154,162,182,160],
[170,0,171,183,208,162,183,170],
[185,170,0,187,198,185,174,187],
[185,158,154,0,174,160,175,175],
[187,133,143,167,0,156,173,139],
[179,179,156,181,185,0,159,130],
[159,158,167,166,168,182,0,148],
[181,171,154,166,202,211,193,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1774, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,159,179,185,174,162,160],
[159,0,181,193,159,171,174,153],
[182,160,0,209,162,198,189,175],
[162,148,132,0,140,139,150,162],
[156,182,179,201,0,155,181,170],
[167,170,143,202,186,0,138,152],
[179,167,152,191,160,203,0,185],
[181,188,166,179,171,189,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1775, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,156,147,199,146,146,146],
[173,0,141,130,202,165,148,163],
[185,200,0,153,215,126,170,184],
[194,211,188,0,208,147,179,159],
[142,139,126,133,0,95,116,129],
[195,176,215,194,246,0,146,208],
[195,193,171,162,225,195,0,174],
[195,178,157,182,212,133,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1776, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,169,188,197,202,188,187],
[166,0,162,178,188,196,168,169],
[172,179,0,175,185,195,164,172],
[153,163,166,0,202,187,174,187],
[144,153,156,139,0,170,153,140],
[139,145,146,154,171,0,162,160],
[153,173,177,167,188,179,0,167],
[154,172,169,154,201,181,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1777, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,185,182,172,200,176,184],
[171,0,175,177,168,193,171,188],
[156,166,0,180,167,193,176,170],
[159,164,161,0,158,177,152,168],
[169,173,174,183,0,196,163,180],
[141,148,148,164,145,0,160,171],
[165,170,165,189,178,181,0,189],
[157,153,171,173,161,170,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1778, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,202,156,175,205,164,177],
[155,0,176,134,138,157,171,141],
[139,165,0,134,142,160,137,172],
[185,207,207,0,179,198,176,168],
[166,203,199,162,0,181,177,180],
[136,184,181,143,160,0,145,161],
[177,170,204,165,164,196,0,177],
[164,200,169,173,161,180,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1779, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,171,147,164,192,194,184],
[167,0,180,171,173,216,141,141],
[170,161,0,149,162,158,168,151],
[194,170,192,0,181,212,224,189],
[177,168,179,160,0,195,163,171],
[149,125,183,129,146,0,138,141],
[147,200,173,117,178,203,0,180],
[157,200,190,152,170,200,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1780, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,149,165,169,173,160,156],
[183,0,164,193,174,195,189,186],
[192,177,0,165,182,180,181,175],
[176,148,176,0,158,176,164,168],
[172,167,159,183,0,180,168,172],
[168,146,161,165,161,0,166,159],
[181,152,160,177,173,175,0,166],
[185,155,166,173,169,182,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1781, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,188,173,183,175,178,177],
[173,0,166,167,173,164,169,172],
[153,175,0,160,161,173,175,174],
[168,174,181,0,177,168,173,172],
[158,168,180,164,0,161,177,169],
[166,177,168,173,180,0,185,165],
[163,172,166,168,164,156,0,189],
[164,169,167,169,172,176,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1782, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,169,152,197,178,150,152],
[188,0,140,169,172,161,164,163],
[172,201,0,160,205,209,193,201],
[189,172,181,0,166,211,195,194],
[144,169,136,175,0,152,168,173],
[163,180,132,130,189,0,172,181],
[191,177,148,146,173,169,0,170],
[189,178,140,147,168,160,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1783, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,173,157,179,195,192,192],
[158,0,163,178,183,165,171,175],
[168,178,0,179,198,189,195,181],
[184,163,162,0,177,161,171,190],
[162,158,143,164,0,163,166,174],
[146,176,152,180,178,0,178,191],
[149,170,146,170,175,163,0,195],
[149,166,160,151,167,150,146,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1784, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,169,183,168,168,167,179],
[174,0,158,178,181,179,179,202],
[172,183,0,165,170,172,174,182],
[158,163,176,0,179,182,158,175],
[173,160,171,162,0,188,170,167],
[173,162,169,159,153,0,142,168],
[174,162,167,183,171,199,0,171],
[162,139,159,166,174,173,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1785, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,207,273,239,173,171,173,105],
[134,0,240,273,135,205,169,138],
[68,101,0,171,33,99,103,103],
[102,68,170,0,137,66,102,104],
[168,206,308,204,0,170,204,206],
[170,136,242,275,171,0,239,208],
[168,172,238,239,137,102,0,170],
[236,203,238,237,135,133,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1786, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,166,181,181,172,170,176],
[169,0,160,170,164,171,150,188],
[175,181,0,186,173,177,181,168],
[160,171,155,0,151,186,146,174],
[160,177,168,190,0,180,154,178],
[169,170,164,155,161,0,160,169],
[171,191,160,195,187,181,0,176],
[165,153,173,167,163,172,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1787, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,156,184,172,142,154,154],
[189,0,189,152,126,160,185,158],
[185,152,0,150,175,153,152,173],
[157,189,191,0,153,155,157,175],
[169,215,166,188,0,169,158,196],
[199,181,188,186,172,0,167,179],
[187,156,189,184,183,174,0,144],
[187,183,168,166,145,162,197,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1788, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,172,161,168,167,183,154],
[170,0,159,175,184,192,179,173],
[169,182,0,180,175,204,178,169],
[180,166,161,0,177,184,197,169],
[173,157,166,164,0,156,210,166],
[174,149,137,157,185,0,199,172],
[158,162,163,144,131,142,0,144],
[187,168,172,172,175,169,197,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1789, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,178,181,168,183,180,169],
[160,0,160,154,171,155,181,181],
[163,181,0,167,167,163,185,171],
[160,187,174,0,177,181,203,176],
[173,170,174,164,0,168,162,169],
[158,186,178,160,173,0,178,155],
[161,160,156,138,179,163,0,169],
[172,160,170,165,172,186,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1790, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,178,160,162,165,178,162],
[158,0,161,153,153,161,166,154],
[163,180,0,164,177,168,177,168],
[181,188,177,0,175,170,186,174],
[179,188,164,166,0,170,172,154],
[176,180,173,171,171,0,186,163],
[163,175,164,155,169,155,0,159],
[179,187,173,167,187,178,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1791, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,178,168,143,160,172,168],
[168,0,193,160,174,161,141,168],
[163,148,0,185,150,173,168,164],
[173,181,156,0,161,173,166,136],
[198,167,191,180,0,168,180,182],
[181,180,168,168,173,0,163,175],
[169,200,173,175,161,178,0,166],
[173,173,177,205,159,166,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1792, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,178,161,163,159,166,154],
[173,0,170,165,155,166,173,167],
[163,171,0,165,159,160,169,148],
[180,176,176,0,158,185,176,174],
[178,186,182,183,0,163,176,171],
[182,175,181,156,178,0,179,177],
[175,168,172,165,165,162,0,160],
[187,174,193,167,170,164,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1793, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,134,129,155,166,160,135],
[181,0,184,183,175,169,173,168],
[207,157,0,189,187,181,178,177],
[212,158,152,0,169,181,155,149],
[186,166,154,172,0,154,174,166],
[175,172,160,160,187,0,155,165],
[181,168,163,186,167,186,0,153],
[206,173,164,192,175,176,188,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1794, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,178,166,186,152,175,163],
[160,0,171,170,180,152,151,150],
[163,170,0,148,155,153,156,146],
[175,171,193,0,193,155,169,172],
[155,161,186,148,0,139,155,143],
[189,189,188,186,202,0,192,170],
[166,190,185,172,186,149,0,178],
[178,191,195,169,198,171,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1795, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,164,153,172,153,147,153],
[164,0,162,161,164,173,152,164],
[177,179,0,166,179,179,181,161],
[188,180,175,0,192,183,168,187],
[169,177,162,149,0,166,161,158],
[188,168,162,158,175,0,150,160],
[194,189,160,173,180,191,0,180],
[188,177,180,154,183,181,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1796, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,156,190,189,163,164,181],
[174,0,176,180,192,167,163,155],
[185,165,0,208,210,163,184,176],
[151,161,133,0,183,157,168,157],
[152,149,131,158,0,147,170,152],
[178,174,178,184,194,0,163,178],
[177,178,157,173,171,178,0,175],
[160,186,165,184,189,163,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1797, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,186,198,158,185,195,212],
[179,0,176,170,168,217,247,222],
[155,165,0,172,175,167,214,256],
[143,171,169,0,193,145,185,191],
[183,173,166,148,0,200,212,220],
[156,124,174,196,141,0,196,233],
[146,94,127,156,129,145,0,204],
[129,119,85,150,121,108,137,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1798, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,172,176,207,164,177,170],
[178,0,175,197,190,153,166,182],
[169,166,0,205,194,179,179,170],
[165,144,136,0,179,161,145,165],
[134,151,147,162,0,142,158,165],
[177,188,162,180,199,0,157,188],
[164,175,162,196,183,184,0,183],
[171,159,171,176,176,153,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1799, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,157,157,178,152,178,170,174],
[184,0,177,197,164,192,188,179],
[184,164,0,177,174,185,174,168],
[163,144,164,0,157,173,158,165],
[189,177,167,184,0,177,171,187],
[163,149,156,168,164,0,170,165],
[171,153,167,183,170,171,0,178],
[167,162,173,176,154,176,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1800, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,142,190,131,164,149,139],
[175,0,180,188,166,149,145,178],
[199,161,0,200,173,175,154,166],
[151,153,141,0,160,146,121,126],
[210,175,168,181,0,156,192,157],
[177,192,166,195,185,0,171,152],
[192,196,187,220,149,170,0,162],
[202,163,175,215,184,189,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1801, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,169,188,210,162,157,199],
[179,0,163,165,195,207,199,234],
[172,178,0,154,186,208,178,206],
[153,176,187,0,187,207,192,227],
[131,146,155,154,0,191,156,177],
[179,134,133,134,150,0,168,196],
[184,142,163,149,185,173,0,219],
[142,107,135,114,164,145,122,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1802, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,137,157,148,152,155,159,167],
[204,0,179,198,188,167,177,198],
[184,162,0,157,172,168,173,185],
[193,143,184,0,178,166,189,175],
[189,153,169,163,0,163,162,185],
[186,174,173,175,178,0,158,174],
[182,164,168,152,179,183,0,166],
[174,143,156,166,156,167,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1803, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,183,176,169,167,162,157],
[174,0,197,185,171,155,163,164],
[158,144,0,166,159,174,156,145],
[165,156,175,0,162,162,177,149],
[172,170,182,179,0,163,171,161],
[174,186,167,179,178,0,177,173],
[179,178,185,164,170,164,0,162],
[184,177,196,192,180,168,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1804, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,156,167,176,167,192,158],
[175,0,163,174,177,181,178,177],
[185,178,0,176,185,161,185,173],
[174,167,165,0,184,183,196,171],
[165,164,156,157,0,164,190,163],
[174,160,180,158,177,0,185,161],
[149,163,156,145,151,156,0,159],
[183,164,168,170,178,180,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1805, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,182,171,162,199,188,172],
[167,0,179,161,145,188,164,195],
[159,162,0,168,171,161,176,181],
[170,180,173,0,146,169,205,218],
[179,196,170,195,0,188,186,184],
[142,153,180,172,153,0,185,176],
[153,177,165,136,155,156,0,176],
[169,146,160,123,157,165,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1806, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,176,163,177,156,173,171],
[178,0,186,167,179,182,173,169],
[165,155,0,164,177,167,155,170],
[178,174,177,0,177,169,178,168],
[164,162,164,164,0,161,167,162],
[185,159,174,172,180,0,177,187],
[168,168,186,163,174,164,0,172],
[170,172,171,173,179,154,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1807, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,163,170,144,168,170,198],
[164,0,171,180,150,180,165,180],
[178,170,0,171,165,176,177,176],
[171,161,170,0,178,180,153,177],
[197,191,176,163,0,191,200,219],
[173,161,165,161,150,0,174,192],
[171,176,164,188,141,167,0,186],
[143,161,165,164,122,149,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1808, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,191,220,192,177,221,151,208],
[150,0,163,163,122,206,163,184],
[121,178,0,218,162,218,148,178],
[149,178,123,0,164,168,148,168],
[164,219,179,177,0,234,150,209],
[120,135,123,173,107,0,122,114],
[190,178,193,193,191,219,0,167],
[133,157,163,173,132,227,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1809, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,146,176,136,174,181,178,175],
[195,0,178,138,196,189,177,170],
[165,163,0,133,174,165,205,163],
[205,203,208,0,229,163,211,195],
[167,145,167,112,0,160,170,181],
[160,152,176,178,181,0,175,155],
[163,164,136,130,171,166,0,111],
[166,171,178,146,160,186,230,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1810, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,170,173,181,174,186,184],
[173,0,161,176,180,172,170,171],
[171,180,0,181,178,162,169,182],
[168,165,160,0,170,156,158,171],
[160,161,163,171,0,159,168,178],
[167,169,179,185,182,0,186,187],
[155,171,172,183,173,155,0,171],
[157,170,159,170,163,154,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1811, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,157,166,159,156,181,173],
[163,0,150,147,157,141,158,149],
[184,191,0,159,186,155,180,180],
[175,194,182,0,188,166,178,181],
[182,184,155,153,0,157,177,171],
[185,200,186,175,184,0,186,166],
[160,183,161,163,164,155,0,162],
[168,192,161,160,170,175,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1812, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,170,156,184,160,172,176],
[176,0,168,171,193,168,187,166],
[171,173,0,157,178,156,179,174],
[185,170,184,0,190,182,171,179],
[157,148,163,151,0,156,159,167],
[181,173,185,159,185,0,174,175],
[169,154,162,170,182,167,0,163],
[165,175,167,162,174,166,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1813, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,192,173,184,194,198,154],
[162,0,160,193,201,189,202,154],
[149,181,0,184,196,188,217,183],
[168,148,157,0,192,178,164,154],
[157,140,145,149,0,196,162,128],
[147,152,153,163,145,0,165,120],
[143,139,124,177,179,176,0,146],
[187,187,158,187,213,221,195,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1814, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,186,184,160,187,190,189],
[173,0,176,169,170,146,187,165],
[155,165,0,169,160,165,189,182],
[157,172,172,0,194,168,177,189],
[181,171,181,147,0,171,187,210],
[154,195,176,173,170,0,185,164],
[151,154,152,164,154,156,0,160],
[152,176,159,152,131,177,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1815, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,151,190,146,149,169,167,204],
[190,0,180,168,175,212,196,186],
[151,161,0,134,162,147,168,166],
[195,173,207,0,164,197,213,192],
[192,166,179,177,0,167,195,200],
[172,129,194,144,174,0,164,180],
[174,145,173,128,146,177,0,155],
[137,155,175,149,141,161,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1816, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,183,173,164,171,177,177],
[181,0,187,170,177,182,180,185],
[158,154,0,146,172,166,160,149],
[168,171,195,0,168,176,187,180],
[177,164,169,173,0,179,186,174],
[170,159,175,165,162,0,176,163],
[164,161,181,154,155,165,0,167],
[164,156,192,161,167,178,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1817, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,169,149,157,146,180,150],
[180,0,176,175,145,163,158,133],
[172,165,0,141,182,139,160,165],
[192,166,200,0,183,200,192,168],
[184,196,159,158,0,191,177,179],
[195,178,202,141,150,0,160,166],
[161,183,181,149,164,181,0,152],
[191,208,176,173,162,175,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1818, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,146,119,183,184,130,146,197],
[195,0,172,183,173,147,159,237],
[222,169,0,236,262,198,209,225],
[158,158,105,0,160,151,162,197],
[157,168,79,181,0,170,132,169],
[211,194,143,190,171,0,182,195],
[195,182,132,179,209,159,0,169],
[144,104,116,144,172,146,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1819, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,171,163,171,174,161,155],
[181,0,174,163,171,170,159,162],
[170,167,0,176,178,182,159,163],
[178,178,165,0,171,166,179,164],
[170,170,163,170,0,177,168,152],
[167,171,159,175,164,0,154,151],
[180,182,182,162,173,187,0,184],
[186,179,178,177,189,190,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1820, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,145,174,155,156,159,164],
[176,0,146,161,155,154,159,174],
[196,195,0,189,167,180,177,188],
[167,180,152,0,162,168,177,171],
[186,186,174,179,0,179,186,165],
[185,187,161,173,162,0,173,184],
[182,182,164,164,155,168,0,171],
[177,167,153,170,176,157,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1821, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,118,158,198,197,158,199,177],
[223,0,138,160,198,123,118,223],
[183,203,0,220,181,181,180,163],
[143,181,121,0,199,120,162,180],
[144,143,160,142,0,142,140,145],
[183,218,160,221,199,0,182,218],
[142,223,161,179,201,159,0,182],
[164,118,178,161,196,123,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1822, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,144,154,135,161,190,187,141],
[197,0,157,152,170,182,198,175],
[187,184,0,155,130,174,182,171],
[206,189,186,0,171,194,206,164],
[180,171,211,170,0,207,213,169],
[151,159,167,147,134,0,173,108],
[154,143,159,135,128,168,0,151],
[200,166,170,177,172,233,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1823, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,192,172,169,187,173,171],
[156,0,179,159,150,165,167,159],
[149,162,0,165,143,157,161,143],
[169,182,176,0,161,167,173,163],
[172,191,198,180,0,184,177,169],
[154,176,184,174,157,0,176,147],
[168,174,180,168,164,165,0,153],
[170,182,198,178,172,194,188,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1824, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,168,157,180,153,174,169],
[166,0,164,174,176,167,176,175],
[173,177,0,170,176,150,193,178],
[184,167,171,0,181,158,177,180],
[161,165,165,160,0,141,182,182],
[188,174,191,183,200,0,190,169],
[167,165,148,164,159,151,0,156],
[172,166,163,161,159,172,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1825, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,199,142,159,161,177,171,157],
[142,0,143,170,143,173,151,152],
[199,198,0,190,194,197,152,174],
[182,171,151,0,164,192,141,185],
[180,198,147,177,0,202,155,174],
[164,168,144,149,139,0,151,143],
[170,190,189,200,186,190,0,167],
[184,189,167,156,167,198,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1826, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,180,168,197,188,194,184],
[160,0,156,169,155,175,163,162],
[161,185,0,180,194,154,161,196],
[173,172,161,0,182,140,181,175],
[144,186,147,159,0,163,172,189],
[153,166,187,201,178,0,176,184],
[147,178,180,160,169,165,0,185],
[157,179,145,166,152,157,156,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1827, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,175,175,176,168,160,175],
[170,0,173,173,164,177,158,177],
[166,168,0,170,175,170,165,178],
[166,168,171,0,163,167,164,162],
[165,177,166,178,0,165,177,180],
[173,164,171,174,176,0,164,176],
[181,183,176,177,164,177,0,186],
[166,164,163,179,161,165,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1828, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,182,156,162,186,170,171],
[169,0,161,162,157,180,153,173],
[159,180,0,172,167,182,166,169],
[185,179,169,0,172,187,172,168],
[179,184,174,169,0,184,177,170],
[155,161,159,154,157,0,150,146],
[171,188,175,169,164,191,0,176],
[170,168,172,173,171,195,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1829, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,150,182,167,173,154,159,180],
[191,0,176,179,174,177,165,187],
[159,165,0,161,157,160,158,166],
[174,162,180,0,169,170,172,182],
[168,167,184,172,0,164,174,176],
[187,164,181,171,177,0,170,180],
[182,176,183,169,167,171,0,179],
[161,154,175,159,165,161,162,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1830, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,172,169,172,180,189,175],
[168,0,159,174,167,167,176,158],
[169,182,0,180,173,178,185,191],
[172,167,161,0,156,181,173,176],
[169,174,168,185,0,187,182,173],
[161,174,163,160,154,0,173,170],
[152,165,156,168,159,168,0,166],
[166,183,150,165,168,171,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1831, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,169,184,181,185,171,166],
[157,0,156,156,168,146,163,167],
[172,185,0,162,183,167,178,169],
[157,185,179,0,173,184,190,186],
[160,173,158,168,0,174,168,166],
[156,195,174,157,167,0,167,176],
[170,178,163,151,173,174,0,176],
[175,174,172,155,175,165,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1832, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,190,172,174,173,165,159,167],
[151,0,149,146,156,160,157,164],
[169,192,0,173,163,170,167,168],
[167,195,168,0,170,181,178,172],
[168,185,178,171,0,169,180,164],
[176,181,171,160,172,0,152,172],
[182,184,174,163,161,189,0,181],
[174,177,173,169,177,169,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1833, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,169,162,169,183,171,163],
[173,0,178,155,174,176,172,179],
[172,163,0,144,169,188,168,170],
[179,186,197,0,190,180,164,162],
[172,167,172,151,0,172,163,159],
[158,165,153,161,169,0,169,165],
[170,169,173,177,178,172,0,176],
[178,162,171,179,182,176,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1834, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,178,175,166,176,179,186],
[169,0,179,181,168,172,158,183],
[163,162,0,167,153,154,166,175],
[166,160,174,0,162,174,172,179],
[175,173,188,179,0,182,168,190],
[165,169,187,167,159,0,143,174],
[162,183,175,169,173,198,0,197],
[155,158,166,162,151,167,144,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1835, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,146,198,153,172,162,180],
[185,0,174,181,163,177,160,173],
[195,167,0,199,195,183,200,187],
[143,160,142,0,148,160,165,146],
[188,178,146,193,0,178,173,172],
[169,164,158,181,163,0,174,158],
[179,181,141,176,168,167,0,161],
[161,168,154,195,169,183,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1836, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,163,154,163,160,162,178],
[183,0,163,164,156,175,174,189],
[178,178,0,169,171,167,177,178],
[187,177,172,0,172,167,165,191],
[178,185,170,169,0,176,177,185],
[181,166,174,174,165,0,172,183],
[179,167,164,176,164,169,0,181],
[163,152,163,150,156,158,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1837, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,173,193,181,177,167,157],
[160,0,168,178,171,162,170,154],
[168,173,0,188,189,163,162,172],
[148,163,153,0,166,165,153,147],
[160,170,152,175,0,163,167,146],
[164,179,178,176,178,0,154,157],
[174,171,179,188,174,187,0,164],
[184,187,169,194,195,184,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1838, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,147,155,164,155,184,177,148],
[194,0,180,186,172,179,179,163],
[186,161,0,165,164,184,185,163],
[177,155,176,0,173,201,184,161],
[186,169,177,168,0,187,193,171],
[157,162,157,140,154,0,191,143],
[164,162,156,157,148,150,0,147],
[193,178,178,180,170,198,194,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1839, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,176,165,168,167,169,160],
[158,0,177,165,162,167,206,177],
[165,164,0,164,175,175,175,147],
[176,176,177,0,194,178,186,164],
[173,179,166,147,0,172,178,150],
[174,174,166,163,169,0,184,168],
[172,135,166,155,163,157,0,155],
[181,164,194,177,191,173,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1840, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,123,128,141,179,196,179,158],
[218,0,149,183,198,216,184,233],
[213,192,0,178,142,231,196,175],
[200,158,163,0,177,195,146,159],
[162,143,199,164,0,235,220,163],
[145,125,110,146,106,0,147,142],
[162,157,145,195,121,194,0,175],
[183,108,166,182,178,199,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1841, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,168,147,137,187,196,194],
[187,0,143,160,131,177,176,205],
[173,198,0,187,183,165,183,184],
[194,181,154,0,149,196,181,192],
[204,210,158,192,0,182,206,204],
[154,164,176,145,159,0,202,215],
[145,165,158,160,135,139,0,206],
[147,136,157,149,137,126,135,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1842, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,177,163,165,167,170,173],
[167,0,183,148,176,174,173,157],
[164,158,0,152,157,152,160,167],
[178,193,189,0,165,179,193,172],
[176,165,184,176,0,154,174,178],
[174,167,189,162,187,0,179,168],
[171,168,181,148,167,162,0,153],
[168,184,174,169,163,173,188,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1843, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,171,180,193,181,169,182],
[169,0,164,170,178,158,178,184],
[170,177,0,189,184,175,184,175],
[161,171,152,0,176,165,167,172],
[148,163,157,165,0,154,162,156],
[160,183,166,176,187,0,186,176],
[172,163,157,174,179,155,0,170],
[159,157,166,169,185,165,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1844, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,159,187,166,161,192,165],
[188,0,153,185,171,178,174,164],
[182,188,0,198,199,155,197,184],
[154,156,143,0,156,153,181,152],
[175,170,142,185,0,138,158,162],
[180,163,186,188,203,0,187,170],
[149,167,144,160,183,154,0,152],
[176,177,157,189,179,171,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1845, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,162,161,156,132,145,155],
[181,0,164,147,175,187,171,165],
[179,177,0,157,169,149,165,159],
[180,194,184,0,193,159,171,194],
[185,166,172,148,0,141,157,167],
[209,154,192,182,200,0,191,199],
[196,170,176,170,184,150,0,178],
[186,176,182,147,174,142,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1846, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,162,154,163,151,160,178],
[188,0,175,175,167,168,171,185],
[179,166,0,166,169,162,162,182],
[187,166,175,0,180,172,171,179],
[178,174,172,161,0,152,165,173],
[190,173,179,169,189,0,170,190],
[181,170,179,170,176,171,0,192],
[163,156,159,162,168,151,149,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1847, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,147,167,158,151,153,172,167],
[194,0,181,167,183,183,192,158],
[174,160,0,158,181,165,159,164],
[183,174,183,0,169,153,187,174],
[190,158,160,172,0,167,181,176],
[188,158,176,188,174,0,183,155],
[169,149,182,154,160,158,0,172],
[174,183,177,167,165,186,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1848, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,185,173,155,171,172,175],
[152,0,161,140,150,157,153,168],
[156,180,0,158,151,158,166,170],
[168,201,183,0,165,174,190,176],
[186,191,190,176,0,182,165,188],
[170,184,183,167,159,0,180,171],
[169,188,175,151,176,161,0,163],
[166,173,171,165,153,170,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1849, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,176,166,171,175,179,173],
[154,0,178,163,148,157,160,158],
[165,163,0,158,162,155,170,172],
[175,178,183,0,177,163,178,173],
[170,193,179,164,0,171,184,170],
[166,184,186,178,170,0,167,169],
[162,181,171,163,157,174,0,176],
[168,183,169,168,171,172,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1850, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,164,169,187,159,182,187],
[185,0,177,185,189,166,170,185],
[177,164,0,178,191,177,182,201],
[172,156,163,0,173,161,169,174],
[154,152,150,168,0,140,159,182],
[182,175,164,180,201,0,191,194],
[159,171,159,172,182,150,0,162],
[154,156,140,167,159,147,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1851, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,169,196,182,174,179,187],
[180,0,177,185,166,161,166,167],
[172,164,0,178,158,175,187,185],
[145,156,163,0,191,160,171,172],
[159,175,183,150,0,143,185,170],
[167,180,166,181,198,0,182,182],
[162,175,154,170,156,159,0,157],
[154,174,156,169,171,159,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1852, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,168,183,189,193,185,189],
[167,0,162,184,177,188,163,171],
[173,179,0,193,175,188,170,186],
[158,157,148,0,174,173,148,159],
[152,164,166,167,0,178,158,154],
[148,153,153,168,163,0,150,160],
[156,178,171,193,183,191,0,176],
[152,170,155,182,187,181,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1853, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,174,165,182,183,190,163],
[169,0,183,152,170,180,165,170],
[167,158,0,172,171,181,175,173],
[176,189,169,0,201,181,176,172],
[159,171,170,140,0,165,165,167],
[158,161,160,160,176,0,169,187],
[151,176,166,165,176,172,0,166],
[178,171,168,169,174,154,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1854, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,165,171,192,181,174,176],
[154,0,163,154,191,179,169,179],
[176,178,0,156,189,187,195,178],
[170,187,185,0,198,193,179,190],
[149,150,152,143,0,167,172,154],
[160,162,154,148,174,0,161,175],
[167,172,146,162,169,180,0,183],
[165,162,163,151,187,166,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1855, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,164,163,167,170,171,170,163],
[177,0,157,157,169,155,169,165],
[178,184,0,170,166,175,173,182],
[174,184,171,0,174,171,154,181],
[171,172,175,167,0,171,175,167],
[170,186,166,170,170,0,169,172],
[171,172,168,187,166,172,0,177],
[178,176,159,160,174,169,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1856, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,163,167,169,167,183,172],
[164,0,175,182,158,177,173,187],
[178,166,0,185,170,172,181,188],
[174,159,156,0,173,164,169,171],
[172,183,171,168,0,174,182,195],
[174,164,169,177,167,0,170,184],
[158,168,160,172,159,171,0,162],
[169,154,153,170,146,157,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1857, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,139,184,150,165,185,170],
[163,0,179,224,160,200,195,182],
[202,162,0,158,196,160,189,173],
[157,117,183,0,138,170,167,165],
[191,181,145,203,0,204,190,217],
[176,141,181,171,137,0,171,151],
[156,146,152,174,151,170,0,172],
[171,159,168,176,124,190,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1858, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,159,160,168,191,162,167,173],
[182,0,160,179,188,162,156,165],
[181,181,0,184,178,167,167,187],
[173,162,157,0,178,158,159,166],
[150,153,163,163,0,152,168,166],
[179,179,174,183,189,0,181,170],
[174,185,174,182,173,160,0,181],
[168,176,154,175,175,171,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1859, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,166,161,164,178,187,184],
[168,0,170,163,172,174,167,167],
[175,171,0,171,174,189,182,170],
[180,178,170,0,170,188,170,168],
[177,169,167,171,0,175,172,172],
[163,167,152,153,166,0,160,159],
[154,174,159,171,169,181,0,166],
[157,174,171,173,169,182,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1860, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,165,160,155,155,156,158],
[178,0,165,170,164,160,164,164],
[176,176,0,178,174,169,177,182],
[181,171,163,0,161,161,181,164],
[186,177,167,180,0,181,183,175],
[186,181,172,180,160,0,156,170],
[185,177,164,160,158,185,0,163],
[183,177,159,177,166,171,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1861, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,171,166,186,173,170,179],
[163,0,161,153,178,163,175,175],
[170,180,0,170,182,166,181,168],
[175,188,171,0,183,169,183,180],
[155,163,159,158,0,164,168,161],
[168,178,175,172,177,0,183,174],
[171,166,160,158,173,158,0,160],
[162,166,173,161,180,167,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1862, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,169,173,174,159,172,163],
[168,0,169,170,173,170,183,157],
[172,172,0,174,161,171,188,168],
[168,171,167,0,170,175,190,156],
[167,168,180,171,0,163,211,174],
[182,171,170,166,178,0,193,162],
[169,158,153,151,130,148,0,149],
[178,184,173,185,167,179,192,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1863, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,149,169,183,141,158,167,163],
[192,0,175,187,165,177,185,180],
[172,166,0,211,175,187,205,185],
[158,154,130,0,137,155,163,149],
[200,176,166,204,0,191,183,178],
[183,164,154,186,150,0,181,149],
[174,156,136,178,158,160,0,154],
[178,161,156,192,163,192,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1864, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,192,197,170,175,178,178],
[162,0,185,159,177,170,179,159],
[149,156,0,161,155,157,171,151],
[144,182,180,0,169,157,183,153],
[171,164,186,172,0,198,196,174],
[166,171,184,184,143,0,170,161],
[163,162,170,158,145,171,0,161],
[163,182,190,188,167,180,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1865, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,167,169,169,180,151,174],
[163,0,164,167,171,186,153,162],
[174,177,0,160,182,195,166,163],
[172,174,181,0,175,170,152,157],
[172,170,159,166,0,177,155,163],
[161,155,146,171,164,0,136,146],
[190,188,175,189,186,205,0,165],
[167,179,178,184,178,195,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1866, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,170,167,169,165,169,168],
[173,0,174,182,186,180,170,166],
[171,167,0,158,154,167,162,167],
[174,159,183,0,161,182,176,169],
[172,155,187,180,0,164,182,173],
[176,161,174,159,177,0,162,153],
[172,171,179,165,159,179,0,160],
[173,175,174,172,168,188,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1867, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,193,194,170,166,193,169],
[167,0,185,174,170,166,176,165],
[148,156,0,172,152,156,173,167],
[147,167,169,0,154,150,157,154],
[171,171,189,187,0,177,177,163],
[175,175,185,191,164,0,183,176],
[148,165,168,184,164,158,0,152],
[172,176,174,187,178,165,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1868, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,184,177,161,190,163,183,176],
[157,0,168,189,189,173,180,181],
[164,173,0,190,181,184,183,191],
[180,152,151,0,185,154,180,172],
[151,152,160,156,0,153,183,154],
[178,168,157,187,188,0,178,163],
[158,161,158,161,158,163,0,154],
[165,160,150,169,187,178,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1869, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,183,194,175,196,166,203],
[166,0,152,175,153,171,177,203],
[158,189,0,176,170,174,177,197],
[147,166,165,0,154,156,160,174],
[166,188,171,187,0,193,172,192],
[145,170,167,185,148,0,185,173],
[175,164,164,181,169,156,0,175],
[138,138,144,167,149,168,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1870, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,168,169,173,173,186,158],
[164,0,178,184,175,159,181,181],
[173,163,0,169,172,176,177,176],
[172,157,172,0,170,171,173,160],
[168,166,169,171,0,169,178,182],
[168,182,165,170,172,0,180,184],
[155,160,164,168,163,161,0,178],
[183,160,165,181,159,157,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1871, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,178,178,202,179,161,182],
[158,0,171,167,178,183,158,167],
[163,170,0,176,189,166,164,165],
[163,174,165,0,201,171,177,175],
[139,163,152,140,0,142,140,168],
[162,158,175,170,199,0,174,184],
[180,183,177,164,201,167,0,187],
[159,174,176,166,173,157,154,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1872, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,205,200,179,167,180,166],
[176,0,169,186,200,171,207,174],
[136,172,0,137,150,143,156,140],
[141,155,204,0,179,164,176,166],
[162,141,191,162,0,190,181,170],
[174,170,198,177,151,0,187,178],
[161,134,185,165,160,154,0,138],
[175,167,201,175,171,163,203,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1873, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,169,164,166,154,155,169],
[170,0,177,172,158,168,147,158],
[172,164,0,175,172,152,171,159],
[177,169,166,0,163,154,165,175],
[175,183,169,178,0,185,159,180],
[187,173,189,187,156,0,168,160],
[186,194,170,176,182,173,0,168],
[172,183,182,166,161,181,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1874, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,162,172,166,160,155,150],
[176,0,139,175,176,159,154,166],
[179,202,0,171,185,169,185,183],
[169,166,170,0,192,176,159,151],
[175,165,156,149,0,143,156,162],
[181,182,172,165,198,0,167,175],
[186,187,156,182,185,174,0,167],
[191,175,158,190,179,166,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1875, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,160,167,172,170,167,171],
[165,0,161,160,175,169,160,174],
[181,180,0,168,176,175,183,189],
[174,181,173,0,186,158,159,179],
[169,166,165,155,0,160,151,154],
[171,172,166,183,181,0,155,166],
[174,181,158,182,190,186,0,182],
[170,167,152,162,187,175,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1876, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,179,173,165,161,156,157],
[185,0,168,182,160,166,169,163],
[162,173,0,165,161,158,154,159],
[168,159,176,0,160,153,177,157],
[176,181,180,181,0,169,173,177],
[180,175,183,188,172,0,166,170],
[185,172,187,164,168,175,0,168],
[184,178,182,184,164,171,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1877, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,160,177,186,163,174,165],
[185,0,171,170,178,162,162,171],
[181,170,0,186,198,177,170,186],
[164,171,155,0,191,164,163,162],
[155,163,143,150,0,151,153,154],
[178,179,164,177,190,0,172,170],
[167,179,171,178,188,169,0,171],
[176,170,155,179,187,171,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1878, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,147,154,159,153,153,166],
[187,0,177,170,174,168,174,175],
[194,164,0,191,174,171,184,182],
[187,171,150,0,160,169,157,179],
[182,167,167,181,0,164,171,180],
[188,173,170,172,177,0,181,179],
[188,167,157,184,170,160,0,171],
[175,166,159,162,161,162,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1879, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,181,170,158,173,189,166],
[168,0,181,167,164,164,176,161],
[160,160,0,155,160,155,173,172],
[171,174,186,0,173,186,166,186],
[183,177,181,168,0,165,167,179],
[168,177,186,155,176,0,174,180],
[152,165,168,175,174,167,0,176],
[175,180,169,155,162,161,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1880, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,169,174,171,173,174,187],
[170,0,166,177,171,173,180,192],
[172,175,0,169,172,190,187,192],
[167,164,172,0,188,198,196,182],
[170,170,169,153,0,176,190,189],
[168,168,151,143,165,0,177,170],
[167,161,154,145,151,164,0,162],
[154,149,149,159,152,171,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1881, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,196,172,165,198,187,188],
[163,0,176,163,167,165,164,172],
[145,165,0,154,178,169,188,175],
[169,178,187,0,176,195,187,179],
[176,174,163,165,0,191,187,177],
[143,176,172,146,150,0,162,160],
[154,177,153,154,154,179,0,175],
[153,169,166,162,164,181,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1882, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,176,173,180,172,166,172],
[168,0,190,180,182,195,189,188],
[165,151,0,178,178,167,167,181],
[168,161,163,0,179,164,155,169],
[161,159,163,162,0,171,159,166],
[169,146,174,177,170,0,161,178],
[175,152,174,186,182,180,0,180],
[169,153,160,172,175,163,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1883, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,168,152,156,167,165,180],
[161,0,170,181,165,166,147,179],
[173,171,0,178,166,164,152,182],
[189,160,163,0,172,168,163,174],
[185,176,175,169,0,177,172,180],
[174,175,177,173,164,0,150,178],
[176,194,189,178,169,191,0,183],
[161,162,159,167,161,163,158,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1884, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,204,173,163,187,175,182,173],
[137,0,163,150,169,152,183,184],
[168,178,0,204,175,199,194,178],
[178,191,137,0,150,173,147,183],
[154,172,166,191,0,154,198,150],
[166,189,142,168,187,0,171,151],
[159,158,147,194,143,170,0,175],
[168,157,163,158,191,190,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1885, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,161,156,161,149,168,161],
[166,0,173,178,183,168,175,159],
[180,168,0,164,172,168,179,165],
[185,163,177,0,176,172,182,156],
[180,158,169,165,0,167,168,172],
[192,173,173,169,174,0,182,171],
[173,166,162,159,173,159,0,168],
[180,182,176,185,169,170,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1886, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,181,179,167,178,183,166,182],
[160,0,168,181,176,161,167,166],
[162,173,0,162,175,171,173,164],
[174,160,179,0,163,167,168,171],
[163,165,166,178,0,171,155,161],
[158,180,170,174,170,0,170,165],
[175,174,168,173,186,171,0,169],
[159,175,177,170,180,176,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1887, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,141,185,179,98,137,155],
[183,0,139,170,134,127,120,98],
[200,202,0,226,181,154,124,139],
[156,171,115,0,151,186,152,113],
[162,207,160,190,0,161,219,160],
[243,214,187,155,180,0,183,183],
[204,221,217,189,122,158,0,157],
[186,243,202,228,181,158,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1888, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,201,186,187,152,221,208,248],
[140,0,169,123,138,142,144,158],
[155,172,0,105,137,139,170,201],
[154,218,236,0,171,251,190,218],
[189,203,204,170,0,205,204,282],
[120,199,202,90,136,0,140,200],
[133,197,171,151,137,201,0,198],
[93,183,140,123,59,141,143,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1889, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,171,158,171,170,154,170],
[175,0,180,169,170,167,164,183],
[170,161,0,170,165,170,166,173],
[183,172,171,0,172,178,163,168],
[170,171,176,169,0,166,164,158],
[171,174,171,163,175,0,170,165],
[187,177,175,178,177,171,0,169],
[171,158,168,173,183,176,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1890, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,171,187,169,181,186,177],
[169,0,160,175,156,169,172,152],
[170,181,0,177,180,188,176,177],
[154,166,164,0,148,170,167,157],
[172,185,161,193,0,182,181,170],
[160,172,153,171,159,0,174,165],
[155,169,165,174,160,167,0,164],
[164,189,164,184,171,176,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1891, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,202,165,134,155,215,211,182],
[139,0,185,142,161,192,224,205],
[176,156,0,188,166,227,171,190],
[207,199,153,0,196,235,193,175],
[186,180,175,145,0,235,209,213],
[126,149,114,106,106,0,167,147],
[130,117,170,148,132,174,0,159],
[159,136,151,166,128,194,182,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1892, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,184,191,172,180,166,178],
[149,0,164,163,164,166,158,172],
[157,177,0,174,168,163,149,178],
[150,178,167,0,159,164,174,170],
[169,177,173,182,0,167,150,179],
[161,175,178,177,174,0,173,159],
[175,183,192,167,191,168,0,181],
[163,169,163,171,162,182,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1893, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,190,169,194,173,188,171],
[176,0,174,175,166,184,181,181],
[151,167,0,161,153,157,164,185],
[172,166,180,0,182,161,173,180],
[147,175,188,159,0,141,186,157],
[168,157,184,180,200,0,173,180],
[153,160,177,168,155,168,0,135],
[170,160,156,161,184,161,206,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1894, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,122,157,121,158,147,128,165],
[219,0,198,191,179,165,185,182],
[184,143,0,128,140,165,122,135],
[220,150,213,0,177,158,175,182],
[183,162,201,164,0,160,180,159],
[194,176,176,183,181,0,155,147],
[213,156,219,166,161,186,0,189],
[176,159,206,159,182,194,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1895, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,180,174,164,174,181,175],
[165,0,179,158,160,183,172,175],
[161,162,0,154,172,156,161,157],
[167,183,187,0,179,186,173,156],
[177,181,169,162,0,175,170,178],
[167,158,185,155,166,0,166,148],
[160,169,180,168,171,175,0,158],
[166,166,184,185,163,193,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1896, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,194,207,160,182,176,191,196],
[147,0,202,155,167,168,158,175],
[134,139,0,163,170,165,160,172],
[181,186,178,0,150,183,173,208],
[159,174,171,191,0,164,168,180],
[165,173,176,158,177,0,165,189],
[150,183,181,168,173,176,0,211],
[145,166,169,133,161,152,130,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1897, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,153,152,160,93,164,145],
[181,0,200,182,158,135,181,127],
[188,141,0,151,152,135,151,117],
[189,159,190,0,199,153,190,162],
[181,183,189,142,0,127,176,174],
[248,206,206,188,214,0,204,134],
[177,160,190,151,165,137,0,165],
[196,214,224,179,167,207,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1898, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,179,166,181,181,165,185],
[152,0,173,154,171,160,163,152],
[162,168,0,154,187,164,149,190],
[175,187,187,0,180,187,170,188],
[160,170,154,161,0,162,165,156],
[160,181,177,154,179,0,180,177],
[176,178,192,171,176,161,0,169],
[156,189,151,153,185,164,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1899, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,178,174,170,194,190,158],
[170,0,173,154,171,178,190,160],
[163,168,0,156,158,196,184,172],
[167,187,185,0,182,196,206,181],
[171,170,183,159,0,186,201,175],
[147,163,145,145,155,0,178,154],
[151,151,157,135,140,163,0,169],
[183,181,169,160,166,187,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1900, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,167,173,146,174,221,167],
[169,0,154,159,146,160,207,177],
[174,187,0,171,187,187,210,168],
[168,182,170,0,164,194,198,183],
[195,195,154,177,0,177,202,171],
[167,181,154,147,164,0,183,167],
[120,134,131,143,139,158,0,142],
[174,164,173,158,170,174,199,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1901, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,172,172,170,162,165,171],
[172,0,177,159,173,185,169,180],
[169,164,0,166,171,175,179,176],
[169,182,175,0,182,191,178,188],
[171,168,170,159,0,173,169,171],
[179,156,166,150,168,0,163,162],
[176,172,162,163,172,178,0,171],
[170,161,165,153,170,179,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1902, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,145,171,192,172,182,156,179],
[196,0,166,179,189,185,178,172],
[170,175,0,184,187,199,178,177],
[149,162,157,0,177,165,163,174],
[169,152,154,164,0,169,163,167],
[159,156,142,176,172,0,152,170],
[185,163,163,178,178,189,0,196],
[162,169,164,167,174,171,145,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1903, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,163,157,155,180,156,169],
[173,0,153,152,144,174,146,169],
[178,188,0,176,171,179,165,174],
[184,189,165,0,162,178,164,181],
[186,197,170,179,0,192,164,180],
[161,167,162,163,149,0,157,154],
[185,195,176,177,177,184,0,170],
[172,172,167,160,161,187,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1904, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,174,141,169,130,167,175],
[175,0,166,154,155,160,150,169],
[167,175,0,167,171,153,130,157],
[200,187,174,0,171,173,151,170],
[172,186,170,170,0,155,152,165],
[211,181,188,168,186,0,172,189],
[174,191,211,190,189,169,0,177],
[166,172,184,171,176,152,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1905, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,173,173,162,176,182,171],
[178,0,182,189,174,185,189,168],
[168,159,0,182,161,173,179,153],
[168,152,159,0,157,175,168,160],
[179,167,180,184,0,175,180,179],
[165,156,168,166,166,0,171,151],
[159,152,162,173,161,170,0,158],
[170,173,188,181,162,190,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1906, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,162,162,200,173,184,187,170],
[179,0,184,191,153,190,176,168],
[179,157,0,196,143,168,173,163],
[141,150,145,0,129,173,163,166],
[168,188,198,212,0,207,191,190],
[157,151,173,168,134,0,165,155],
[154,165,168,178,150,176,0,166],
[171,173,178,175,151,186,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1907, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,188,173,172,177,173,170],
[152,0,140,165,152,165,144,153],
[153,201,0,166,174,190,162,153],
[168,176,175,0,169,178,168,158],
[169,189,167,172,0,197,169,156],
[164,176,151,163,144,0,171,162],
[168,197,179,173,172,170,0,176],
[171,188,188,183,185,179,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1908, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,160,169,182,165,190,168,186],
[181,0,180,174,187,187,170,188],
[172,161,0,157,160,189,168,163],
[159,167,184,0,149,191,170,162],
[176,154,181,192,0,197,183,194],
[151,154,152,150,144,0,151,175],
[173,171,173,171,158,190,0,167],
[155,153,178,179,147,166,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1909, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,171,153,149,152,147,159],
[170,0,129,152,162,138,137,159],
[170,212,0,164,211,180,166,174],
[188,189,177,0,189,155,184,182],
[192,179,130,152,0,134,163,148],
[189,203,161,186,207,0,168,181],
[194,204,175,157,178,173,0,161],
[182,182,167,159,193,160,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1910, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,180,171,159,181,179,167],
[167,0,168,171,156,172,176,174],
[161,173,0,154,152,173,173,152],
[170,170,187,0,171,190,193,173],
[182,185,189,170,0,185,184,172],
[160,169,168,151,156,0,161,162],
[162,165,168,148,157,180,0,170],
[174,167,189,168,169,179,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1911, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,173,162,139,137,145,157],
[166,0,192,188,154,156,181,198],
[168,149,0,189,176,176,157,185],
[179,153,152,0,151,138,148,146],
[202,187,165,190,0,164,157,184],
[204,185,165,203,177,0,179,187],
[196,160,184,193,184,162,0,151],
[184,143,156,195,157,154,190,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1912, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,170,175,193,171,179,166],
[170,0,179,176,173,191,191,177],
[171,162,0,173,165,168,187,164],
[166,165,168,0,171,165,169,160],
[148,168,176,170,0,181,174,157],
[170,150,173,176,160,0,173,166],
[162,150,154,172,167,168,0,153],
[175,164,177,181,184,175,188,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1913, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,186,174,170,181,186,168],
[168,0,198,174,176,178,180,167],
[155,143,0,156,157,166,160,143],
[167,167,185,0,162,168,171,164],
[171,165,184,179,0,176,181,174],
[160,163,175,173,165,0,168,173],
[155,161,181,170,160,173,0,170],
[173,174,198,177,167,168,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1914, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,178,157,168,174,155,151],
[167,0,179,188,188,199,175,185],
[163,162,0,171,165,177,160,167],
[184,153,170,0,179,186,162,169],
[173,153,176,162,0,163,153,149],
[167,142,164,155,178,0,168,155],
[186,166,181,179,188,173,0,181],
[190,156,174,172,192,186,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1915, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,156,176,153,150,166,172],
[161,0,165,161,163,171,172,176],
[185,176,0,183,172,171,162,166],
[165,180,158,0,156,159,161,167],
[188,178,169,185,0,173,173,182],
[191,170,170,182,168,0,169,168],
[175,169,179,180,168,172,0,165],
[169,165,175,174,159,173,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1916, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,183,170,180,204,194,174,179],
[158,0,148,152,176,167,159,184],
[171,193,0,174,174,175,168,188],
[161,189,167,0,194,186,179,178],
[137,165,167,147,0,164,154,164],
[147,174,166,155,177,0,164,162],
[167,182,173,162,187,177,0,205],
[162,157,153,163,177,179,136,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1917, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,187,163,182,172,178,177],
[170,0,170,162,174,149,181,173],
[154,171,0,157,165,161,166,164],
[178,179,184,0,185,177,172,164],
[159,167,176,156,0,152,168,162],
[169,192,180,164,189,0,177,190],
[163,160,175,169,173,164,0,181],
[164,168,177,177,179,151,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1918, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,243,152,200,236,169,183,204],
[98,0,140,160,137,149,140,166],
[189,201,0,215,173,194,169,214],
[141,181,126,0,141,106,137,185],
[105,204,168,200,0,181,189,202],
[172,192,147,235,160,0,168,206],
[158,201,172,204,152,173,0,217],
[137,175,127,156,139,135,124,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1919, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,141,157,139,145,146,153],
[188,0,181,200,163,172,174,179],
[200,160,0,180,175,163,175,189],
[184,141,161,0,175,176,185,196],
[202,178,166,166,0,148,183,170],
[196,169,178,165,193,0,166,174],
[195,167,166,156,158,175,0,177],
[188,162,152,145,171,167,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1920, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,184,181,174,172,204,159],
[174,0,169,166,176,161,170,170],
[157,172,0,168,182,158,184,156],
[160,175,173,0,166,165,172,147],
[167,165,159,175,0,155,169,177],
[169,180,183,176,186,0,201,180],
[137,171,157,169,172,140,0,164],
[182,171,185,194,164,161,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1921, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,149,151,199,149,150,174,153],
[192,0,170,201,167,165,172,187],
[190,171,0,182,176,179,190,155],
[142,140,159,0,132,147,178,163],
[192,174,165,209,0,156,184,184],
[191,176,162,194,185,0,197,181],
[167,169,151,163,157,144,0,156],
[188,154,186,178,157,160,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1922, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,235,170,191,193,124,167,233],
[106,0,109,189,131,105,171,171],
[171,232,0,212,172,148,211,233],
[150,152,129,0,130,190,148,213],
[148,210,169,211,0,166,188,234],
[217,236,193,151,175,0,216,234],
[174,170,130,193,153,125,0,214],
[108,170,108,128,107,107,127,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1923, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,174,159,188,165,209,180,175],
[167,0,187,183,172,187,176,182],
[182,154,0,170,154,189,160,172],
[153,158,171,0,161,187,189,160],
[176,169,187,180,0,188,149,184],
[132,154,152,154,153,0,143,146],
[161,165,181,152,192,198,0,167],
[166,159,169,181,157,195,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1924, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,167,152,158,154,167,166],
[185,0,189,170,180,167,175,185],
[174,152,0,160,167,170,162,166],
[189,171,181,0,166,171,179,171],
[183,161,174,175,0,168,169,162],
[187,174,171,170,173,0,195,175],
[174,166,179,162,172,146,0,180],
[175,156,175,170,179,166,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1925, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,180,161,182,174,165,157],
[183,0,181,165,191,196,149,171],
[161,160,0,132,159,160,151,190],
[180,176,209,0,175,195,161,193],
[159,150,182,166,0,186,173,162],
[167,145,181,146,155,0,135,151],
[176,192,190,180,168,206,0,198],
[184,170,151,148,179,190,143,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1926, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,186,169,173,178,182,182],
[165,0,165,175,168,169,171,170],
[155,176,0,163,172,164,163,165],
[172,166,178,0,169,172,179,174],
[168,173,169,172,0,184,192,182],
[163,172,177,169,157,0,167,175],
[159,170,178,162,149,174,0,173],
[159,171,176,167,159,166,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1927, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,174,169,192,175,179,178],
[163,0,174,159,189,158,183,156],
[167,167,0,171,199,198,160,169],
[172,182,170,0,187,183,180,169],
[149,152,142,154,0,158,171,152],
[166,183,143,158,183,0,154,148],
[162,158,181,161,170,187,0,178],
[163,185,172,172,189,193,163,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1928, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,139,162,171,161,176,160,166],
[202,0,167,168,199,186,193,174],
[179,174,0,170,183,193,177,174],
[170,173,171,0,177,180,175,172],
[180,142,158,164,0,177,161,153],
[165,155,148,161,164,0,149,165],
[181,148,164,166,180,192,0,169],
[175,167,167,169,188,176,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1929, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,177,159,164,162,165,154],
[174,0,177,158,173,174,162,157],
[164,164,0,163,153,169,147,155],
[182,183,178,0,184,169,166,173],
[177,168,188,157,0,187,155,162],
[179,167,172,172,154,0,157,156],
[176,179,194,175,186,184,0,161],
[187,184,186,168,179,185,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1930, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,179,175,180,181,165,170],
[169,0,181,176,176,176,158,174],
[162,160,0,155,177,161,160,157],
[166,165,186,0,166,172,164,176],
[161,165,164,175,0,165,155,167],
[160,165,180,169,176,0,159,162],
[176,183,181,177,186,182,0,167],
[171,167,184,165,174,179,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1931, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,148,149,161,171,171,150,148],
[193,0,166,164,179,176,190,168],
[192,175,0,181,179,162,182,161],
[180,177,160,0,152,173,181,159],
[170,162,162,189,0,167,189,148],
[170,165,179,168,174,0,183,171],
[191,151,159,160,152,158,0,152],
[193,173,180,182,193,170,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1932, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,190,180,191,168,188,194,181],
[151,0,162,179,169,176,170,161],
[161,179,0,188,182,169,168,170],
[150,162,153,0,134,156,159,160],
[173,172,159,207,0,183,179,176],
[153,165,172,185,158,0,165,152],
[147,171,173,182,162,176,0,171],
[160,180,171,181,165,189,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1933, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,177,173,192,180,176,167,177],
[164,0,158,173,162,166,155,148],
[168,183,0,182,171,173,163,173],
[149,168,159,0,160,161,148,157],
[161,179,170,181,0,179,173,155],
[165,175,168,180,162,0,160,159],
[174,186,178,193,168,181,0,170],
[164,193,168,184,186,182,171,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1934, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,163,178,175,173,174,168],
[166,0,163,177,165,156,157,182],
[178,178,0,181,153,166,169,185],
[163,164,160,0,154,163,162,157],
[166,176,188,187,0,185,185,185],
[168,185,175,178,156,0,177,178],
[167,184,172,179,156,164,0,165],
[173,159,156,184,156,163,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1935, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,189,159,161,180,186,174],
[165,0,178,163,165,170,175,170],
[152,163,0,171,165,165,168,162],
[182,178,170,0,171,159,178,162],
[180,176,176,170,0,170,174,176],
[161,171,176,182,171,0,169,166],
[155,166,173,163,167,172,0,155],
[167,171,179,179,165,175,186,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1936, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,189,165,174,199,181,191],
[163,0,170,170,169,167,181,171],
[152,171,0,168,164,192,166,179],
[176,171,173,0,168,173,176,184],
[167,172,177,173,0,187,173,185],
[142,174,149,168,154,0,169,162],
[160,160,175,165,168,172,0,169],
[150,170,162,157,156,179,172,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1937, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,180,153,170,174,178,172,173],
[161,0,157,147,155,173,150,156],
[188,184,0,170,162,176,178,168],
[171,194,171,0,166,184,176,176],
[167,186,179,175,0,183,170,172],
[163,168,165,157,158,0,162,150],
[169,191,163,165,171,179,0,165],
[168,185,173,165,169,191,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1938, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,164,144,170,160,174,161],
[187,0,175,183,208,175,192,140],
[177,166,0,168,204,202,237,151],
[197,158,173,0,188,188,183,153],
[171,133,137,153,0,150,168,155],
[181,166,139,153,191,0,172,177],
[167,149,104,158,173,169,0,152],
[180,201,190,188,186,164,189,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1939, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,169,169,174,179,192,188],
[170,0,183,158,145,139,168,170],
[172,158,0,158,154,165,174,177],
[172,183,183,0,187,153,188,190],
[167,196,187,154,0,156,185,191],
[162,202,176,188,185,0,164,200],
[149,173,167,153,156,177,0,182],
[153,171,164,151,150,141,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1940, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,174,174,173,154,177,165],
[173,0,167,184,172,169,166,176],
[167,174,0,189,180,179,180,182],
[167,157,152,0,156,165,154,161],
[168,169,161,185,0,165,169,180],
[187,172,162,176,176,0,186,166],
[164,175,161,187,172,155,0,175],
[176,165,159,180,161,175,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1941, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,176,189,155,172,170,182,178],
[165,0,174,169,182,176,179,173],
[152,167,0,167,174,177,160,158],
[186,172,174,0,171,173,170,178],
[169,159,167,170,0,176,171,173],
[171,165,164,168,165,0,171,168],
[159,162,181,171,170,170,0,172],
[163,168,183,163,168,173,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1942, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,157,135,128,150,135,170],
[174,0,164,164,145,147,130,171],
[184,177,0,183,173,165,162,182],
[206,177,158,0,142,152,171,190],
[213,196,168,199,0,175,174,190],
[191,194,176,189,166,0,176,198],
[206,211,179,170,167,165,0,180],
[171,170,159,151,151,143,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1943, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,171,163,153,185,163,166],
[156,0,155,189,157,201,145,137],
[170,186,0,201,191,195,198,176],
[178,152,140,0,138,157,173,138],
[188,184,150,203,0,177,168,180],
[156,140,146,184,164,0,145,132],
[178,196,143,168,173,196,0,202],
[175,204,165,203,161,209,139,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1944, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,176,171,192,201,186,190],
[175,0,167,186,199,203,179,198],
[165,174,0,145,188,223,189,171],
[170,155,196,0,209,223,188,191],
[149,142,153,132,0,147,169,158],
[140,138,118,118,194,0,151,151],
[155,162,152,153,172,190,0,188],
[151,143,170,150,183,190,153,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1945, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,180,220,186,191,178,183],
[172,0,159,201,187,173,184,191],
[161,182,0,191,173,174,185,187],
[121,140,150,0,154,151,137,153],
[155,154,168,187,0,162,155,167],
[150,168,167,190,179,0,169,169],
[163,157,156,204,186,172,0,186],
[158,150,154,188,174,172,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1946, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,168,159,170,171,175,160],
[173,0,170,173,151,167,172,158],
[173,171,0,184,152,180,185,162],
[182,168,157,0,168,185,171,146],
[171,190,189,173,0,166,189,174],
[170,174,161,156,175,0,173,164],
[166,169,156,170,152,168,0,157],
[181,183,179,195,167,177,184,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1947, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,162,170,176,171,164,154],
[166,0,168,172,162,185,179,173],
[179,173,0,186,168,180,177,173],
[171,169,155,0,169,174,173,162],
[165,179,173,172,0,182,179,178],
[170,156,161,167,159,0,167,159],
[177,162,164,168,162,174,0,161],
[187,168,168,179,163,182,180,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1948, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,180,170,204,220,169,170],
[187,0,197,169,176,192,182,180],
[161,144,0,147,159,207,139,132],
[171,172,194,0,167,186,181,163],
[137,165,182,174,0,186,170,136],
[121,149,134,155,155,0,137,137],
[172,159,202,160,171,204,0,176],
[171,161,209,178,205,204,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1949, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,169,171,179,181,172,179],
[163,0,170,173,182,169,169,179],
[172,171,0,167,190,167,169,165],
[170,168,174,0,168,162,165,167],
[162,159,151,173,0,152,158,168],
[160,172,174,179,189,0,174,174],
[169,172,172,176,183,167,0,184],
[162,162,176,174,173,167,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1950, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,147,136,143,187,205,188,179],
[194,0,163,189,236,227,206,228],
[205,178,0,163,223,190,227,166],
[198,152,178,0,199,214,189,191],
[154,105,118,142,0,141,190,157],
[136,114,151,127,200,0,186,151],
[153,135,114,152,151,155,0,166],
[162,113,175,150,184,190,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1951, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,185,176,166,185,184,180],
[183,0,207,181,178,200,179,167],
[156,134,0,156,142,182,181,144],
[165,160,185,0,168,183,190,162],
[175,163,199,173,0,193,187,170],
[156,141,159,158,148,0,171,132],
[157,162,160,151,154,170,0,154],
[161,174,197,179,171,209,187,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1952, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,168,180,160,175,174,176],
[185,0,170,184,172,187,178,182],
[173,171,0,162,167,184,179,165],
[161,157,179,0,169,180,170,172],
[181,169,174,172,0,160,171,184],
[166,154,157,161,181,0,179,180],
[167,163,162,171,170,162,0,162],
[165,159,176,169,157,161,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1953, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,186,184,168,189,188,172],
[156,0,182,184,157,181,175,166],
[155,159,0,164,151,174,174,139],
[157,157,177,0,160,174,172,153],
[173,184,190,181,0,171,186,164],
[152,160,167,167,170,0,172,155],
[153,166,167,169,155,169,0,160],
[169,175,202,188,177,186,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1954, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,159,128,150,180,153,160],
[168,0,160,172,165,176,142,159],
[182,181,0,177,150,168,141,166],
[213,169,164,0,181,212,170,182],
[191,176,191,160,0,195,176,178],
[161,165,173,129,146,0,147,155],
[188,199,200,171,165,194,0,180],
[181,182,175,159,163,186,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1955, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,151,186,181,159,148,195],
[180,0,160,176,191,158,173,171],
[190,181,0,172,192,167,177,195],
[155,165,169,0,173,155,163,170],
[160,150,149,168,0,148,145,159],
[182,183,174,186,193,0,157,197],
[193,168,164,178,196,184,0,174],
[146,170,146,171,182,144,167,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1956, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,208,191,184,178,196,161,198],
[133,0,163,123,132,171,153,164],
[150,178,0,153,146,181,153,148],
[157,218,188,0,190,186,183,170],
[163,209,195,151,0,198,193,175],
[145,170,160,155,143,0,178,144],
[180,188,188,158,148,163,0,163],
[143,177,193,171,166,197,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1957, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,173,122,146,149,75,25,50],
[168,0,171,121,173,95,47,74],
[219,170,0,172,200,146,125,149],
[195,220,169,0,244,172,96,70],
[192,168,141,97,0,96,145,121],
[266,246,195,169,245,0,172,146],
[316,294,216,245,196,169,0,172],
[291,267,192,271,220,195,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1958, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,149,145,143,170,172,153,168],
[192,0,155,182,187,193,173,166],
[196,186,0,167,158,190,192,196],
[198,159,174,0,180,194,160,203],
[171,154,183,161,0,194,184,171],
[169,148,151,147,147,0,158,167],
[188,168,149,181,157,183,0,189],
[173,175,145,138,170,174,152,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1959, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,159,164,154,155,171,170],
[172,0,164,182,179,178,180,175],
[182,177,0,170,169,169,183,181],
[177,159,171,0,176,162,179,173],
[187,162,172,165,0,161,199,173],
[186,163,172,179,180,0,181,188],
[170,161,158,162,142,160,0,173],
[171,166,160,168,168,153,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1960, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,165,172,156,183,170,162,166],
[176,0,181,173,170,167,165,173],
[169,160,0,151,176,155,155,165],
[185,168,190,0,199,177,181,169],
[158,171,165,142,0,161,146,158],
[171,174,186,164,180,0,163,154],
[179,176,186,160,195,178,0,172],
[175,168,176,172,183,187,169,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1961, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,134,142,134,143,123,143,146],
[207,0,167,151,157,166,164,150],
[199,174,0,137,167,152,124,142],
[207,190,204,0,198,171,176,169],
[198,184,174,143,0,147,168,173],
[218,175,189,170,194,0,189,173],
[198,177,217,165,173,152,0,181],
[195,191,199,172,168,168,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1962, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,168,194,180,190,192,181,190],
[173,0,200,173,185,166,183,178],
[147,141,0,143,169,162,183,182],
[161,168,198,0,181,166,173,189],
[151,156,172,160,0,151,157,182],
[149,175,179,175,190,0,182,192],
[160,158,158,168,184,159,0,177],
[151,163,159,152,159,149,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1963, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,186,193,175,186,187,156,193],
[155,0,156,147,183,185,153,150],
[148,185,0,151,176,202,161,189],
[166,194,190,0,205,192,189,181],
[155,158,165,136,0,189,154,174],
[154,156,139,149,152,0,144,168],
[185,188,180,152,187,197,0,176],
[148,191,152,160,167,173,165,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1964, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,169,156,184,157,181,171,160],
[172,0,157,171,159,169,173,151],
[185,184,0,189,177,171,166,150],
[157,170,152,0,158,168,163,137],
[184,182,164,183,0,186,199,172],
[160,172,170,173,155,0,182,157],
[170,168,175,178,142,159,0,147],
[181,190,191,204,169,184,194,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1965, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,176,174,178,171,172,168],
[169,0,171,163,167,161,171,167],
[165,170,0,166,173,157,169,163],
[167,178,175,0,165,166,176,167],
[163,174,168,176,0,161,177,156],
[170,180,184,175,180,0,181,184],
[169,170,172,165,164,160,0,166],
[173,174,178,174,185,157,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1966, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,148,270,222,122,195,193,198],
[193,0,246,198,170,171,145,197],
[71,95,0,124,144,118,167,147],
[119,143,217,0,146,144,216,198],
[219,171,197,195,0,145,217,195],
[146,170,223,197,196,0,171,196],
[148,196,174,125,124,170,0,148],
[143,144,194,143,146,145,193,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1967, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,187,186,175,174,179,168,182],
[154,0,175,172,165,166,157,175],
[155,166,0,176,161,164,164,174],
[166,169,165,0,161,171,173,173],
[167,176,180,180,0,173,161,170],
[162,175,177,170,168,0,167,184],
[173,184,177,168,180,174,0,184],
[159,166,167,168,171,157,157,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1968, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,158,162,171,163,194,169,164],
[183,0,182,162,176,177,164,163],
[179,159,0,161,163,176,166,163],
[170,179,180,0,175,181,170,183],
[178,165,178,166,0,193,174,170],
[147,164,165,160,148,0,164,160],
[172,177,175,171,167,177,0,163],
[177,178,178,158,171,181,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1969, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,164,170,171,179,173,167],
[174,0,162,165,170,176,162,166],
[177,179,0,170,171,183,179,174],
[171,176,171,0,174,176,163,165],
[170,171,170,167,0,183,174,173],
[162,165,158,165,158,0,169,167],
[168,179,162,178,167,172,0,166],
[174,175,167,176,168,174,175,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1970, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,178,186,188,204,176,142],
[169,0,183,196,208,234,194,172],
[163,158,0,165,182,207,189,158],
[155,145,176,0,196,202,172,127],
[153,133,159,145,0,176,164,140],
[137,107,134,139,165,0,156,124],
[165,147,152,169,177,185,0,147],
[199,169,183,214,201,217,194,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1971, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,176,176,167,177,167,178],
[152,0,165,177,152,159,179,185],
[165,176,0,156,155,156,183,172],
[165,164,185,0,171,150,163,170],
[174,189,186,170,0,187,184,171],
[164,182,185,191,154,0,180,193],
[174,162,158,178,157,161,0,156],
[163,156,169,171,170,148,185,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1972, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,175,191,152,182,179,151],
[170,0,197,207,182,188,185,171],
[166,144,0,174,171,180,177,161],
[150,134,167,0,163,178,165,162],
[189,159,170,178,0,178,194,142],
[159,153,161,163,163,0,174,151],
[162,156,164,176,147,167,0,134],
[190,170,180,179,199,190,207,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1973, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,188,184,186,186,166,185,185],
[153,0,174,163,154,158,166,179],
[157,167,0,153,155,155,181,161],
[155,178,188,0,172,170,190,167],
[155,187,186,169,0,166,183,165],
[175,183,186,171,175,0,175,169],
[156,175,160,151,158,166,0,160],
[156,162,180,174,176,172,181,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1974, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,152,170,184,148,157,148,173],
[189,0,191,188,178,175,156,178],
[171,150,0,167,139,166,167,172],
[157,153,174,0,155,168,154,175],
[193,163,202,186,0,181,173,182],
[184,166,175,173,160,0,165,186],
[193,185,174,187,168,176,0,191],
[168,163,169,166,159,155,150,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1975, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,163,188,189,189,193,195,186],
[178,0,177,187,174,166,183,173],
[153,164,0,175,170,168,174,181],
[152,154,166,0,167,168,172,155],
[152,167,171,174,0,166,180,150],
[148,175,173,173,175,0,188,171],
[146,158,167,169,161,153,0,165],
[155,168,160,186,191,170,176,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1976, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,145,133,173,212,197,208,223],
[196,0,168,170,169,224,157,210],
[208,173,0,210,166,246,194,263],
[168,171,131,0,195,196,220,221],
[129,172,175,146,0,196,223,171],
[144,117,95,145,145,0,198,171],
[133,184,147,121,118,143,0,171],
[118,131,78,120,170,170,170,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1977, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,178,190,178,172,187,169,183],
[163,0,181,172,164,176,167,175],
[151,160,0,168,163,168,170,173],
[163,169,173,0,152,173,163,169],
[169,177,178,189,0,180,171,176],
[154,165,173,168,161,0,170,162],
[172,174,171,178,170,171,0,180],
[158,166,168,172,165,179,161,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1978, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,179,171,174,157,178,171,162],
[162,0,171,166,174,176,161,160],
[170,170,0,188,159,188,165,149],
[167,175,153,0,154,176,150,158],
[184,167,182,187,0,200,165,144],
[163,165,153,165,141,0,149,153],
[170,180,176,191,176,192,0,175],
[179,181,192,183,197,188,166,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1979, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,161,175,173,172,176,174],
[156,0,177,184,174,164,173,171],
[180,164,0,176,181,176,175,163],
[166,157,165,0,168,173,172,153],
[168,167,160,173,0,187,175,165],
[169,177,165,168,154,0,172,166],
[165,168,166,169,166,169,0,163],
[167,170,178,188,176,175,178,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1980, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,192,173,184,194,152,187,169],
[149,0,142,143,198,143,177,152],
[168,199,0,135,193,129,189,154],
[157,198,206,0,231,177,214,167],
[147,143,148,110,0,130,184,147],
[189,198,212,164,211,0,212,176],
[154,164,152,127,157,129,0,127],
[172,189,187,174,194,165,214,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1981, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,117,170,170,170,191,116,153],
[224,0,147,187,207,189,171,206],
[171,194,0,205,264,188,172,150],
[171,154,136,0,169,152,154,134],
[171,134,77,172,0,152,176,135],
[150,152,153,189,189,0,116,170],
[225,170,169,187,165,225,0,226],
[188,135,191,207,206,171,115,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1982, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,195,137,171,166,177,174,186],
[146,0,148,149,149,168,140,155],
[204,193,0,158,180,178,167,189],
[170,192,183,0,183,199,181,198],
[175,192,161,158,0,173,166,178],
[164,173,163,142,168,0,157,162],
[167,201,174,160,175,184,0,194],
[155,186,152,143,163,179,147,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1983, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,170,167,177,171,179,173,169],
[171,0,178,159,162,168,154,167],
[174,163,0,167,165,187,159,159],
[164,182,174,0,192,179,144,177],
[170,179,176,149,0,169,160,161],
[162,173,154,162,172,0,151,137],
[168,187,182,197,181,190,0,181],
[172,174,182,164,180,204,160,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1984, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,162,165,184,172,177,160],
[159,0,157,164,173,157,153,179],
[179,184,0,191,165,183,169,204],
[176,177,150,0,169,199,152,179],
[157,168,176,172,0,160,145,184],
[169,184,158,142,181,0,147,189],
[164,188,172,189,196,194,0,204],
[181,162,137,162,157,152,137,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1985, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,166,174,184,178,173,173,197],
[175,0,183,186,195,165,183,187],
[167,158,0,182,183,163,170,184],
[157,155,159,0,153,158,146,170],
[163,146,158,188,0,157,159,175],
[168,176,178,183,184,0,183,195],
[168,158,171,195,182,158,0,202],
[144,154,157,171,166,146,139,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1986, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,156,155,169,145,181,163,170],
[185,0,182,169,178,189,185,177],
[186,159,0,175,176,195,178,181],
[172,172,166,0,165,188,186,161],
[196,163,165,176,0,192,179,171],
[160,152,146,153,149,0,167,159],
[178,156,163,155,162,174,0,173],
[171,164,160,180,170,182,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1987, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,175,181,157,163,157,158,177],
[166,0,183,185,165,157,151,165],
[160,158,0,174,149,148,167,147],
[184,156,167,0,153,142,157,169],
[178,176,192,188,0,164,162,161],
[184,184,193,199,177,0,178,170],
[183,190,174,184,179,163,0,186],
[164,176,194,172,180,171,155,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1988, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,182,169,177,172,156,188,183],
[159,0,171,162,173,165,163,151],
[172,170,0,161,169,160,171,155],
[164,179,180,0,181,167,175,160],
[169,168,172,160,0,172,174,170],
[185,176,181,174,169,0,162,179],
[153,178,170,166,167,179,0,168],
[158,190,186,181,171,162,173,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1989, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,171,176,167,158,184,172,169],
[170,0,192,179,176,172,172,168],
[165,149,0,179,171,152,164,165],
[174,162,162,0,165,174,167,147],
[183,165,170,176,0,160,167,156],
[157,169,189,167,181,0,160,182],
[169,169,177,174,174,181,0,167],
[172,173,176,194,185,159,174,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1990, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,159,171,158,161,164,159],
[174,0,163,176,169,161,149,162],
[182,178,0,191,171,170,172,171],
[170,165,150,0,165,154,149,161],
[183,172,170,176,0,164,171,158],
[180,180,171,187,177,0,170,176],
[177,192,169,192,170,171,0,173],
[182,179,170,180,183,165,168,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1991, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,161,175,160,166,166,180,158],
[180,0,194,168,181,199,177,175],
[166,147,0,161,160,177,162,158],
[181,173,180,0,166,183,182,181],
[175,160,181,175,0,208,185,179],
[175,142,164,158,133,0,147,138],
[161,164,179,159,156,194,0,147],
[183,166,183,160,162,203,194,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1992, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,185,185,182,184,184,179,170],
[156,0,163,171,175,175,175,178],
[156,178,0,191,168,167,189,178],
[159,170,150,0,151,159,164,169],
[157,166,173,190,0,163,168,174],
[157,166,174,182,178,0,167,169],
[162,166,152,177,173,174,0,150],
[171,163,163,172,167,172,191,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1993, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,143,155,186,185,167,153,179],
[198,0,170,191,190,184,181,181],
[186,171,0,199,186,186,180,167],
[155,150,142,0,153,139,165,164],
[156,151,155,188,0,137,171,149],
[174,157,155,202,204,0,196,173],
[188,160,161,176,170,145,0,162],
[162,160,174,177,192,168,179,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1994, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,189,182,178,178,192,184,170],
[152,0,163,164,161,177,168,182],
[159,178,0,196,172,190,185,164],
[163,177,145,0,167,182,175,156],
[163,180,169,174,0,174,177,163],
[149,164,151,159,167,0,164,170],
[157,173,156,166,164,177,0,164],
[171,159,177,185,178,171,177,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1995, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,167,176,169,160,155,177,185],
[174,0,190,179,157,175,188,179],
[165,151,0,181,150,164,186,162],
[172,162,160,0,160,175,179,172],
[181,184,191,181,0,156,194,206],
[186,166,177,166,185,0,180,183],
[164,153,155,162,147,161,0,177],
[156,162,179,169,135,158,164,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1996, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,154,169,168,147,161,154,151],
[187,0,185,182,157,157,162,173],
[172,156,0,167,163,166,152,161],
[173,159,174,0,151,164,170,163],
[194,184,178,190,0,167,177,169],
[180,184,175,177,174,0,173,167],
[187,179,189,171,164,168,0,182],
[190,168,180,178,172,174,159,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1997, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,172,182,180,173,169,187,185],
[169,0,173,180,172,167,177,176],
[159,168,0,173,172,154,162,166],
[161,161,168,0,169,167,164,170],
[168,169,169,172,0,169,172,163],
[172,174,187,174,172,0,179,169],
[154,164,179,177,169,162,0,158],
[156,165,175,171,178,172,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1998, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,153,155,144,145,153,152,148],
[188,0,166,169,158,173,176,173],
[186,175,0,162,183,168,185,164],
[197,172,179,0,174,166,189,173],
[196,183,158,167,0,180,189,184],
[188,168,173,175,161,0,183,176],
[189,165,156,152,152,158,0,158],
[193,168,177,168,157,165,183,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 1999, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
##############################################################
om = np.array([
[0,247,244,148,198,173,199,267],
[94,0,146,171,172,196,145,171],
[97,195,0,145,146,143,146,241],
[193,170,196,0,225,197,100,171],
[143,169,195,116,0,143,168,167],
[168,145,198,144,198,0,195,193],
[142,196,195,241,173,146,0,244],
[74,170,100,170,174,148,97,0]])
times = np.zeros(rep)
for i in range(rep):
# Algorithm with Condorcet winner
algorithm = am3.AzziniMunda3(om)
start_time = time.time()
sol = algorithm.execute()
t = (time.time() - start_time)
times[i] = t
#print(t)
exec_time = np.median(times)
result = np.append(np.array([8, 341, 2000, "ME-RCW", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
pd.DataFrame(results).to_csv("predictTime_8_341.csv", index=False, header=False) | [
"[email protected]"
] | |
1db367d4918110b8a0232d642973173af2617b77 | 66e6360325b781ed0791868765f1fd8a6303726f | /TB2009/WorkDirectory/5141 Number Of Samples Over Threshold/Count_108535.py | b35a81682068d313d7f63d34b079e98224e2decc | [] | no_license | alintulu/FHead2011PhysicsProject | c969639b212d569198d8fce2f424ce866dcfa881 | 2568633d349810574354ad61b0abab24a40e510e | refs/heads/master | 2022-04-28T14:19:30.534282 | 2020-04-23T17:17:32 | 2020-04-23T17:17:32 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,819 | py | import FWCore.ParameterSet.Config as cms
process = cms.Process("EventDisplay")
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32(-1)
)
process.source = cms.Source("HcalTBSource",
fileNames = cms.untracked.vstring("file:/tmp/chenyi/HTB_108535.root"),
streams = cms.untracked.vstring('Chunk699', 'HCAL_Trigger', 'HCAL_SlowData', 'HCAL_QADCTDC', 'HCAL_DCC021')
)
process.tbunpack = cms.EDFilter("HcalTBObjectUnpacker",
#IncludeUnmatchedHits = cms.untracked.bool(False),
HcalTriggerFED = cms.untracked.int32(1),
HcalVLSBFED = cms.untracked.int32(699),
HcalTDCFED = cms.untracked.int32(8),
HcalQADCFED = cms.untracked.int32(8),
HcalSlowDataFED = cms.untracked.int32(3),
ConfigurationFile = cms.untracked.string('configQADCTDC_TB2009.txt')
)
process.vlsbinfo = cms.EDProducer("VLSBInformationProducer",
minSample = cms.untracked.uint32(0),
maxSample = cms.untracked.uint32(31),
baselineSamples = cms.untracked.uint32(3),
mip = cms.untracked.string("MIPCalibration.txt"),
useMotherBoard0 = cms.untracked.bool(True),
useMotherBoard1 = cms.untracked.bool(False),
useMotherBoard2 = cms.untracked.bool(False),
useMotherBoard3 = cms.untracked.bool(False),
usePedestalMean = cms.untracked.bool(True),
pedestalMean = cms.untracked.string("PedestalMean_108535.txt")
)
process.ABCcut = cms.EDFilter("SingleTowerParticleFilter")
process.MessageLogger = cms.Service("MessageLogger",
default = cms.untracked.PSet(
reportEvery = cms.untracked.int32(100)
)
)
process.countsample = cms.EDAnalyzer("FillMaxAdcAnalyzer",
threshold = cms.untracked.double(12600),
output = cms.untracked.string('CountSample_108535.root')
)
process.p = cms.Path(process.tbunpack*process.ABCcut*process.vlsbinfo*process.countsample)
| [
"[email protected]"
] | |
63ba110f6605deb2d39ba210975b637a8084fbb7 | 90cad1df7b7d424feb8e71ff3d77e772d446afdf | /alembic/versions/3147aa982e03_payment_application_datetime.py | 434fce6bc4ce03501fa4352481a996f74989e5e0 | [] | no_license | razagilani/billing | acb8044c22b4075250c583f599baafe3e09abc2e | fd2b20019eeedf0fcc781e5d81ff240be90c0b37 | refs/heads/master | 2021-05-01T14:46:32.138870 | 2016-03-09T18:55:09 | 2016-03-09T18:55:09 | 79,589,205 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 592 | py | """payment application datetime
Revision ID: 3147aa982e03
Revises: 4f2f8e2f7cd
Create Date: 2014-07-23 15:43:12.596865
"""
# revision identifiers, used by Alembic.
revision = '3147aa982e03'
down_revision = '4f2f8e2f7cd'
from alembic import op
import sqlalchemy as sa
from sqlalchemy.types import DateTime, Date
def upgrade():
op.alter_column('payment', 'date_applied', type_=DateTime)
op.alter_column('reebill', 'issue_date', type_=DateTime)
def downgrade():
op.alter_column('payment', 'date_applied', type_=Date)
op.alter_column('reebill', 'issue_date', type_=Date)
| [
"[email protected]"
] | |
61dec1d0e6f74a2fecd66c82df9047590d148082 | cf9158e73c3630bb6c76f5a849014df79e550471 | /paixu.py | e6239d3c47c6e108dbaa197b9970e50d9d62b9ba | [] | no_license | starmerxhcd/python1 | dbcc589c101421a38644f22cb2b7af0378d0e534 | f7ed4b129a4ec22d0e1eed99081d9d695b769229 | refs/heads/master | 2021-08-12T00:55:18.466596 | 2017-11-14T07:48:51 | 2017-11-14T07:48:51 | 110,618,349 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,628 | py | # -*- coding: UTF-8 -*-
# 快速排序
# 从数列中取出一个数作为基准数->分区过程，最终结果小的数 基准数 大的数->再对左右区间重复分区过程，知道区间只有一个数
# s list l左标志位 r右标志位 paixu 0为升序 1为降序
def quick_sort(s,l,r,paixu=0):
if(l>=r):
return 'r必须大于l'
if(not isinstance(s,list)):
return '请传入list类型'
if(l<r):
i=l
j=r
x=s[l]
# 一次分区过程
while(i<j):
# 先从右向左找
# 降序排列
if paixu:
while (i < j and s[j] <= x):
j = j - 1
else:
while (i < j and s[j] >= x):
j = j - 1
if(i<j):
# 注意是把当前位置的数据赋值给基准数的位置
s[i]=s[j]
#i位置的数据确定了 则i坐标右移1个
i=i+1
# 从左向右找
if paixu:
while (i < j and s[i] >= x):
i = i + 1
else:
while (i < j and s[i] <= x):
i = i + 1
if(i<j):
s[j]=s[i]
j=j-1
# i=j时，找到了中间位置
s[i]=x
# 循环调用
quick_sort(s,l,i-1,paixu)
quick_sort(s,i+1,r,paixu)
# 最后返回列表
return s
# 进行测试
s=[33,43,22,66,2,54,7,39,55]
print s
print '升序排列'
print quick_sort(s,0,s.__len__()-1)
print '降序排列'
print quick_sort(s,0,s.__len__()-1,1) | [
"[email protected]"
] | |
e6999cec4013893c63f3967582a644f9a6d64d51 | 90419da201cd4948a27d3612f0b482c68026c96f | /sdk/python/pulumi_azure_nextgen/apimanagement/v20191201/get_group.py | 1ad33fd5f9a9cc3080ea190180c967ae733fe384 | [
"BSD-3-Clause",
"Apache-2.0"
] | permissive | test-wiz-sec/pulumi-azure-nextgen | cd4bee5d70cb0d332c04f16bb54e17d016d2adaf | 20a695af0d020b34b0f1c336e1b69702755174cc | refs/heads/master | 2023-06-08T02:35:52.639773 | 2020-11-06T22:39:06 | 2020-11-06T22:39:06 | 312,993,761 | 0 | 0 | Apache-2.0 | 2023-06-02T06:47:28 | 2020-11-15T09:04:00 | null | UTF-8 | Python | false | false | 4,723 | py | # coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union
from ... import _utilities, _tables
__all__ = [
'GetGroupResult',
'AwaitableGetGroupResult',
'get_group',
]
@pulumi.output_type
class GetGroupResult:
"""
Contract details.
"""
def __init__(__self__, built_in=None, description=None, display_name=None, external_id=None, name=None, type=None):
if built_in and not isinstance(built_in, bool):
raise TypeError("Expected argument 'built_in' to be a bool")
pulumi.set(__self__, "built_in", built_in)
if description and not isinstance(description, str):
raise TypeError("Expected argument 'description' to be a str")
pulumi.set(__self__, "description", description)
if display_name and not isinstance(display_name, str):
raise TypeError("Expected argument 'display_name' to be a str")
pulumi.set(__self__, "display_name", display_name)
if external_id and not isinstance(external_id, str):
raise TypeError("Expected argument 'external_id' to be a str")
pulumi.set(__self__, "external_id", external_id)
if name and not isinstance(name, str):
raise TypeError("Expected argument 'name' to be a str")
pulumi.set(__self__, "name", name)
if type and not isinstance(type, str):
raise TypeError("Expected argument 'type' to be a str")
pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="builtIn")
def built_in(self) -> bool:
"""
true if the group is one of the three system groups (Administrators, Developers, or Guests); otherwise false.
"""
return pulumi.get(self, "built_in")
@property
@pulumi.getter
def description(self) -> Optional[str]:
"""
Group description. Can contain HTML formatting tags.
"""
return pulumi.get(self, "description")
@property
@pulumi.getter(name="displayName")
def display_name(self) -> str:
"""
Group name.
"""
return pulumi.get(self, "display_name")
@property
@pulumi.getter(name="externalId")
def external_id(self) -> Optional[str]:
"""
For external groups, this property contains the id of the group from the external identity provider, e.g. for Azure Active Directory `aad://<tenant>.onmicrosoft.com/groups/<group object id>`; otherwise the value is null.
"""
return pulumi.get(self, "external_id")
@property
@pulumi.getter
def name(self) -> str:
"""
Resource name.
"""
return pulumi.get(self, "name")
@property
@pulumi.getter
def type(self) -> str:
"""
Resource type for API Management resource.
"""
return pulumi.get(self, "type")
class AwaitableGetGroupResult(GetGroupResult):
# pylint: disable=using-constant-test
def __await__(self):
if False:
yield self
return GetGroupResult(
built_in=self.built_in,
description=self.description,
display_name=self.display_name,
external_id=self.external_id,
name=self.name,
type=self.type)
def get_group(group_id: Optional[str] = None,
resource_group_name: Optional[str] = None,
service_name: Optional[str] = None,
opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetGroupResult:
"""
Use this data source to access information about an existing resource.
:param str group_id: Group identifier. Must be unique in the current API Management service instance.
:param str resource_group_name: The name of the resource group.
:param str service_name: The name of the API Management service.
"""
__args__ = dict()
__args__['groupId'] = group_id
__args__['resourceGroupName'] = resource_group_name
__args__['serviceName'] = service_name
if opts is None:
opts = pulumi.InvokeOptions()
if opts.version is None:
opts.version = _utilities.get_version()
__ret__ = pulumi.runtime.invoke('azure-nextgen:apimanagement/v20191201:getGroup', __args__, opts=opts, typ=GetGroupResult).value
return AwaitableGetGroupResult(
built_in=__ret__.built_in,
description=__ret__.description,
display_name=__ret__.display_name,
external_id=__ret__.external_id,
name=__ret__.name,
type=__ret__.type)
| [
"[email protected]"
] | |
cf000ffd91c88cbfd2f59ee93dc3e4697700ce28 | c1ef1f1fa94b5dbecff2ec09e94ae29a9094d82a | /20210701.py | c13acabf4bce257bd66f37de2cc21ee67c7fa201 | [] | no_license | MONKEYZ9/algorithm | cd6039a2232615e9bd40f63e2509fddf7edcede7 | 4ffde1ac47294af87152ed740962db600e0b9755 | refs/heads/main | 2023-08-14T17:01:54.792376 | 2021-10-01T06:14:55 | 2021-10-01T06:14:55 | 380,917,885 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 415 | py | # 약수 구하기
# 약수는 나눠서 나머지가 0인 것을 나타낸다.
# 그럼 그것들을 모아서 리스트에 나오게끔 하면 되다.
def solution(n):
num_list = []
for i in range(1, n+1):
if n % i == 0:
num_list.append(i)
return num_list[0], num_list[-1]
n = int(input())
max, min = solution(n)
print(max, min)
lsitasd = list(range(10, 0,-1))
print(lsitasd) | [
"[email protected]"
] | |
c4c49205364f01979a89041cba0306dc7b3714a1 | 1a5e3871a403057fbbc3f0914a931fc0a6bf06c3 | /Server/app/docs/__init__.py | c1df725028415f127e2c74e054d89fcb8f008df7 | [
"MIT"
] | permissive | DSM-DMS/DMS-Backend-API-v2 | ec754b575bfa3ef831efaae242f0a8203c595dd1 | dfb49879ce81d7a3c1c4cda47b1de150f245cd86 | refs/heads/master | 2021-05-04T00:03:17.912351 | 2018-04-06T13:51:25 | 2018-04-06T13:51:25 | 120,405,963 | 0 | 0 | MIT | 2018-02-18T14:39:13 | 2018-02-06T05:25:05 | Python | UTF-8 | Python | false | false | 1,884 | py | TEMPLATE = {
'schemes': [
'http'
],
'tags': [
{
'name': '관리자 계정',
'description': '관리자 권한으로 접근 가능한 계정/계정 관리 API'
},
{
'name': '계정',
'description': '학생 권한으로 접근 가능한 계정 API'
},
{
'name': '신청 정보 관리',
'description': '관리자 권한으로 접근 가능한 신청 정보 관리 API'
},
{
'name': '신청',
'description': '학생 권한으로 접근 가능한 신청 API'
},
{
'name': '신고 관리',
'description': '관리자 권한으로 접근 가능한 시설 고장, DMS 시스템 등 신고 관리 API'
},
{
'name': '신고',
'description': '학생 권한으로 접근 가능한 시설 고장, DMS 시스템 등 신고 API'
},
{
'name': '게시글 관리',
'description': '관리자 권한으로 접근 가능한 게시글 관리 API'
},
{
'name': '게시글',
'description': '학생 권한으로 접근 가능한 게시글 조회 관련 API'
},
{
'name': '설문지 관리',
'description': '관리자 권한으로 접근 가능한 설문지 관리 API'
},
{
'name': '설문지',
'description': '학생 권한으로 접근 가능한 설문지 API'
},
{
'name': '상벌점 관리',
'description': '관리자 권한으로 접근 가능한 상벌점 관리 API'
},
{
'name': '학교',
'description': '학생과 관리자 권한으로 접근 가능한 학교 정보 조회 관련 API'
}
]
}
| [
"[email protected]"
] | |
62a54329673eecda6470aab943460239d2c97a22 | fb82fdf706863465b1f357cd1fa0447474cd8a70 | /ServerComponent/venv/Lib/site-packages/rsrc/contrib/db/mongo/serializer.py | 4ce65d072d3cc5cf44fb07e5acfe9000727e374a | [
"MIT"
] | permissive | CDU55/FakeNews | d79e2a069b3f1392f779d5b2256cd54c696e789a | 707bd48dd78851081d98ad21bbdadfc2720bd644 | refs/heads/main | 2023-02-20T06:27:18.618837 | 2021-01-17T15:14:27 | 2021-01-17T15:14:27 | 305,167,221 | 0 | 1 | MIT | 2020-12-07T19:51:46 | 2020-10-18T18:16:49 | Python | UTF-8 | Python | false | false | 593 | py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from rsrc import settings
from jsonsir import Serializer
from jsonsir.contrib.intencoder import IntEncoder
from jsonsir.contrib.boolencoder import BoolEncoder
from jsonsir.contrib.regexencoder import RegexEncoder
from jsonsir.contrib.objectidencoder import ObjectIdEncoder
from jsonsir.contrib.datetimeencoder import DateTimeEncoder
# instantiate `Serializer` (bound with specified encoders)
serializer = Serializer([
IntEncoder(),
BoolEncoder(),
RegexEncoder(),
ObjectIdEncoder(),
DateTimeEncoder(settings.DATE_FORMAT),
])
| [
"[email protected]"
] | |
8a1620d7c5e238a937e8c5e317cd0d841bd6c9c1 | 2f98aa7e5bfc2fc5ef25e4d5cfa1d7802e3a7fae | /python/python_12364.py | 078700cb2bbfce3105692f4e33e508d8b2f4b77d | [] | no_license | AK-1121/code_extraction | cc812b6832b112e3ffcc2bb7eb4237fd85c88c01 | 5297a4a3aab3bb37efa24a89636935da04a1f8b6 | refs/heads/master | 2020-05-23T08:04:11.789141 | 2015-10-22T19:19:40 | 2015-10-22T19:19:40 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 150 | py | # backslash in a character set of a python regexp (how to specify 'not a backslash' character set)?
regexps.append({'left':r'[^\\]%.*', 'right':r''})
| [
"[email protected]"
] | |
fd23120ffa6c03d72252d789dea7030132ea3bd4 | 31eadb37c1748ea37c9d978ae099f56f3d01d3be | /core/utils.py | ba5db3540ba38eb07995f3dd2da24fc7852637a7 | [] | no_license | geofferyj/simple_django_chat | daccf0b8e47b0a70d6bd4ad10da737da88fcc0a1 | ad9606bc42528bc24448e9786665f7fae034e51f | refs/heads/master | 2023-08-12T19:13:32.992640 | 2021-10-14T04:52:00 | 2021-10-14T04:52:00 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,662 | py | from django.contrib.auth.models import AnonymousUser
from channels.db import database_sync_to_async
from django.db import close_old_connections
from rest_framework.authtoken.models import Token
from channels.middleware import BaseMiddleware
from channels.auth import AuthMiddlewareStack
from rest_framework.authentication import TokenAuthentication
@database_sync_to_async
def get_user(token_key):
try:
token = Token.objects.get(key=token_key)
return token.user
except Token.DoesNotExist:
return AnonymousUser()
finally:
close_old_connections()
class TokenAuthMiddleware(BaseMiddleware):
def __init__(self, inner):
self.inner = inner
async def __call__(self, scope, receive, send):
token_key = scope['query_string'].decode().split('=')[-1]
scope['user'] = await get_user(token_key)
return await super().__call__(scope, receive, send)
TokenAuthMiddlewareStack = lambda inner: TokenAuthMiddleware(AuthMiddlewareStack(inner))
class QSTokenAuthentication(TokenAuthentication):
"""
Extend the TokenAuthentication class to support querystring authentication
in the form of "http://www.example.com/?auth_token=<token_key>"
"""
def authenticate(self, request):
# Check if 'token_auth' is in the request query params.
# Give precedence to 'Authorization' header.
if 'token' in request.query_params and \
'HTTP_AUTHORIZATION' not in request.META:
return self.authenticate_credentials(request.query_params.get('token'))
else:
return super().authenticate(request) | [
"[email protected]"
] | |
7af3af409784414f72d30c21d0d452263f877838 | b5cba88ce8c86740c8c3453134610fd5bafbb8c4 | /AlgoExpert/Selection Sort/solution.py | 2f1ea5a4052470bf42473e09bd03a59a4df0f506 | [] | no_license | EduardoSantos7/Algorithms4fun | 55fcf9d515ea3b70b93298ac96a58d2ae68dee11 | 6ff182ed596b6322322b087f29e6ad98baec3f97 | refs/heads/master | 2023-07-23T01:38:08.216313 | 2023-07-23T01:35:58 | 2023-07-23T01:35:58 | 227,448,848 | 1 | 1 | null | null | null | null | UTF-8 | Python | false | false | 294 | py | def selectionSort(array):
for i in range(len(array) - 1):
current_min = i
for j in range(i + 1, len(array)):
if array[j] < array[current_min]:
current_min = j
array[i], array[current_min] = array[current_min], array[i]
return array
| [
"[email protected]"
] | |
42690924946bef5ab0da79ed1f252d7fc6198fff | 6e3d061f94468905841a918278a352d4e5df89a1 | /hashicorp_vault_client/test/test_body92.py | 87a8f24bd7cd68ac8fe9c87c8e3e6c826c7412f2 | [
"Apache-2.0"
] | permissive | drewmullen/HAC | 179a4188e6e6ce3a36d480e45f238fd0901a710f | fb185804fd244366f8f8d01df22835b3d96e7512 | refs/heads/master | 2020-08-03T12:13:08.785915 | 2019-10-03T18:33:04 | 2019-10-03T18:33:04 | 211,749,364 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 868 | py | # coding: utf-8
"""
HashiCorp Vault API
HTTP API that gives you full access to Vault. All API routes are prefixed with `/v1/`. # noqa: E501
OpenAPI spec version: 1.2.0
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
from __future__ import absolute_import
import unittest
import hashicorp_vault_client
from models.body92 import Body92 # noqa: E501
from hashicorp_vault_client.rest import ApiException
class TestBody92(unittest.TestCase):
"""Body92 unit test stubs"""
def setUp(self):
pass
def tearDown(self):
pass
def testBody92(self):
"""Test Body92"""
# FIXME: construct object with mandatory attributes with example values
# model = hashicorp_vault_client.models.body92.Body92() # noqa: E501
pass
if __name__ == '__main__':
unittest.main()
| [
"[email protected]"
] | |
32102d490eaf01579a5fdfd91f758f8e60ddd1d3 | 3c6b3b0a92e5a290ba69d0f73af51ac82aff3509 | /exams/midterm2/list_set.py | 9e0137e47de684f4ff2f0f13a542abe3f3d2f362 | [] | no_license | sarae17/2019-T-111-PROG | ba6c6db7075acba16bbcd23e4c0d3db6e2bb374f | 017287b3300ec4fe809bfc81fee856ffb17b4800 | refs/heads/master | 2020-09-10T14:36:53.715479 | 2019-11-13T13:41:04 | 2019-11-13T13:41:04 | 221,722,173 | 1 | 0 | null | 2019-11-14T14:54:15 | 2019-11-14T14:54:14 | null | UTF-8 | Python | false | false | 1,018 | py | def unique_elements(a_list):
''' Returns a new list containing the unique elements in a_list '''
result = []
for elem in a_list:
if not elem in result:
result.append(elem)
return result
def make_sorted_set(a_list):
a_set = unique_elements(a_list)
return sorted(a_set)
def intersection(set1, set2):
result_set = []
for elem in set1:
if elem in set2:
result_set.append(elem)
return result_set
def union(set1, set2):
result_list = set1 + set2
result_set = make_sorted_set(result_list)
return result_set
def get_set():
a_list = input("Enter elements of a list separated by space: ").strip().split()
a_list = [int(i) for i in a_list]
return make_sorted_set(a_list)
# Main program starts here
set1 = get_set()
set2 = get_set()
print("Set 1: {}".format(set1))
print("Set 2: {}".format(set2))
set3 = intersection(set1, set2)
print("Intersection: {}".format(set3))
set4 = union(set1, set2)
print("Union: {}".format(set4))
| [
"[email protected]"
] | |
19c07d874f40176edcbf9fe01161f45a8eab33ac | acf314ab0fa399018764b2ebd96e33c66362994e | /0x0F-python-object_relational_mapping/model_city.py | de7071389d2f251afb219add79ea14ca20dfe060 | [] | no_license | glyif/holbertonschool-higher_level_programming | 98f9c2da0b71a4e9e2dd9f6fde755875e9015f34 | 14c02d79e2008db1b992b08f9faa55b20dbe0691 | refs/heads/master | 2021-01-20T06:53:16.179354 | 2017-09-28T18:14:12 | 2017-09-28T18:14:12 | 89,939,980 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 471 | py | #!/usr/bin/python3
"""
City Base Model
"""
from sqlalchemy import Column, Integer, String, ForeignKey
from model_state import Base, State
class City(Base):
"""
City Model
tablename: cities
id: id
name: name
state_id: state_id
"""
__tablename__ = "cities"
id = Column(Integer, autoincrement=True, nullable=False, primary_key=True)
name = Column(String(128), nullable=False)
state_id = Column(Integer, ForeignKey(State.id))
| [
"[email protected]"
] | |
e0fade2adeb0017c44bf7145e021bf79ff8828c2 | edfdc0d3a2fdeed95ba7aa3d0e198eb9dafe4064 | /operator_api/ledger/migrations/0034_auto_20180921_1222.py | 2fd8e466f164d186fb24a45d8da3bf7466401d5e | [
"MIT",
"LicenseRef-scancode-warranty-disclaimer"
] | permissive | xiaobai900/nocust-hub | 880e72ba4e1d324ae36adea6c03c9761a7d91621 | 76f49f9b8a6c264fcbe9e0c110e98031d463c0a8 | refs/heads/master | 2023-05-28T08:18:17.402228 | 2020-11-01T19:48:17 | 2020-11-01T19:48:17 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 429 | py | # -*- coding: utf-8 -*-
# Generated by Django 1.11.8 on 2018-09-21 12:22
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('ledger', '0033_transfer_cancelled'),
]
operations = [
migrations.RenameField(
model_name='transfer',
old_name='sent',
new_name='complete',
),
]
| [
"[email protected]"
] | |
f649243082383177f106b99b34768aba67f6e947 | 7c2e909991d608845bf9afca58909949cf056d2f | /solid/web/libs/session.py | c41ce7bb43be48d319fbea8dbf45095dfecac886 | [] | no_license | martinrusev/solid | a176dfc937865caafb485b111e288cda5c0a1376 | af2a43e644653d08a5d5d26a5ad5b6bf33e4ffe4 | refs/heads/master | 2020-05-20T16:41:55.327281 | 2013-07-01T08:31:19 | 2013-07-01T08:31:19 | 10,189,216 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 10,548 | py | # -*- coding: utf-8 -*-
"""
Sessions module for the Tornado framework.
Milan Cermak <[email protected]>
USAGE:
======
Every session object can be handled as a dictionary:
self.session[key] = value
var = self.session[key]
The session data is saved automatically for you when the request
handler finishes.
Two utility functions, invalidate() and refresh() are available to
every session object. Read their documentation to learn more.
The application provider is responsible for removing stale, expired
sessions from the storage. However, he can use the delete_expired()
function provided with every storage class except Memcached, which
knows when a session expired and removes it automatically.
SETTINGS:
=========
The session module introduces new settings available to the
application:
session_age: how long should the session be valid (applies also to cookies);
the value can be anything an integer, long, string or datetime.timedelta;
integer, long and string are meant to represent seconds,
default is 900 seconds (15 mins);
check out _expires_at for additional info
session_regeneration_interval: period in seconds, after which the session_id should be
regenerated; when the session creation time + period
exceed current time, a new session is stored
server-side (the sesion data remains unchanged) and
the client cookie is refreshed; the old session
is no longer valid
session regeneration is used to strenghten security
and prevent session hijacking; default interval
is 4 minutes
the setting accepts integer, string or timedelta values,
read _next_regeneration_at() documentation for more info
session_cookie_name: the name of the cookie, which stores the session_id;
default is 'session_id'
session_cookie_path: path attribute for the session cookie;
default is '/'
session_cookie_domain: domain attribute for the session cookie;
default is None
"""
import base64
import collections
import datetime
import os
import cPickle as pickle
import time
from solid.core.mongodb import MongoBackend
class BaseSession(collections.MutableMapping):
"""The base class for the session object. Work with the session object
is really simple, just treat is as any other dictionary:
class Handler(tornado.web.RequestHandler):
def get(self):
var = self.session['key']
self.session['another_key'] = 'value'
Session is automatically saved on handler finish. Session expiration
is updated with every request. If configured, session ID is
regenerated periodically.
The session_id attribute stores a unique, random, 64 characters long
string serving as an indentifier.
To create a new storage system for the sessions, subclass BaseSession
and define save(), load() and delete(). For inspiration, check out any
of the already available classes and documentation to aformentioned functions."""
def __init__(self, session_id=None, data=None, security_model=[], expires=None,
duration=None, ip_address=None, user_agent=None,
regeneration_interval=None, next_regeneration=None, **kwargs):
# if session_id is True, we're loading a previously initialized session
if session_id:
self.session_id = session_id
self.data = data
self.duration = duration
self.expires = expires
self.dirty = False
else:
self.session_id = self._generate_session_id()
self.data = {}
self.duration = duration
self.expires = self._expires_at()
self.dirty = True
self.ip_address = ip_address
self.user_agent = user_agent
self.security_model = security_model
self.regeneration_interval = regeneration_interval
self.next_regeneration = next_regeneration or self._next_regeneration_at()
self._delete_cookie = False
def __repr__(self):
return '<session id: %s data: %s>' % (self.session_id, self.data)
def __str__(self):
return self.session_id
def __getitem__(self, key):
return self.data[key]
def __setitem__(self, key, value):
self.data[key] = value
self.dirty = True
def __delitem__(self, key):
del self.data[key]
self.dirty = True
def keys(self):
return self.data.keys()
def __iter__(self):
return self.data.__iter__()
def __len__(self):
return len(self.data.keys())
def _generate_session_id(cls):
return os.urandom(16).encode('hex')
def _is_expired(self):
"""Check if the session has expired."""
if self.expires is None: # never expire
return False
return datetime.datetime.utcnow() > self.expires
def _expires_at(self):
"""Find out the expiration time. Returns datetime.datetime."""
v = self.duration
if v is None: # never expire
return None
elif isinstance(v, datetime.timedelta):
pass
elif isinstance(v, (int, long)):
self.duration = datetime.timedelta(seconds=v)
elif isinstance(v, basestring):
self.duration = datetime.timedelta(seconds=int(v))
else:
self.duration = datetime.timedelta(seconds=900) # 15 mins
return datetime.datetime.utcnow() + self.duration
def _serialize_expires(self):
""" Determines what value of expires is stored to DB during save()."""
if self.expires is None:
return None
else:
return int(time.mktime(self.expires.timetuple()))
def _should_regenerate(self):
"""Determine if the session_id should be regenerated."""
if self.regeneration_interval is None: # never regenerate
return False
return datetime.datetime.utcnow() > self.next_regeneration
def _next_regeneration_at(self):
"""Return a datetime object when the next session id regeneration
should occur."""
# convert whatever value to an timedelta (period in seconds)
# store it in self.regeneration_interval to prevent
# converting in later calls and return the datetime
# of next planned regeneration
v = self.regeneration_interval
if v is None: # never regenerate
return None
elif isinstance(v, datetime.timedelta):
pass
elif isinstance(v, (int, long)):
self.regeneration_interval = datetime.timedelta(seconds=v)
elif isinstance(v, basestring):
self.regeneration_interval = datetime.timedelta(seconds=int(v))
else:
self.regeneration_interval = datetime.timedelta(seconds=240) # 4 mins
return datetime.datetime.utcnow() + self.regeneration_interval
def invalidate(self):
"""Destroys the session, both server-side and client-side.
As a best practice, it should be used when the user logs out of
the application."""
self.delete() # remove server-side
self._delete_cookie = True # remove client-side
def refresh(self, duration=None, new_session_id=False): # the opposite of invalidate
"""Prolongs the session validity. You can specify for how long passing a
value in the duration argument (the same rules as for session_age apply).
Be aware that henceforward this particular session may have different
expiry date, not respecting the global setting.
If new_session_id is True, a new session identifier will be generated.
This should be used e.g. on user authentication for security reasons."""
if duration:
self.duration = duration
self.expires = self._expires_at()
else:
self.expires = self._expires_at()
if new_session_id:
self.delete()
self.session_id = self._generate_session_id()
self.next_regeneration = self._next_regeneration_at()
self.dirty = True # force save
self.save()
def save(self):
"""Save the session data and metadata to the backend storage
if necessary (self.dirty == True). On successful save set
dirty to False."""
pass
@staticmethod
def load(session_id, location):
"""Load the stored session from storage backend or return
None if the session was not found, in case of stale cookie."""
pass
def delete(self):
"""Remove all data representing the session from backend storage."""
pass
@staticmethod
def delete_expired(file_path):
"""Deletes sessions with timestamps in the past form storage."""
pass
def serialize(self):
dump = {'session_id': self.session_id,
'data': self.data,
'duration': self.duration,
'expires': self.expires,
'ip_address': self.ip_address,
'user_agent': self.user_agent,
'security_model': self.security_model,
'regeneration_interval': self.regeneration_interval,
'next_regeneration': self.next_regeneration}
return base64.encodestring(pickle.dumps(dump))
@staticmethod
def deserialize(datastring):
return pickle.loads(base64.decodestring(datastring))
mongo_backend = MongoBackend()
mongo = mongo_backend.get_collection('sessions')
class MongoDBSession(BaseSession):
"""Class implementing the MongoDB based session storage.
All sessions are stored in a collection "sessions" in the db
you specify in the session_storage setting.
The session document structure is following:
'session_id': session ID
'data': serialized session object
'expires': a timestamp of when the session expires, in sec since epoch
'user_agent': self-explanatory
An index on session_id is created automatically, on application's init.
The end_request() is called after every operation (save, load, delete),
to return the connection back to the pool.
"""
def __init__(self, **kwargs):
super(MongoDBSession, self).__init__(**kwargs)
self.db = mongo # pymongo Collection object - sessions
if not kwargs.has_key('session_id'):
self.save()
def save(self):
"""Upsert a document to the tornado_sessions collection.
The document's structure is like so:
{'session_id': self.session_id,
'data': self.serialize(),
'expires': self._serialize_expires(),
'user_agent': self.user_agent}
"""
# upsert
self.db.update(
{'session_id': self.session_id}, # equality criteria
{'session_id': self.session_id,
'data': self.serialize(),
'expires': self._serialize_expires(),
'user_agent': self.user_agent}, # new document
upsert=True)
self.db.database.connection.end_request()
self.dirty = False
@staticmethod
def load(session_id):
"""Load the session from mongo."""
try:
data = mongo.find_one({'session_id': session_id})
if data:
kwargs = MongoDBSession.deserialize(data['data'])
mongo.database.connection.end_request()
return MongoDBSession(**kwargs)
return None
except:
mongo.database.connection.end_request()
return None
def delete(self):
"""Remove session from mongo."""
self.db.remove({'session_id': self.session_id})
self.db.database.connection.end_request()
@staticmethod
def delete_expired(db):
db.remove({'expires': {'$lte': int(time.time())}})
| [
"[email protected]"
] | |
96d2a76bc48ba275b4dc54827f951e5329d02f4b | 68d5dfd61fc2ea4dce4046d4ab83b5e837288781 | /trax/models/research/layerdrop_transformer.py | fa2378cea529ddab22e5f0c69245d9e777eabaca | [
"Apache-2.0"
] | permissive | lukaszkaiser/trax | e1bf055c40c1c2c69726b0fe23f3de87c2e6ec6f | d875d804b8503d36b5dba493efa22ace86bb68f0 | refs/heads/master | 2023-08-17T11:12:47.806355 | 2021-09-29T21:57:02 | 2021-09-29T21:57:02 | 411,838,526 | 3 | 0 | Apache-2.0 | 2021-09-29T21:46:56 | 2021-09-29T21:46:55 | null | UTF-8 | Python | false | false | 11,461 | py | # coding=utf-8
# Copyright 2021 The Trax Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Lint as: python3
"""Layer-Skipping Transformer Models.
Like in https://arxiv.org/pdf/1909.11556.pdf
"""
from trax import layers as tl
from trax.layers.assert_shape import assert_shape
from trax.models import transformer
def LargerThan(val):
"""Checks if the input is larger than a certain value."""
return tl.Fn('LargerThan', lambda x: x > val)
@assert_shape('...s->...sv')
def SkippingTransformerLM(vocab_size,
d_model=512,
d_ff=2048,
n_layers=6,
n_heads=8,
dropout=0.1,
max_len=2048,
mode='train',
ff_activation=tl.Relu,
skip_fraction=0.4):
"""Returns a Skipping Transformer language model.
The input to the model is a tensor of tokens. (This model uses only the
decoder part of the overall Transformer.)
Args:
vocab_size: int: vocab size
d_model: int: depth of embedding
d_ff: int: depth of feed-forward layer
n_layers: int: number of encoder/decoder layers
n_heads: int: number of attention heads
dropout: float: dropout rate (how much to drop out)
max_len: int: maximum symbol length for positional encoding
mode: str: 'train', 'eval' or 'predict', predict mode is for fast inference
ff_activation: the non-linearity in feed-forward layer
skip_fraction: fraction of times to skip some layers
Returns:
A Transformer language model as a layer that maps from a tensor of tokens
to activations over a vocab set.
"""
embedder = [
tl.Embedding(vocab_size, d_model),
tl.Dropout(rate=dropout, mode=mode),
tl.PositionalEncoding(max_len=max_len, mode=mode),
]
@assert_shape('...sd,->...sd,')
def ConditionedBlock(current_layer_num):
return tl.Serial(
# stack: embedding, n_layers_to_keep
tl.Select([1, 0, 1]), # n_layers_to_keep, embedding, n_layers_to_keep
tl.Cond(
# if n_layers_to_keep > current_layer_num
LargerThan(float(current_layer_num)),
# then: run block
tl.Serial(transformer._DecoderBlock( # pylint: disable=g-complex-comprehension,protected-access
d_model, d_ff, n_heads, dropout, [], mode, ff_activation)),
# else: run noop
tl.Serial()
)
# stack: embedding, n_layers_to_keep
)
if mode == 'train':
if skip_fraction == 0.0:
minimum_layers = float(n_layers)
maximum_layers = float(n_layers)
else:
minimum_layers = 0.0
maximum_layers = float(n_layers) / skip_fraction
else:
minimum_layers = maximum_layers = float(n_layers)
return tl.Serial(
tl.ShiftRight(mode=mode),
embedder,
# stack: embedding
tl.RandomUniform(minimum_layers, maximum_layers, sync=True),
# stack: n_layers_to_keep, embedding
tl.Swap(),
# stack: embedding, n_layers_to_keep
[ConditionedBlock(i) for i in range(n_layers)],
# stack: embedding, n_layers_to_keep
tl.AssertShape('...sd,'),
tl.Select([0], n_in=2), # stack: embedding
tl.AssertShape('...sd'),
tl.LayerNorm(),
tl.Dense(vocab_size),
)
@assert_shape('...s->...sv')
def EveryOtherLayerDropTransformerLM(vocab_size,
d_model=512,
d_ff=2048,
n_layers=6,
n_heads=8,
dropout=0.1,
max_len=2048,
mode='train',
ff_activation=tl.Relu,
skip_mode='even',
skip_fraction=0.5,
eval_skip_fraction=0.0):
"""Returns an "EveryOther" LayerDrop Transformer language model.
During each training step it either runs all layers, or skips a subset of
layers. This subset is the same every time, and it is specified by
"skip_mode".
The input to the model is a tensor of tokens. (This model uses only the
decoder part of the overall Transformer.)
Args:
vocab_size: int: vocab size
d_model: int: depth of embedding
d_ff: int: depth of feed-forward layer
n_layers: int: number of encoder/decoder layers
n_heads: int: number of attention heads
dropout: float: dropout rate (how much to drop out)
max_len: int: maximum symbol length for positional encoding
mode: str: 'train', 'eval' or 'predict', predict mode is for fast inference
ff_activation: the non-linearity in feed-forward layer
skip_mode: which layers to skip when skipping: even/odd/1half/2half.
skip_fraction: fraction of times to skip layers
eval_skip_fraction: fraction of times to skip layers during eval
Returns:
A Transformer language model as a layer that maps from a tensor of tokens
to activations over a vocab set.
"""
embedder = [
tl.Embedding(vocab_size, d_model),
tl.Dropout(rate=dropout, mode=mode),
tl.PositionalEncoding(max_len=max_len, mode=mode),
]
if mode == 'train':
pass
else:
skip_fraction = eval_skip_fraction
skip_mode_funs = { # which layers should be skipped?
'even': (lambda num: num%2 == 0), # 0th layer is even
'odd': (lambda num: num%2 == 1),
'1half': (lambda num: num < (n_layers/2)),
'2half': (lambda num: num >= (n_layers/2)),
}
skip_mode_fun = skip_mode_funs[skip_mode]
@assert_shape('...sd,->...sd,')
def ConditionedBlock(current_layer_num):
return tl.Serial(
# stack: embedding, n_layers_to_keep
tl.Select([1, 0, 1]), # n_layers_to_keep, embedding, n_layers_to_keep
tl.Cond(
# if random() > skip_fraction OR layer not in skip_mode ...
LargerThan(skip_fraction if skip_mode_fun(current_layer_num)
else 0.0),
# then: run block
tl.Serial(transformer._DecoderBlock( # pylint: disable=g-complex-comprehension,protected-access
d_model, d_ff, n_heads, dropout, [], mode, ff_activation))
# else: noop (implicit)
)
# stack: embedding, n_layers_to_keep
)
return tl.Serial(
tl.ShiftRight(mode=mode),
embedder,
# stack: embedding
tl.RandomUniform(0., 1., sync=True),
# stack: n_layers_to_keep, embedding
tl.Swap(),
# stack: embedding, n_layers_to_keep
[ConditionedBlock(i) for i in range(n_layers)],
# stack: embedding, n_layers_to_keep
tl.Select([0], n_in=2), # stack: embedding
tl.LayerNorm(),
tl.Dense(vocab_size),
)
@assert_shape('...s->...sv')
def LayerDropTransformerLM(vocab_size,
d_model=512,
d_ff=2048,
n_layers=6,
n_heads=8,
dropout=0.1,
max_len=2048,
mode='train',
ff_activation=tl.Relu,
skip_fraction=0.4,
eval_skip_fraction='every_other'):
"""Returns a LayerDrop Transformer language model.
Based on Fan, Grave, Joulin 2019, https://arxiv.org/abs/1909.11556 .
The input to the model is a tensor of tokens. (This model uses only the
decoder part of the overall Transformer.)
Args:
vocab_size: int: vocab size
d_model: int: depth of embedding
d_ff: int: depth of feed-forward layer
n_layers: int: number of encoder/decoder layers
n_heads: int: number of attention heads
dropout: float: dropout rate (how much to drop out)
max_len: int: maximum symbol length for positional encoding
mode: str: 'train', 'eval' or 'predict', predict mode is for fast inference
ff_activation: the non-linearity in feed-forward layer
skip_fraction: probability of skipping a layer; it can be a single
probability or a list of probabilities different for each layer
eval_skip_fraction: probability of skipping a layer during eval; it can be a
single probability, or a list of probabilities different for each layer,
or a string "every other" implementing a strategy from original paper
Returns:
A Transformer language model as a layer that maps from a tensor of tokens
to activations over a vocab set.
"""
embedder = [
tl.Embedding(vocab_size, d_model),
tl.Dropout(rate=dropout, mode=mode),
tl.PositionalEncoding(max_len=max_len, mode=mode),
]
if not isinstance(skip_fraction, (list, tuple)):
# If we don't get a list of skip_fractions we use the same skip_fraction
# for each layer.
skip_fraction = [skip_fraction for i in range(n_layers)]
if len(skip_fraction) != n_layers:
raise ValueError('n_layers ({}) must be equal to len(skip_fraction) ({})'
.format(n_layers, len(skip_fraction)))
if eval_skip_fraction == 'every_other':
# 100% skipping for even-numbered layers; 0% for odd-numbered layers.
eval_skip_fraction = [(1.0 if i % int(1./skip_fraction[i]) == 0 else 0.0)
if skip_fraction[i] != 0 else 0.0
for i in range(n_layers)]
if eval_skip_fraction == 'same':
# Same skip_fraction as in training.
eval_skip_fraction = skip_fraction
if not isinstance(eval_skip_fraction, (list, tuple)):
# If we don't get a list of eval_skip_fractions we use the same
# eval_skip_fraction for each layer.
eval_skip_fraction = [eval_skip_fraction for i in range(n_layers)]
if len(eval_skip_fraction) != n_layers:
raise ValueError(
'n_layers ({}) must be equal to len(eval_skip_fraction) ({})'
.format(n_layers, len(eval_skip_fraction)))
@assert_shape('...sd->...sd')
def ConditionedBlock(current_layer_num):
return tl.Serial(
# stack: embedding
tl.RandomUniform(0., 1, sync=True),
# stack: random_uniform, embedding
tl.Cond(
# if random_uniform > skip_fraction
LargerThan(skip_fraction[current_layer_num] if mode == 'train'
else eval_skip_fraction[current_layer_num]),
# then: run block
tl.Serial(transformer._DecoderBlock( # pylint: disable=g-complex-comprehension,protected-access
d_model, d_ff, n_heads, dropout, [], mode, ff_activation)),
# else: run noop
tl.Serial()
)
# stack: embedding
)
return tl.Serial(
tl.ShiftRight(mode=mode),
embedder,
[ConditionedBlock(i) for i in range(n_layers)],
tl.LayerNorm(),
tl.Dense(vocab_size),
)
| [
"[email protected]"
] | |
87f6a95198355d88ac93093a58294e5b1c64dcf4 | 8f64d50494507fd51c0a51010b84d34c667bd438 | /BeautyForMe/myvenv/Lib/site-packages/win32/scripts/backupEventLog.py | 1a72db1578c00a5a37fa7d7486d95356f6238705 | [
"MIT"
] | permissive | YooInKeun/CAU_CSE_Capstone_3 | 5a4a61a916dc13c8635d25a04d59c21279678477 | 51405c4bed2b55661aa0708c8acea17fe72aa701 | refs/heads/master | 2022-12-11T15:39:09.721019 | 2021-07-27T08:26:04 | 2021-07-27T08:26:04 | 207,294,862 | 6 | 1 | MIT | 2022-11-22T04:52:11 | 2019-09-09T11:37:13 | Python | UTF-8 | Python | false | false | 1,040 | py |
# Generate a base file name
import time, os
import win32api
import win32evtlog
def BackupClearLog(logType):
datePrefix = time.strftime("%Y%m%d", time.localtime(time.time()))
fileExists = 1
retry = 0
while fileExists:
if retry == 0:
index = ""
else:
index = "-%d" % retry
try:
fname = os.path.join(win32api.GetTempPath(), "%s%s-%s" % (datePrefix, index, logType) + ".evt")
os.stat(fname)
except os.error:
fileExists = 0
retry = retry + 1
# OK - have unique file name.
try:
hlog = win32evtlog.OpenEventLog(None, logType)
except win32evtlogutil.error as details:
print("Could not open the event log", details)
return
try:
if win32evtlog.GetNumberOfEventLogRecords(hlog)==0:
print("No records in event log %s - not backed up" % logType)
return
win32evtlog.ClearEventLog(hlog, fname)
print("Backed up %s log to %s" % (logType, fname))
finally:
win32evtlog.CloseEventLog(hlog)
if __name__=='__main__':
BackupClearLog("Application")
BackupClearLog("System")
BackupClearLog("Security")
| [
"[email protected]"
] | |
e4781373c7e3b7491d6ba5776799f89dbb0ac3ec | e724c4340ddf8a99fe7d887b5cc5453e46e7eb29 | /src/main/python/pgshovel/streams/sequences.py | a2a0f8037ef84174e19d62a735d20e0797e5ace0 | [
"Apache-2.0"
] | permissive | fuziontech/pgshovel | 1789369e2db6c82deba08bb86504840cef705d8f | 5107a9885785f702340d421bbae9f6b82f44e98a | refs/heads/master | 2021-01-17T07:07:25.383805 | 2015-08-14T08:33:54 | 2015-08-14T17:15:02 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,271 | py | """
Tools for validating input streams.
"""
import logging
logger = logging.getLogger(__name__)
class SequencingError(Exception):
"""
Error raised when a message contains an invalid sequence value.
"""
class InvalidPublisher(SequencingError):
"""
Error raised when a message is received from an unexpected publisher.
"""
class RepeatedSequenceError(SequencingError):
"""
Error raised when a sequence value is reused for a different message from
the same publisher.
"""
class InvalidSequenceStartError(Exception):
"""
Error raised when a message is recieved from a new publisher that starts
at an incorrect sequence value.
"""
def validate(messages):
"""
Validates a stream of Message instances, ensuring that the correct
sequencing order is maintained, all messages are present, and only a single
publisher is communicating on the stream.
Duplicate messages are dropped if they have already been yielded.
"""
# TODO: Also warn on non-monotonic timestamp advancement.
previous = None
# All of the publishers that have been previously seen during the execution
# of this validator. (Does not include the currently active publisher.)
dead = set()
for message in messages:
if message.header.publisher in dead:
raise InvalidPublisher('Received message from previously used publisher.')
if previous is not None:
if previous.header.publisher == message.header.publisher:
# If the message we just received is exactly the same as the
# previous message, we can safely ignore it. (This could happen
# if the publisher is retrying a message that was not fully
# acknowledged before being partitioned from the recipient, but
# was actually written.)
if previous.header.sequence == message.header.sequence:
if previous == message:
logger.debug('Skipping duplicate message.')
continue
else:
raise RepeatedSequenceError(previous, message)
elif previous.header.sequence + 1 != message.header.sequence:
raise SequencingError(
'Invalid sequence: {0} to {1}'.format(
previous.header.sequence,
message.header.sequence,
)
)
else:
logger.info(
'Publisher of %r has changed from %r to %r.',
messages,
previous.header.publisher,
message.header.publisher,
)
dead.add(previous.header.publisher)
previous = None
# TODO: This needs to handle starting consumption in the middle of the
# stream somehow.
if previous is None and message.header.sequence != 0:
raise InvalidSequenceStartError(
'Invalid sequence start point: {0}'.format(
message.header.sequence,
)
)
yield message
previous = message
| [
"[email protected]"
] | |
783e84a8fb9c3cbbecc3557157aa5917430ac426 | 53fab060fa262e5d5026e0807d93c75fb81e67b9 | /backup/user_164/ch128_2020_04_01_18_11_42_129452.py | ab64e7a6ec6a5e0b2d75d17984dba66242fc56bb | [] | no_license | gabriellaec/desoft-analise-exercicios | b77c6999424c5ce7e44086a12589a0ad43d6adca | 01940ab0897aa6005764fc220b900e4d6161d36b | refs/heads/main | 2023-01-31T17:19:42.050628 | 2020-12-16T05:21:31 | 2020-12-16T05:21:31 | 306,735,108 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 446 | py | sim = ["sim"]
nao = ["nao"]
esta_se_movendo = input("Está se movendo?")
if esta_se_movendo in sim:
se_move = input("Deveria se mover?")
if se_move in sim:
print("Sem problemas!")
elif se_move in nao:
print("Silver Tape")
if esta_se_movendo in nao:
nao_se_move = input("Derveria se mover ?")
if esta_se_movendo in sim:
print ("Sem problemas!")
elif esta_se_movendo in nao:
print ("WD-40") | [
"[email protected]"
] | |
d782c90e1f40be5b2502d577a699d8d716c9955b | 1b4672de3ee7eb823fb2a238ea767fe0e1e11e7e | /shared/migrations/0001_initial.py | 0c89461bd8ba3895f44aa18c3d23aaeb018a4b11 | [] | no_license | FriedrichK/gamecoach | ce6510115e58286cc5eb56ddfbd35e7457639379 | cfa0d8c686cbc7b48cfc86e1feabd30d575f3039 | refs/heads/master | 2016-09-06T04:08:52.746047 | 2014-11-03T21:20:39 | 2014-11-03T21:20:39 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,278 | py | from south.v2 import DataMigration
from django.conf import settings
class Migration(DataMigration):
def forwards(self, orm):
site = self._forward_ensure_primary_site_is_set_up_correctly(orm)
self._forward_ensure_facebook_provider_exists(orm, site)
def _forward_ensure_primary_site_is_set_up_correctly(self, orm):
Site = orm['sites.Site']
site, created = Site.objects.get_or_create(id=settings.SITE_ID)
site.domain = settings.SITE_DOMAIN
site.name = settings.SITE_NAME
site.save()
return site
def _forward_ensure_facebook_provider_exists(self, orm, site):
SocialApp = orm['socialaccount.SocialApp']
provider, created = SocialApp.objects.get_or_create(provider='facebook', name='Facebook')
provider.secret = settings.FACEBOOK_APP_SECRET
provider.client_id = settings.FACEBOOK_APP_ID
provider.key = ''
provider.sites.add(site)
provider.save()
return provider
def backwards(self, orm):
pass
models = {
'sites.site': {
'Meta': {'ordering': "('domain',)", 'object_name': 'Site', 'db_table': "'django_site'"},
'domain': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'socialaccount.socialapp': {
'Meta': {'object_name': 'SocialApp'},
'client_id': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'key': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '40'}),
'provider': ('django.db.models.fields.CharField', [], {'max_length': '30'}),
'secret': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'sites': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['sites.Site']", 'symmetrical': 'False', 'blank': 'True'})
}
}
complete_apps = ['shared']
| [
"[email protected]"
] | |
a97a18124e03c1c5cba179560a3a8bcc88bc64ae | f3472d0f7c4c15d978dc74520ecebc7b6396da78 | /tests/http/test_request_data_property.py | 0d147ccbed4c4a77b5fe7fb35156fb3fa65c8468 | [
"MIT"
] | permissive | Lookyan/flex | a5b18e7f69ab4bc98ef810deebc22733b5346e4a | 284ea6d5b5a5f65d7f4abbe9d36ca6f31567c0ec | refs/heads/master | 2021-01-16T17:40:58.428296 | 2016-10-12T11:49:18 | 2016-10-12T11:49:18 | 67,237,824 | 0 | 1 | null | 2016-09-02T16:23:14 | 2016-09-02T16:23:13 | null | UTF-8 | Python | false | false | 898 | py | import pytest
import json
from flex.constants import EMPTY
from tests.factories import (
RequestFactory,
)
def test_null_body_returns_null():
request = RequestFactory(body=None)
assert request.data is None
def test_empty_string_body_returns_empty_string():
request = RequestFactory(body='')
assert request.data == ''
def test_empty_body_returns_empty():
request = RequestFactory(body=EMPTY)
assert request.data is EMPTY
def test_json_content_type_with_json_body():
request = RequestFactory(
body=json.dumps({'key': 'value'}),
content_type='application/json',
)
assert request.data == {'key': 'value'}
def test_unsupported_content_type():
request = RequestFactory(
body=json.dumps({'key': 'value'}),
content_type='application/unsupported',
)
with pytest.raises(NotImplementedError):
request.data
| [
"[email protected]"
] | |
c600389a03e33cbfd54ea9b4103aba8b123f1cc5 | aa3f670fcc2b43d8a5eb8a131082510bed2eb4d8 | /scripts/ingestors/nass_quickstats.py | 2b7ee785badec8b6d8ea7c1b583e03b7621a4a51 | [
"MIT"
] | permissive | jamayfieldjr/iem | e0d496311d82790ad518c600c2fcffe44e834da1 | 275b77a65f3b12e26e6cbdb230786b9c7d2b9c9a | refs/heads/master | 2020-08-07T11:55:56.256857 | 2019-10-04T04:22:36 | 2019-10-04T04:22:36 | 213,439,554 | 1 | 0 | MIT | 2019-10-07T17:01:20 | 2019-10-07T17:01:20 | null | UTF-8 | Python | false | false | 5,165 | py | """Dump NASS Quickstats to the IEM database"""
from __future__ import print_function
import sys
import subprocess
import datetime
import os
import pandas as pd
from pyiem.util import get_dbconn
TMP = "/mesonet/tmp"
def get_file():
"""Download and gunzip the file from the FTP site"""
os.chdir("/mesonet/tmp")
if os.path.isfile("%s/qstats.txt" % (TMP, )):
print(' skipping download as we already have the file')
return
for i in range(0, -7, -1):
now = datetime.date.today() + datetime.timedelta(days=i)
fn = "qs.crops_%s.txt.gz" % (now.strftime("%Y%m%d"),)
cmd = ("wget -q "
"ftp://ftp.nass.usda.gov/quickstats/%s") % (fn, )
proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
proc.stdout.read()
if os.path.isfile(fn):
break
cmd = "cd %s; mv %s qstats.txt.gz; gunzip qstats.txt.gz" % (TMP, fn)
# Popen is async, so we need to read from it!
proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
proc.stdout.read()
def database(pgconn, df):
"""Save df to the database!"""
cursor = pgconn.cursor()
cursor.execute("""SET TIME ZONE 'UTC'""")
df.columns = [x.lower() for x in df.columns]
df = df.where((pd.notnull(df)), None)
df['num_value'] = pd.to_numeric(df['value'], errors='coerce')
df2 = df[df['commodity_desc'].isin(['CORN', 'SOYBEANS'])]
for _, row in df2.iterrows():
try:
# If we are not in addall mode, we have to be careful!
cursor.execute("""
INSERT into nass_quickstats(source_desc, sector_desc,
group_desc,
commodity_desc,
class_desc,
prodn_practice_desc,
util_practice_desc,
statisticcat_desc,
unit_desc,
agg_level_desc,
state_alpha,
asd_code,
county_ansi,
zip_5,
watershed_code,
country_code,
year,
freq_desc,
begin_code,
end_code,
week_ending,
load_time,
value,
cv,
num_value) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s,
%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
""", (row['source_desc'], row['sector_desc'], row['group_desc'],
row['commodity_desc'],
row['class_desc'],
row['prodn_practice_desc'],
row['util_practice_desc'],
row['statisticcat_desc'],
row['unit_desc'],
row['agg_level_desc'],
row['state_alpha'],
row['asd_code'],
row['county_ansi'],
row['zip_5'],
row['watershed_code'],
row['country_code'],
row['year'],
row['freq_desc'],
row['begin_code'],
row['end_code'],
row['week_ending'],
row['load_time'],
row['value'],
row['cv_%'],
row['num_value']))
except Exception as exp:
print(exp)
for key in row.keys():
print("%s %s %s" % (key, row[key], len(str(row[key]))))
sys.exit()
print(' processed %6s lines from %6s candidates' % (len(df2.index),
len(df.index)))
cursor.close()
pgconn.commit()
def process(pgconn):
"""Do some work"""
# The file is way too big (11+ GB) to be reliably read into pandas, so
# we need to do some chunked processing.
cursor = pgconn.cursor()
cursor.execute("truncate nass_quickstats")
cursor.close()
pgconn.commit()
header = ""
tmpfn = None
accumlines = 0
for linenum, line in enumerate(open("%s/qstats.txt" % (TMP, ))):
if linenum == 0:
header = line
if tmpfn is None:
tmpfn = '/mesonet/tmp/tempor.txt'
fh = open(tmpfn, 'w')
fh.write(header+"\n")
if linenum > 0:
fh.write(line+"\n")
accumlines += 1
if accumlines >= 600000:
fh.close()
df = pd.read_csv(tmpfn, sep='\t', low_memory=False)
database(pgconn, df)
tmpfn = None
accumlines = 0
if accumlines > 0:
fh.close()
df = pd.read_csv(tmpfn, sep='\t', low_memory=False)
database(pgconn, df)
def cleanup():
"""Cleanup after ourselves"""
for fn in ['%s/qstats.txt' % (TMP, ), '%s/tempor.txt' % (TMP, )]:
print(' Deleted %s' % (fn, ))
os.unlink(fn)
def main(argv):
"""Go Main Go"""
pgconn = get_dbconn('coop')
print("scripts/ingestors/nass_quickstats.py")
get_file()
process(pgconn)
if len(argv) == 1:
cleanup()
print("done...")
if __name__ == '__main__':
main(sys.argv)
| [
"[email protected]"
] | |
94e54f003e8bf858139be8bc41ecdd20852a0d7b | 3e149e35fbe53c190d74da8b68a12a472e0e6552 | /footer_project/templatetags/footer_tags.py | f94449355897e353ddb401a08e4359feb5aeccc5 | [] | no_license | kamral/official_student_project | 20a5c02fc0a7769f209c33a8eeee6a3f748ea647 | fc585a20d46b858204c643cfa7f7b6f3e3a1655f | refs/heads/main | 2023-02-22T16:41:28.269882 | 2021-01-18T11:41:19 | 2021-01-18T11:41:19 | 323,295,350 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,229 | py | from django import template
from footer_project.models import \
About_Company_Category,\
Opportunities_category,\
Ourpartners_category
register=template.Library()
@register.simple_tag()
def get_about_company_categories(name='get_about_company_categories'):
return About_Company_Category.objects.all()
@register.simple_tag()
def get_oportunities_categories():
return Opportunities_category.objects.all()
@register.simple_tag()
def get_ourpartners_category():
return Ourpartners_category.objects.all()
@register.inclusion_tag('templatetags_categories_footer/about_company_categories.html')
def show_categories_about_company():
categories=About_Company_Category.objects.all()
return {'about_company_categories':categories}
@register.inclusion_tag('templatetags_categories_footer/oportunities_category.html')
def show_categories_oportunities_category():
categories=Opportunities_category.objects.all()
return {'oportunities_category':categories}
@register.inclusion_tag('templatetags_categories_footer/ourpartners_category.html')
def show_ourpartners_category():
category=Ourpartners_category.objects.all()
return {'ourpartners_category':category}
| [
"[email protected]"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.