blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
616
| content_id
stringlengths 40
40
| detected_licenses
listlengths 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
listlengths 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)),
],
),
]
|
[
"asadullah.itcgcs@gmail.com"
] |
asadullah.itcgcs@gmail.com
|
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()
|
[
"59328810+namujinju@users.noreply.github.com"
] |
59328810+namujinju@users.noreply.github.com
|
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])
|
[
"noreply@github.com"
] |
ssangitha.noreply@github.com
|
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'
}
)
|
[
"1159254961@qq.com"
] |
1159254961@qq.com
|
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})
|
[
"xwp_fullstack@163.com"
] |
xwp_fullstack@163.com
|
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])
|
[
"mary.jereh@gmail.com"
] |
mary.jereh@gmail.com
|
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
|
[
"you@example.com"
] |
you@example.com
|
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 -------------------------------------------------
|
[
"noreply@github.com"
] |
LaurenDebruyn.noreply@github.com
|
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
|
[
"82406273+mlx-bot@users.noreply.github.com"
] |
82406273+mlx-bot@users.noreply.github.com
|
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()))))
|
[
"david.vlaminck@mow.vlaanderen.be"
] |
david.vlaminck@mow.vlaanderen.be
|
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
# ##################################################
|
[
"bkhoward@live.com"
] |
bkhoward@live.com
|
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='fanstatic@googlegroups.com',
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'
|
[
"sahadina10@gmail.com"
] |
sahadina10@gmail.com
|
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,
})
|
[
"albert12132@gmail.com"
] |
albert12132@gmail.com
|
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())
|
[
"tpxsky@163.com"
] |
tpxsky@163.com
|
|
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)))
|
[
"noreply@github.com"
] |
g147.noreply@github.com
|
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
)
|
[
"noreply@github.com"
] |
YijunXieMS.noreply@github.com
|
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)
|
[
"daniel.martin.sheehan@gmail.com"
] |
daniel.martin.sheehan@gmail.com
|
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())
|
[
"jainendra.kumar@oracle.com"
] |
jainendra.kumar@oracle.com
|
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)
|
[
"playpauseandstop@gmail.com"
] |
playpauseandstop@gmail.com
|
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()
|
[
"alex@grep.ro"
] |
alex@grep.ro
|
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)
|
[
"moon.qiu198909@hotmail.com"
] |
moon.qiu198909@hotmail.com
|
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
|
[
"mehdy@google.com"
] |
mehdy@google.com
|
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()
|
[
"jgross@mit.edu"
] |
jgross@mit.edu
|
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"))
|
[
"mary.jereh@gmail.com"
] |
mary.jereh@gmail.com
|
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
"""
|
[
"jversoza@cs.nyu.edu"
] |
jversoza@cs.nyu.edu
|
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
|
[
"dustin@virtualroadside.com"
] |
dustin@virtualroadside.com
|
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
|
[
"msplanchard@gmail.com"
] |
msplanchard@gmail.com
|
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 []
|
[
"noreply@github.com"
] |
chetankhopade.noreply@github.com
|
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
)
|
[
"noreply@github.com"
] |
huawei-noah.noreply@github.com
|
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}")
|
[
"wangjiangben@huawei.com"
] |
wangjiangben@huawei.com
|
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)
|
[
"riceissa@gmail.com"
] |
riceissa@gmail.com
|
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
|
[
"1052632241@qq.com"
] |
1052632241@qq.com
|
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
|
[
"dg1732004@smail.nju.edu.cn"
] |
dg1732004@smail.nju.edu.cn
|
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()
|
[
"you@example.com"
] |
you@example.com
|
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:])
|
[
"coricozizi@gmail.com"
] |
coricozizi@gmail.com
|
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)
|
[
"noreply@github.com"
] |
Ponkiruthika112.noreply@github.com
|
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"
|
[
"giordani.leonardo@gmail.com"
] |
giordani.leonardo@gmail.com
|
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)
|
[
"vanvalen@gmail.com"
] |
vanvalen@gmail.com
|
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
|
[
"marc@cs.brandeis.edu"
] |
marc@cs.brandeis.edu
|
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()
|
[
"you@example.com"
] |
you@example.com
|
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)
|
[
"1069583789@qq.com"
] |
1069583789@qq.com
|
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()
|
[
"adam@omniwiki.co.uk"
] |
adam@omniwiki.co.uk
|
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 aafshar@gmail.com
#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()
|
[
"michal.stechly@gmail.com"
] |
michal.stechly@gmail.com
|
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),
),
]
|
[
"team@crowdbotics.com"
] |
team@crowdbotics.com
|
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)
|
[
"MK_Devil@163.com"
] |
MK_Devil@163.com
|
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)
)
|
[
"sdk-team@alibabacloud.com"
] |
sdk-team@alibabacloud.com
|
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
|
[
"noreply@github.com"
] |
xiaogaogaoxiao.noreply@github.com
|
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)
|
[
"atsuhisa.1124@gmail.com"
] |
atsuhisa.1124@gmail.com
|
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
|
[
"info@nielsdevries.net"
] |
info@nielsdevries.net
|
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]))
|
[
"647530+Virtlink@users.noreply.github.com"
] |
647530+Virtlink@users.noreply.github.com
|
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)
|
[
"xxshss@yahoo.co.jp"
] |
xxshss@yahoo.co.jp
|
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")
|
[
"noreply@github.com"
] |
vivimouret29.noreply@github.com
|
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),
),
]
|
[
"katherine.erickson@gmail.com"
] |
katherine.erickson@gmail.com
|
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')]),
),
]
|
[
"1079614505@qq.com"
] |
1079614505@qq.com
|
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()
|
[
"support@lipcoins.org"
] |
support@lipcoins.org
|
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
|
[
"hwcloudsdk@huawei.com"
] |
hwcloudsdk@huawei.com
|
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()
|
[
"benjaminrk@gmail.com"
] |
benjaminrk@gmail.com
|
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',
),
]
|
[
"bmshamsulhaq65@gmail.com"
] |
bmshamsulhaq65@gmail.com
|
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))} }}'
|
[
"oz.sasha.ivanov@gmail.com"
] |
oz.sasha.ivanov@gmail.com
|
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)
|
[
"dg1732004@smail.nju.edu.cn"
] |
dg1732004@smail.nju.edu.cn
|
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='kunal@lol.lol')
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='lol@lol.lol')
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'))
|
[
"k.mehta@berkeley.edu"
] |
k.mehta@berkeley.edu
|
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
|
[
"daniel.reich@danielreichs-MacBook-Pro.local"
] |
daniel.reich@danielreichs-MacBook-Pro.local
|
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()
|
[
"mrdh94@naver.com"
] |
mrdh94@naver.com
|
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()
|
[
"danielrsoto@gmail.com"
] |
danielrsoto@gmail.com
|
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])
|
[
"ybliang8@gmail.com"
] |
ybliang8@gmail.com
|
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
|
[
"noreply@github.com"
] |
cgtobi.noreply@github.com
|
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)
|
[
"noreply@github.com"
] |
qxzsilver1.noreply@github.com
|
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 in.kim@kaist.ac.kr
""" % 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)
|
[
"hopefulp@gmail.com"
] |
hopefulp@gmail.com
|
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
|
[
"la236am@users.isi.deterlab.net"
] |
la236am@users.isi.deterlab.net
|
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)
|
[
"ermiasgelaye@gmail.com"
] |
ermiasgelaye@gmail.com
|
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
)
|
[
"noreply@github.com"
] |
sh00t2kill.noreply@github.com
|
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
|
[
"CommanderPho@users.noreply.github.com"
] |
CommanderPho@users.noreply.github.com
|
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'
|
[
"ubuntu@ip-172-31-7-228.us-west-2.compute.internal"
] |
ubuntu@ip-172-31-7-228.us-west-2.compute.internal
|
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()
|
[
"elesun2018@gmail.com"
] |
elesun2018@gmail.com
|
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)
|
[
"noeliarico@uniovi.es"
] |
noeliarico@uniovi.es
|
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)
|
[
"yichen@positron01.hep.caltech.edu"
] |
yichen@positron01.hep.caltech.edu
|
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)
|
[
"dklothe@skylineinnovations.com"
] |
dklothe@skylineinnovations.com
|
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)
|
[
"root@localhost.localdomain"
] |
root@localhost.localdomain
|
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)
|
[
"public@paulstack.co.uk"
] |
public@paulstack.co.uk
|
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)
|
[
"sangmin3285@gmail.com"
] |
sangmin3285@gmail.com
|
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'
}
]
}
|
[
"city7310@naver.com"
] |
city7310@naver.com
|
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),
])
|
[
"48147775+BiancaChirica@users.noreply.github.com"
] |
48147775+BiancaChirica@users.noreply.github.com
|
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''})
|
[
"ubuntu@ip-172-31-7-228.us-west-2.compute.internal"
] |
ubuntu@ip-172-31-7-228.us-west-2.compute.internal
|
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)
|
[
"geofferyjoseph1@gmail.com"
] |
geofferyjoseph1@gmail.com
|
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
|
[
"eduardoluissd@gmail.com"
] |
eduardoluissd@gmail.com
|
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()
|
[
"drew@nebulaworks.com"
] |
drew@nebulaworks.com
|
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))
|
[
"hrafnl@gmail.com"
] |
hrafnl@gmail.com
|
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))
|
[
"122@holbertonschool.com"
] |
122@holbertonschool.com
|
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',
),
]
|
[
"guillaume@felley.io"
] |
guillaume@felley.io
|
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 <milan.cermak@gmail.com>
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())}})
|
[
"martinrusev@zoho.com"
] |
martinrusev@zoho.com
|
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),
)
|
[
"copybara-worker@google.com"
] |
copybara-worker@google.com
|
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")
|
[
"keun0390@naver.com"
] |
keun0390@naver.com
|
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
|
[
"ted@kaemming.com"
] |
ted@kaemming.com
|
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")
|
[
"you@example.com"
] |
you@example.com
|
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']
|
[
"friedrich@cartogami.com"
] |
friedrich@cartogami.com
|
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
|
[
"piper@simpleenergy.com"
] |
piper@simpleenergy.com
|
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)
|
[
"akrherz@iastate.edu"
] |
akrherz@iastate.edu
|
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}
|
[
"kamral010101@gmail.com"
] |
kamral010101@gmail.com
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.